| from __future__ import annotations |
|
|
| import itertools |
| from dataclasses import dataclass, field, asdict |
| from typing import ( |
| Any, |
| Dict, |
| Iterable, |
| List, |
| Optional, |
| Tuple, |
| TypeAlias, |
| Union, |
| TYPE_CHECKING, |
| ) |
|
|
| import requests |
|
|
| if TYPE_CHECKING: |
| from autoresttest.graph.generate_graph import OperationEdge |
|
|
|
|
| def to_dict_helper(item: Any) -> Any: |
| """Convert nested dataclasses, dictionaries, and iterables into serialisable structures.""" |
| if hasattr(item, "to_dict"): |
| return item.to_dict() |
| if isinstance(item, dict): |
| converted = {} |
| for key, value in item.items(): |
| if value is None: |
| continue |
| converted_key = ( |
| "|".join("" if part is None else str(part) for part in key) |
| if isinstance(key, tuple) |
| else key |
| ) |
| converted[converted_key] = to_dict_helper(value) |
| return {key: value for key, value in converted.items() if value is not None} |
| if isinstance(item, Iterable) and not isinstance(item, (str, bytes)): |
| converted = [to_dict_helper(element) for element in item] |
| return [value for value in converted if value is not None] |
| return item |
|
|
|
|
| |
| ParameterKey: TypeAlias = tuple[str, str | None] |
|
|
|
|
| def is_parameter_key(value: Any) -> bool: |
| """ |
| Check if a value is essentially a ParameterKey (tuple of length 2 with str, str|None). |
| """ |
| if not isinstance(value, tuple) or len(value) != 2: |
| return False |
| name, in_value = value |
| return isinstance(name, str) and (in_value is None or isinstance(in_value, str)) |
|
|
|
|
| @dataclass |
| class ResponseProperties: |
| """Stores the properties of an HTTP response.""" |
|
|
| status_code: int = -1 |
| description: Optional[str] = None |
| content: Dict[str, "SchemaProperties"] = field(default_factory=dict) |
|
|
| def to_dict(self) -> Dict[str, Any]: |
| return to_dict_helper(asdict(self)) |
|
|
|
|
| @dataclass |
| class SchemaProperties: |
| """Represents schema properties for parameters or request bodies.""" |
|
|
| type: Optional[str] = None |
| format: Optional[str] = None |
| description: Optional[str] = None |
| items: Optional["SchemaProperties"] = None |
| properties: Optional[Dict[str, "SchemaProperties"]] = None |
| required: List[str] = field(default_factory=list) |
| default: Optional[Union[str, int, float, bool, List, Dict]] = None |
| enum: List[str] = field(default_factory=list) |
| minimum: Optional[int] = None |
| maximum: Optional[int] = None |
| min_length: Optional[int] = None |
| max_length: Optional[int] = None |
| pattern: Optional[str] = None |
| max_items: Optional[int] = None |
| min_items: Optional[int] = None |
| unique_items: Optional[bool] = None |
| additional_properties: Union[bool, "SchemaProperties", None] = True |
| nullable: Optional[bool] = None |
| read_only: Optional[bool] = None |
| write_only: Optional[bool] = None |
| example: Optional[Union[str, int, float, bool, List, Dict]] = None |
| examples: List[Optional[Union[str, int, float, bool, List, Dict]]] = field( |
| default_factory=list |
| ) |
|
|
| def to_dict(self) -> Dict[str, Any]: |
| return to_dict_helper(asdict(self)) |
|
|
|
|
| @dataclass |
| class ParameterProperties: |
| """Stores the properties of an OpenAPI parameter.""" |
|
|
| name: str = "" |
| in_value: Optional[str] = None |
| description: Optional[str] = None |
| required: Optional[bool] = None |
| deprecated: Optional[bool] = None |
| allow_empty_value: Optional[bool] = None |
| style: Optional[str] = None |
| explode: Optional[bool] = None |
| allow_reserved: Optional[bool] = None |
| schema: Optional[SchemaProperties] = None |
| example: Optional[Union[str, int, float, bool, List, Dict]] = None |
| examples: List[Optional[Union[str, int, float, bool, List, Dict]]] = field( |
| default_factory=list |
| ) |
| content: Dict[str, SchemaProperties] = field(default_factory=dict) |
|
|
| def to_dict(self) -> Dict[str, Any]: |
| return to_dict_helper(asdict(self)) |
|
|
|
|
| @dataclass |
| class OperationProperties: |
| """Stores the properties of an OpenAPI operation.""" |
|
|
| operation_id: str = "" |
| endpoint_path: str = "" |
| http_method: str = "" |
| summary: Optional[str] = None |
| parameters: Dict[ParameterKey, ParameterProperties] = field(default_factory=dict) |
| request_body: Optional[Dict[str, SchemaProperties]] = None |
| responses: Optional[Dict[str, ResponseProperties]] = None |
|
|
| def to_dict(self) -> Dict[str, Any]: |
| return to_dict_helper(asdict(self)) |
|
|
|
|
| @dataclass |
| class RequestData: |
| """Encapsulates the request information derived from an operation.""" |
|
|
| endpoint_path: str |
| http_method: str |
| parameters: Dict[ParameterKey, Any] | None |
| request_body: Dict[str, Any] | None |
| operation_properties: OperationProperties |
| requirements: Optional["RequestRequirements"] = None |
|
|
|
|
| @dataclass |
| class RequestRequirements: |
| """Captures dependencies required to satisfy a request edge.""" |
|
|
| edge: "OperationEdge" |
| parameter_requirements: Dict[ParameterKey, Any] = field(default_factory=dict) |
| request_body_requirements: Dict[str, Any] = field(default_factory=dict) |
|
|
| def generate_combinations(self) -> List["RequestRequirements"]: |
| combinations: List[RequestRequirements] = [] |
|
|
| param_combinations: List[Dict[ParameterKey, Any]] = [] |
| if self.parameter_requirements: |
| for i in range(1, len(self.parameter_requirements) + 1): |
| for subset in itertools.combinations( |
| self.parameter_requirements.keys(), i |
| ): |
| param_combinations.append( |
| {key: self.parameter_requirements[key] for key in subset} |
| ) |
|
|
| body_combinations: List[Dict[str, Any]] = [] |
| if self.request_body_requirements: |
| for i in range(1, len(self.request_body_requirements) + 1): |
| for subset in itertools.combinations( |
| self.request_body_requirements.keys(), i |
| ): |
| body_combinations.append( |
| {key: self.request_body_requirements[key] for key in subset} |
| ) |
|
|
| if not param_combinations and not body_combinations: |
| return [self] |
|
|
| if not param_combinations: |
| for body_combination in body_combinations: |
| combinations.append( |
| RequestRequirements( |
| edge=self.edge, |
| parameter_requirements={}, |
| request_body_requirements=body_combination, |
| ) |
| ) |
| return combinations |
|
|
| if not body_combinations: |
| for param_combination in param_combinations: |
| combinations.append( |
| RequestRequirements( |
| edge=self.edge, |
| parameter_requirements=param_combination, |
| request_body_requirements={}, |
| ) |
| ) |
| return combinations |
|
|
| for param_combination in param_combinations: |
| for body_combination in body_combinations: |
| combinations.append( |
| RequestRequirements( |
| edge=self.edge, |
| parameter_requirements=param_combination, |
| request_body_requirements=body_combination, |
| ) |
| ) |
|
|
| combinations.sort( |
| key=lambda req: len(req.parameter_requirements) |
| + len(req.request_body_requirements), |
| reverse=True, |
| ) |
| return combinations |
|
|
|
|
| @dataclass |
| class RequestResponse: |
| """Pairs a request with its observed response.""" |
|
|
| request: RequestData |
| response: requests.Response |
| response_text: str |
|
|
|
|
| @dataclass |
| class ValueAction: |
| """Represents an action taken by the value agent.""" |
|
|
| param_mappings: Optional[Dict[ParameterKey, Any]] |
| body_mappings: Optional[Dict[str, Any]] |
|
|
|
|
| @dataclass |
| class SimilarityValue: |
| """Captures similarity metadata when comparing operations.""" |
|
|
| dependent_val: Union[str, ParameterKey] = "" |
| in_value: str = "" |
| similarity: float = 0.0 |
|
|
| def to_dict(self) -> Dict[str, Any]: |
| return { |
| "response": self.dependent_val, |
| "in_value": self.in_value, |
| "similarity": self.similarity, |
| } |
|
|
|
|
| __all__ = [ |
| "to_dict_helper", |
| "ResponseProperties", |
| "SchemaProperties", |
| "ParameterProperties", |
| "ParameterKey", |
| "is_parameter_key", |
| "OperationProperties", |
| "RequestData", |
| "RequestRequirements", |
| "RequestResponse", |
| "ValueAction", |
| "SimilarityValue", |
| ] |
|
|
