import json import logging import os import re from pathlib import Path from typing import Any, Dict, List, Set from prance import ResolvingParser, ValidationError as PranceValidationError from openapi_spec_validator.validation.exceptions import ( ValidationError as OASValidationError, # type: ignore[attr-defined] OpenAPIValidationError, ) from autoresttest.config import get_config from autoresttest.models import ( OperationProperties, ParameterKey, ParameterProperties, ResponseProperties, SchemaProperties, to_dict_helper, ) def json_spec_output(output_directory: Path, file_name: str, spec: Dict): """ Create a testing JSON file from the specification parsing output. """ output_file = output_directory / file_name with output_file.open("w", encoding="utf-8") as file: json.dump(spec, file, ensure_ascii=False, indent=4) CONFIG = get_config() def default_recursive_limit_handler( limit: int, parsed_url: Any, recursions: tuple[str, ...] = () ) -> dict[str, Any]: """ Prance invokes this handler when a circular/self-reference exceeds the recursion_limit. Parameters: limit: The configured recursion_limit value. parsed_url: The parsed URL of the reference that triggered the limit (contains the $ref path). recursions: Tuple of reference URLs that form the circular chain. Returns a placeholder schema to substitute for the circular reference. """ # Extract the reference name from the parsed URL fragment (e.g., "#/components/schemas/Node" -> "Node") ref_name = "self-reference" if parsed_url and hasattr(parsed_url, "fragment") and parsed_url.fragment: ref_name = parsed_url.fragment.split("/")[-1] return { "type": "object", "title": f"Circular Reference: {ref_name}", "description": f"circular_self_reference:{ref_name}", "properties": {}, } class LenientResolvingParser(ResolvingParser): """ ResolvingParser constructor calls: 1. RefResolver.resolve_references() 2. BaseParser._validate(self) -> openapi-spec-validator Override _validate to provide error on incorrect schemas instead of crashing """ def _validate(self): try: super()._validate() except ( PranceValidationError, OASValidationError, OpenAPIValidationError, ) as exc: logging.warning( "OpenAPI validation failed for %s; continuing with unvalidated " "specs. Error: %s", getattr(self, "url", None), exc, ) self.valid = False class SpecificationParser: """ Class to parse a specification file and return a dictionary of all the operations and their properties. """ def __init__(self, spec_path=None, spec_name=None): self.spec_path = spec_path self.spec_name = spec_name if spec_path is None: raise ValueError("No specification path provided.") self.resolving_parser = self._build_resolving_parser(spec_path) if self.resolving_parser.specification is None: raise ValueError("An error occurred during Prance specification parsing.") self.directory_path = ( "specs/aratrl-openapi/" # DEPRECATED - NOT USED IN EXECUTION ) self.all_specs = {} def _build_resolving_parser(self, spec_path): parser_cls = ( ResolvingParser if CONFIG.strict_validation else LenientResolvingParser ) return parser_cls( spec_path, backend="openapi-spec-validator", # AutoRestTest supports OAS 3.x strict=True, recursion_limit=CONFIG.recursion_limit, recursion_limit_handler=default_recursive_limit_handler, ) def get_api_url(self) -> str: """ Extract the server URL from the specification file. """ spec = self.resolving_parser.specification if spec is None: raise ValueError("Specification not initialized successfully.") servers = spec.get("servers") if not servers: raise ValueError("No servers defined in the OpenAPI specification.") first_server = servers[0] if not isinstance(first_server, dict): raise ValueError("Invalid server definition in the OpenAPI specification.") url = first_server.get("url") if not url: raise ValueError("Server URL is missing in the OpenAPI specification.") return url def get_api_title(self) -> str | None: """ Extract the title of the API from the specification file. """ spec = self.resolving_parser.specification if spec is None: return None info = spec.get("info") if not isinstance(info, dict): return None title = info.get("title") return title if isinstance(title, str) else None def process_parameter_object_properties( self, properties: Dict | None ) -> Dict[str, SchemaProperties] | None: """ Process the properties of a parameter of type object to return a dictionary of all the properties and their corresponding parameter values. """ if properties is None or not isinstance(properties, dict): return None object_properties = {} for name, values in properties.items(): object_properties.setdefault( name, self.process_parameter_schema(values) ) # check if this is correct, or if it should be process_parameter # Filter out None values from nested schema processing return {k: v for k, v in object_properties.items() if v is not None} def _infer_schema_type(self, schema: Dict) -> str | None: """Infer schema type from context when not explicitly provided.""" if schema.get("type"): return schema.get("type") # Array indicators if schema.get("items") is not None: return "array" # Object indicators if schema.get("properties") is not None: return "object" if schema.get("additionalProperties") is not None: return "object" # Infer from enum values enum = schema.get("enum") if enum and len(enum) > 0: first_val = enum[0] if isinstance(first_val, bool): return "boolean" if isinstance(first_val, int): return "integer" if isinstance(first_val, float): return "number" if isinstance(first_val, str): return "string" # Numeric constraint indicators if any( schema.get(k) is not None for k in ("minimum", "maximum", "multipleOf", "exclusiveMinimum", "exclusiveMaximum") ): return "number" # String constraint indicators if any(schema.get(k) is not None for k in ("minLength", "maxLength", "pattern")): return "string" return None def process_parameter_schema( self, schema: Dict | None, description: str | None = None ) -> SchemaProperties | None: """ Process the schema of a parameter to return a ValueProperties object """ if not schema or not isinstance(schema, dict): return None value_properties = SchemaProperties( type=self._infer_schema_type(schema), format=schema.get("format"), description=schema.get("description") if not description else description, items=self.process_parameter_schema( schema.get("items") ), # recursively process items properties=self.process_parameter_object_properties( schema.get("properties") ), required=schema.get("required") or [], default=schema.get("default"), enum=schema.get("enum") or [], minimum=schema.get("minimum"), maximum=schema.get("maximum"), min_length=schema.get("minLength"), max_length=schema.get("maxLength"), pattern=schema.get("pattern"), max_items=schema.get("maxItems"), min_items=schema.get("minItems"), unique_items=schema.get("uniqueItems"), additional_properties=schema.get("additionalProperties"), nullable=schema.get("nullable"), read_only=schema.get("readOnly"), write_only=schema.get("writeOnly"), example=schema.get("example"), examples=schema.get("examples") or [], ) return value_properties def process_parameter(self, parameter: Any) -> ParameterProperties: """ Process an individual parameter to return a ParameterProperties object. """ if not isinstance(parameter, dict): return ParameterProperties() parameter_properties = ParameterProperties( name=parameter.get("name") or "", in_value=parameter.get("in"), description=parameter.get("description"), required=parameter.get("required"), deprecated=parameter.get("deprecated"), allow_empty_value=parameter.get("allowEmptyValue"), style=parameter.get("style"), explode=parameter.get("explode"), allow_reserved=parameter.get("allowReserved"), ) if parameter.get("schema"): parameter_properties.schema = self.process_parameter_schema( parameter.get("schema") ) return parameter_properties def process_parameters( self, parameter_list ) -> Dict[ParameterKey, ParameterProperties]: """ Process the parameters list to return a Dictionary with all its properties and values. """ parameters = {} if parameter_list: for parameter in parameter_list: parameter_properties = self.process_parameter(parameter) if not parameter_properties.name: continue key = (parameter_properties.name, parameter_properties.in_value) parameters[key] = parameter_properties return parameters def process_request_body(self, request_body) -> Dict[str, SchemaProperties]: """ Process the request body to return a Dictionary with mime type and its properties and values. """ request_body_properties = {} content = request_body.get("content") description = request_body.get("description") if content: for mime_type, mime_details in content.items(): # if we need to check required list, do it here schema = mime_details.get("schema") if schema: request_body_properties[mime_type] = self.process_parameter_schema( schema, description ) return request_body_properties def process_responses(self, responses) -> Dict[str, ResponseProperties]: """ Process the responses to return a Dictionary with status code and its properties and values. """ response_properties = {} for status_code, response_details in responses.items(): response_properties.setdefault( status_code, ResponseProperties( status_code=status_code, description=response_details.get("description"), ), ) content = response_details.get("content") if content: for mime_type, mime_details in content.items(): # if we need to check required list, do it here schema = mime_details.get("schema") if schema: response_properties[status_code].content[mime_type] = ( self.process_parameter_schema(schema) ) return response_properties def process_operation_details( self, http_method: str, endpoint_path: str, operation_details: Dict, operation_id: str, merged_parameters: List[Dict], ) -> OperationProperties: """ Process the parameters and request body details within a given operation to return as OperationProperties object. """ operation_properties = OperationProperties( operation_id=operation_id, endpoint_path=endpoint_path, http_method=http_method, summary=operation_details.get("summary"), ) if merged_parameters: operation_properties.parameters = self.process_parameters( parameter_list=merged_parameters ) if operation_details.get("requestBody"): operation_properties.request_body = self.process_request_body( request_body=operation_details.get("requestBody") ) if operation_details.get("responses"): operation_properties.responses = self.process_responses( responses=operation_details.get("responses") ) # maybe add security details? return operation_properties def _normalize_endpoint_path(self, endpoint_path: str) -> str: """ Convert a path template to a safe string segment for fallback operationIds. """ normalized = endpoint_path.replace("{", "").replace("}", "") normalized = re.sub(r"[^a-zA-Z0-9]+", "_", normalized).strip("_") return normalized or "root" def _resolve_operation_id( self, http_method: str, endpoint_path: str, operation_details: Dict, seen_ids: Set[str], ) -> str: """ Use provided operationId when available; otherwise construct a unique, deterministic fallback. If a duplicate is detected, append an incrementing suffix to keep IDs unique. """ provided_id = operation_details.get("operationId") candidate = provided_id if provided_id else None if not candidate: normalized_path = self._normalize_endpoint_path(endpoint_path) candidate = f"{http_method.lower()}_{normalized_path}" base_candidate = candidate suffix = 1 while candidate in seen_ids: candidate = f"{base_candidate}_{suffix}" suffix += 1 if provided_id and candidate != provided_id: logging.warning( "Duplicate operationId '%s' for %s %s; using '%s' to avoid collision.", provided_id, http_method, endpoint_path, candidate, ) return candidate def _merge_parameters( self, path_parameters: List[Dict], operation_parameters: List[Dict] ) -> List[Dict]: """ Merge path-level and operation-level parameters, letting operation-level definitions override matching path-level parameters (by (name, in)). """ merged: Dict[ParameterKey, Dict] = {} for raw_param in path_parameters or []: if isinstance(raw_param, dict): name = raw_param.get("name") if name is not None: merged[(name, raw_param.get("in"))] = raw_param for raw_param in operation_parameters or []: if isinstance(raw_param, dict): name = raw_param.get("name") if name is not None: merged[(name, raw_param.get("in"))] = raw_param return list(merged.values()) def parse_specification(self) -> Dict[str, OperationProperties]: """ Parse the specification file to return a dictionary of all the operations and their properties. The key of the dictionary is the operationId and the value is an OperationProperties object. """ supported_methods = {"get", "post", "put", "delete", "head", "options", "patch"} operation_collection = {} seen_ids: Set[str] = set() spec = self.resolving_parser.specification if spec is None: return operation_collection spec_paths = spec.get("paths", {}) if not isinstance(spec_paths, dict): spec_paths = {} for endpoint_path, endpoint_details in spec_paths.items(): if not isinstance(endpoint_details, dict): continue path_level_parameters = endpoint_details.get("parameters", []) for http_method, operation_details in endpoint_details.items(): if http_method in supported_methods: merged_parameters = self._merge_parameters( path_level_parameters, operation_details.get("parameters", []) ) operation_id = self._resolve_operation_id( http_method, endpoint_path, operation_details, seen_ids ) seen_ids.add(operation_id) operation_properties = self.process_operation_details( http_method, endpoint_path, operation_details, operation_id, merged_parameters, ) operation_collection[operation_id] = operation_properties return operation_collection def parse_all_specifications(self) -> dict[str, dict[str, OperationProperties]]: """ Parse all the specification files in the directory to return a dictionary of all the operations and their properties. """ for file_name in os.listdir(self.directory_path): print("Specification parsing for file: ", file_name) self.spec_path = os.path.join(self.directory_path, file_name) self.resolving_parser = self._build_resolving_parser(self.spec_path) self.all_specs[file_name] = self.parse_specification() # print("Output: " + str(output)) return self.all_specs def all_json_spec_output(self): """ Create a testing JSON file from the specification parsing output. """ all_specs = { file_name: to_dict_helper(spec) for file_name, spec in self.all_specs.items() } output_directory = Path("./testing_output") output_directory.mkdir(parents=True, exist_ok=True) for file_name, spec in all_specs.items(): json_spec_output(output_directory, file_name, spec) def single_json_spec_output(self): output_directory = Path("./testing_output") output_directory.mkdir(parents=True, exist_ok=True) output = self.parse_specification() file_name = self.spec_name if self.spec_name else "spec_output.json" json_spec_output(output_directory, file_name, to_dict_helper(output)) if __name__ == "__main__": # testing # spec_path = os.path.normpath("../../aratrl-openapi/project.yaml") spec_path = os.path.normpath("kafka-rest.yaml") spec_parser = SpecificationParser(spec_name="project", spec_path=spec_path) spec_parser.parse_specification() print(spec_parser.parse_specification()) # spec_parser.single_json_spec_output() # spec_parser.parse_all_specifications() # spec_parser.all_json_spec_output() # spec_parser = SpecificationParser(spec_path="../specs/original/oas/genome-nexus.yaml", spec_name="genome-nexus") # spec_parser.single_json_spec_output() # output = spec_parser.parse_specification() # print(output["fetchPostTranslationalModificationsByPtmFilterPOST"]) # print(output["endpoint-add-tracks-to-playlist"]) # print(output["endpoint-get-playlist"]) # print(output["endpoint-remove-tracks-playlist"])