robotframework-openapitools 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

OpenApiLibCore/openapi_libcore.py

@@ -152,6 +152,11 @@ from OpenApiLibCore.dto_utils import (
     get_dto_class,
     get_id_property_name,
 )
+from OpenApiLibCore.localized_faker import FAKE
+from OpenApiLibCore.models import (
+    OpenApiObject,
+    PathItemObject,
+)
 from OpenApiLibCore.oas_cache import PARSER_CACHE, CachedParser
 from OpenApiLibCore.parameter_utils import (
     get_oas_name_from_safe_name,
@@ -159,11 +164,10 @@ from OpenApiLibCore.parameter_utils import (
 )
 from OpenApiLibCore.protocols import ResponseValidatorType
 from OpenApiLibCore.request_data import RequestData, RequestValues
-from OpenApiLibCore.value_utils import FAKE
 
 run_keyword = BuiltIn().run_keyword
 default_str_mapping: Mapping[str, str] = MappingProxyType({})
-default_any_mapping: Mapping[str, object] = MappingProxyType({})
+default_json_mapping: Mapping[str, JSON] = MappingProxyType({})
 
 
 @library(scope="SUITE", doc_format="ROBOT")
@@ -434,7 +438,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         self,
         path: str,
         method: str,
-        overrides: Mapping[str, object] = default_any_mapping,
+        overrides: Mapping[str, JSON] = default_json_mapping,
     ) -> RequestValues:
         """Return an object with all (valid) request values needed to make a request."""
         json_data: dict[str, JSON] = {}
@@ -482,24 +486,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         )
 
     @keyword
-    def get_json_data_for_dto_class(
-        self,
-        schema: dict[str, JSON],
-        dto_class: type[Dto],
-        operation_id: str = "",
-    ) -> JSON:
-        """
-        Generate valid (json-compatible) data for the `dto_class`.
-        """
-        return _data_generation.get_json_data_for_dto_class(
-            schema=schema,
-            dto_class=dto_class,
-            get_id_property_name=self.get_id_property_name,
-            operation_id=operation_id,
-        )
-
-    @keyword
-    def get_invalid_json_data(
+    def get_invalid_body_data(
         self,
         url: str,
         method: str,
@@ -513,7 +500,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         > Note: applicable UniquePropertyValueConstraint and IdReference Relations are
             considered before changes to `json_data` are made.
         """
-        return di.get_invalid_json_data(
+        return di.get_invalid_body_data(
             url=url,
             method=method,
             status_code=status_code,
@@ -526,7 +513,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         self,
         status_code: int,
         request_data: RequestData,
-    ) -> tuple[dict[str, JSON], dict[str, str]]:
+    ) -> tuple[dict[str, JSON], dict[str, JSON]]:
         """
         Returns a version of `params, headers` as present on `request_data` that has
         been modified to cause the provided `status_code`.
@@ -706,7 +693,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         path: str,
         status_code: int,
         request_values: RequestValues,
-        original_data: Mapping[str, object] = default_any_mapping,
+        original_data: Mapping[str, JSON] = default_json_mapping,
     ) -> None:
         """
         This keyword first calls the Authorized Request keyword, then the Validate
@@ -751,7 +738,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         self,
         path: str,
         response: Response,
-        original_data: Mapping[str, object] = default_any_mapping,
+        original_data: Mapping[str, JSON] = default_json_mapping,
     ) -> None:
         """
         Validate the `response` by performing the following validations:
@@ -775,24 +762,11 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
             original_data=original_data,
         )
 
-    @keyword
-    def validate_resource_properties(
-        self, resource: dict[str, JSON], schema: dict[str, JSON]
-    ) -> None:
-        """
-        Validate that the `resource` does not contain any properties that are not
-        defined in the `schema_properties`.
-        """
-        val.validate_resource_properties(
-            resource=resource,
-            schema=schema,
-        )
-
     @staticmethod
     @keyword
     def validate_send_response(
         response: Response,
-        original_data: Mapping[str, object] = default_any_mapping,
+        original_data: Mapping[str, JSON] = default_json_mapping,
     ) -> None:
         """
         Validate that each property that was send that is in the response has the value
@@ -818,17 +792,17 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         return validation_spec
 
     @property
-    def openapi_spec(self) -> dict[str, JSON]:
+    def openapi_spec(self) -> OpenApiObject:
         """Return a deepcopy of the parsed openapi document."""
         # protect the parsed openapi spec from being mutated by reference
         return deepcopy(self._openapi_spec)
 
     @cached_property
-    def _openapi_spec(self) -> dict[str, JSON]:
+    def _openapi_spec(self) -> OpenApiObject:
         parser, _, _ = self._load_specs_and_validator()
-        spec_dict: dict[str, JSON] = parser.specification
-        register_path_parameters(spec_dict["paths"])
-        return spec_dict
+        spec_model = OpenApiObject.model_validate(parser.specification)
+        register_path_parameters(spec_model.paths)
+        return spec_model
 
     @cached_property
     def response_validator(
@@ -927,5 +901,5 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
                 f"ValidationError while trying to load openapi spec: {exception}"
             ) from exception
 
-    def read_paths(self) -> dict[str, JSON]:
-        return self.openapi_spec["paths"]  # type: ignore[return-value]
+    def read_paths(self) -> dict[str, PathItemObject]:
+        return self.openapi_spec.paths

OpenApiLibCore/parameter_utils.py

@@ -5,7 +5,7 @@ names and the original names in the parsed OpenApi Specification document.
 
 from typing import Generator
 
-from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.models import ParameterObject, PathItemObject
 
 PARAMETER_REGISTRY: dict[str, str] = {
     "body": "body",
@@ -20,11 +20,11 @@ def get_oas_name_from_safe_name(safe_name: str) -> str:
 
 
 def get_safe_name_for_oas_name(oas_name: str) -> str:
-    if is_python_safe(oas_name):
+    if _is_python_safe(oas_name):
         PARAMETER_REGISTRY[oas_name] = oas_name
         return oas_name
 
-    safe_name = convert_string_to_python_identifier(oas_name)
+    safe_name = _convert_string_to_python_identifier(oas_name)
 
     if safe_name not in PARAMETER_REGISTRY:
         PARAMETER_REGISTRY[safe_name] = oas_name
@@ -36,17 +36,17 @@ def get_safe_name_for_oas_name(oas_name: str) -> str:
     # We're dealing with multiple oas_names that convert to the same safe_name.
     # To resolve this, a more verbose safe_name is generated. This is less user-friendly
     # but necessary to ensure an one-to-one mapping.
-    verbose_safe_name = convert_string_to_python_identifier(oas_name, verbose=True)
+    verbose_safe_name = _convert_string_to_python_identifier(oas_name, verbose=True)
     if verbose_safe_name not in PARAMETER_REGISTRY:
         PARAMETER_REGISTRY[verbose_safe_name] = oas_name
     return verbose_safe_name
 
 
-def is_python_safe(name: str) -> bool:
+def _is_python_safe(name: str) -> bool:
     return name.isidentifier()
 
 
-def convert_string_to_python_identifier(string: str, verbose: bool = False) -> str:
+def _convert_string_to_python_identifier(string: str, verbose: bool = False) -> str:
     def _convert_string_to_python_identifier() -> Generator[str, None, None]:
         string_iterator = iter(string)
 
@@ -71,21 +71,27 @@ def convert_string_to_python_identifier(string: str, verbose: bool = False) -> s
                 ascii_code = ord(character)
                 yield f"_{ascii_code}_"
 
-    if is_python_safe(string):
+    if _is_python_safe(string):
         return string
 
     converted_string = "".join(_convert_string_to_python_identifier())
-    if not is_python_safe(converted_string):
+    if not _is_python_safe(converted_string):
         raise ValueError(f"Failed to convert '{string}' to Python identifier.")
     return converted_string
 
 
-def register_path_parameters(paths_data: dict[str, dict[str, JSON]]) -> None:
-    for operations_data in paths_data.values():
-        for method_data in operations_data.values():
-            parameters_data: list[dict[str, str]] = method_data.get("parameters", [])
-            path_parameter_names = [
-                p["name"] for p in parameters_data if p["in"] == "path"
-            ]
-            for name in path_parameter_names:
-                _ = get_safe_name_for_oas_name(name)
+def register_path_parameters(paths_data: dict[str, PathItemObject]) -> None:
+    def _register_path_parameter(parameter_object: ParameterObject) -> None:
+        if parameter_object.in_ == "path":
+            _ = get_safe_name_for_oas_name(parameter_object.name)
+
+    for path_item in paths_data.values():
+        if parameters := path_item.parameters:
+            for parameter in path_item.parameters:
+                _register_path_parameter(parameter_object=parameter)
+
+        operations = path_item.get_operations()
+        for operation in operations.values():
+            if parameters := operation.parameters:
+                for parameter in parameters:
+                    _register_path_parameter(parameter_object=parameter)

OpenApiLibCore/path_functions.py

@@ -9,6 +9,7 @@ from requests import Response
 from robot.libraries.BuiltIn import BuiltIn
 
 from OpenApiLibCore.dto_base import PathPropertiesConstraint
+from OpenApiLibCore.models import OpenApiObject
 from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
 from OpenApiLibCore.request_data import RequestData
 
@@ -24,14 +25,14 @@ def match_parts(parts: list[str], spec_parts: list[str]) -> bool:
     return True
 
 
-def get_parametrized_path(path: str, openapi_spec: dict[str, Any]) -> str:
+def get_parametrized_path(path: str, openapi_spec: OpenApiObject) -> str:
     path_parts = path.split("/")
     # if the last part is empty, the path has a trailing `/` that
     # should be ignored during matching
     if path_parts[-1] == "":
         _ = path_parts.pop(-1)
 
-    spec_paths: list[str] = {**openapi_spec}["paths"].keys()
+    spec_paths: list[str] = list(openapi_spec.paths.keys())
 
     candidates: list[str] = []
 
@@ -64,12 +65,12 @@ def get_valid_url(
     path: str,
     base_url: str,
     get_dto_class: GetDtoClassType,
-    openapi_spec: dict[str, Any],
+    openapi_spec: OpenApiObject,
 ) -> str:
     try:
         # path can be partially resolved or provided by a PathPropertiesConstraint
         parametrized_path = get_parametrized_path(path=path, openapi_spec=openapi_spec)
-        _ = openapi_spec["paths"][parametrized_path]
+        _ = openapi_spec.paths[parametrized_path]
     except KeyError:
         raise ValueError(
             f"{path} not found in paths section of the OpenAPI document."

OpenApiLibCore/protocols.py

@@ -13,18 +13,20 @@ from OpenApiLibCore.dto_base import Dto
 class ResponseValidatorType(Protocol):
     def __call__(
         self, request: RequestsOpenAPIRequest, response: RequestsOpenAPIResponse
-    ) -> None: ...
+    ) -> None: ...  # pragma: no cover
 
 
 class GetDtoClassType(Protocol):
-    def __init__(self, mappings_module_name: str) -> None: ...
+    def __init__(self, mappings_module_name: str) -> None: ...  # pragma: no cover
 
-    def __call__(self, path: str, method: str) -> Type[Dto]: ...
+    def __call__(self, path: str, method: str) -> Type[Dto]: ...  # pragma: no cover
 
 
 class GetIdPropertyNameType(Protocol):
-    def __init__(self, mappings_module_name: str) -> None: ...
+    def __init__(self, mappings_module_name: str) -> None: ...  # pragma: no cover
 
     def __call__(
         self, path: str
-    ) -> tuple[str, Callable[[str], str] | Callable[[int], int]]: ...
+    ) -> tuple[
+        str, Callable[[str], str] | Callable[[int], int]
+    ]: ...  # pragma: no cover

OpenApiLibCore/request_data.py

@@ -6,11 +6,15 @@ from functools import cached_property
 from random import sample
 from typing import Any
 
-from OpenApiLibCore.dto_base import (
-    Dto,
-    resolve_schema,
-)
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import Dto
 from OpenApiLibCore.dto_utils import DefaultDto
+from OpenApiLibCore.models import (
+    ObjectSchema,
+    ParameterObject,
+    ResolvedSchemaObjectTypes,
+    UnionTypeSchema,
+)
 
 
 @dataclass
@@ -19,23 +23,23 @@ class RequestValues:
 
     url: str
     method: str
-    params: dict[str, Any] = field(default_factory=dict)
-    headers: dict[str, str] = field(default_factory=dict)
-    json_data: dict[str, Any] = field(default_factory=dict)
+    params: dict[str, JSON] = field(default_factory=dict)
+    headers: dict[str, JSON] = field(default_factory=dict)
+    json_data: dict[str, JSON] = field(default_factory=dict)
 
-    def override_body_value(self, name: str, value: Any) -> None:
+    def override_body_value(self, name: str, value: JSON) -> None:
         if name in self.json_data:
             self.json_data[name] = value
 
-    def override_header_value(self, name: str, value: Any) -> None:
+    def override_header_value(self, name: str, value: JSON) -> None:
         if name in self.headers:
             self.headers[name] = value
 
-    def override_param_value(self, name: str, value: str) -> None:
+    def override_param_value(self, name: str, value: JSON) -> None:
         if name in self.params:
             self.params[name] = str(value)
 
-    def override_request_value(self, name: str, value: Any) -> None:
+    def override_request_value(self, name: str, value: JSON) -> None:
         self.override_body_value(name=name, value=value)
         self.override_header_value(name=name, value=value)
         self.override_param_value(name=name, value=value)
@@ -52,16 +56,14 @@ class RequestData:
     """Helper class to manage parameters used when making requests."""
 
     dto: Dto | DefaultDto = field(default_factory=DefaultDto)
-    dto_schema: dict[str, Any] = field(default_factory=dict)
-    parameters: list[dict[str, Any]] = field(default_factory=list)
-    params: dict[str, Any] = field(default_factory=dict)
-    headers: dict[str, Any] = field(default_factory=dict)
+    body_schema: ObjectSchema | None = None
+    parameters: list[ParameterObject] = field(default_factory=list)
+    params: dict[str, JSON] = field(default_factory=dict)
+    headers: dict[str, JSON] = field(default_factory=dict)
     has_body: bool = True
 
     def __post_init__(self) -> None:
         # prevent modification by reference
-        self.dto_schema = deepcopy(self.dto_schema)
-        self.parameters = deepcopy(self.parameters)
         self.params = deepcopy(self.params)
         self.headers = deepcopy(self.headers)
 
@@ -70,20 +72,24 @@ class RequestData:
         """Whether or not the dto data (json data) contains optional properties."""
 
         def is_required_property(property_name: str) -> bool:
-            return property_name in self.dto_schema.get("required", [])
+            return property_name in self.required_property_names
 
         properties = (self.dto.as_dict()).keys()
         return not all(map(is_required_property, properties))
 
+    @property
+    def required_property_names(self) -> list[str]:
+        if self.body_schema:
+            return self.body_schema.required
+        return []
+
     @property
     def has_optional_params(self) -> bool:
         """Whether or not any of the query parameters are optional."""
 
         def is_optional_param(query_param: str) -> bool:
             optional_params = [
-                p.get("name")
-                for p in self.parameters
-                if p.get("in") == "query" and not p.get("required")
+                p.name for p in self.parameters if p.in_ == "query" and not p.required
             ]
             return query_param in optional_params
 
@@ -96,47 +102,26 @@ class RequestData:
         restrictions, data type or by not providing them in a request.
         """
         result = set()
-        params = [h for h in self.parameters if h.get("in") == "query"]
+        params = [h for h in self.parameters if h.in_ == "query"]
         for param in params:
             # required params can be omitted to invalidate a request
-            if param["required"]:
-                result.add(param["name"])
+            if param.required:
+                result.add(param.name)
                 continue
 
-            schema = resolve_schema(param["schema"])
-            if schema.get("type", None):
-                param_types = [schema]
+            if param.schema_ is None:
+                continue
+
+            possible_schemas: list[ResolvedSchemaObjectTypes] = []
+            if isinstance(param.schema_, UnionTypeSchema):
+                possible_schemas = param.schema_.resolved_schemas
             else:
-                param_types = schema["types"]
-            for param_type in param_types:
-                # any basic non-string type except "null" can be invalidated by
-                # replacing it with a string
-                if param_type["type"] not in ["string", "array", "object", "null"]:
-                    result.add(param["name"])
-                    continue
-                # enums, strings and arrays with boundaries can be invalidated
-                if set(param_type.keys()).intersection(
-                    {
-                        "enum",
-                        "minLength",
-                        "maxLength",
-                        "minItems",
-                        "maxItems",
-                    }
-                ):
-                    result.add(param["name"])
-                    continue
-                # an array of basic non-string type can be invalidated by replacing the
-                # items in the array with strings
-                if param_type["type"] == "array" and param_type["items"][
-                    "type"
-                ] not in [
-                    "string",
-                    "array",
-                    "object",
-                    "null",
-                ]:
-                    result.add(param["name"])
+                possible_schemas = [param.schema_]
+
+            for param_schema in possible_schemas:
+                if param_schema.can_be_invalidated:
+                    result.add(param.name)
+
         return result
 
     @property
@@ -145,9 +130,7 @@ class RequestData:
 
         def is_optional_header(header: str) -> bool:
             optional_headers = [
-                p.get("name")
-                for p in self.parameters
-                if p.get("in") == "header" and not p.get("required")
+                p.name for p in self.parameters if p.in_ == "header" and not p.required
             ]
             return header in optional_headers
 
@@ -160,47 +143,26 @@ class RequestData:
         restrictions or by not providing them in a request.
         """
         result = set()
-        headers = [h for h in self.parameters if h.get("in") == "header"]
+        headers = [h for h in self.parameters if h.in_ == "header"]
         for header in headers:
             # required headers can be omitted to invalidate a request
-            if header["required"]:
-                result.add(header["name"])
+            if header.required:
+                result.add(header.name)
+                continue
+
+            if header.schema_ is None:
                 continue
 
-            schema = resolve_schema(header["schema"])
-            if schema.get("type", None):
-                header_types = [schema]
+            possible_schemas: list[ResolvedSchemaObjectTypes] = []
+            if isinstance(header.schema_, UnionTypeSchema):
+                possible_schemas = header.schema_.resolved_schemas
             else:
-                header_types = schema["types"]
-            for header_type in header_types:
-                # any basic non-string type except "null" can be invalidated by
-                # replacing it with a string
-                if header_type["type"] not in ["string", "array", "object", "null"]:
-                    result.add(header["name"])
-                    continue
-                # enums, strings and arrays with boundaries can be invalidated
-                if set(header_type.keys()).intersection(
-                    {
-                        "enum",
-                        "minLength",
-                        "maxLength",
-                        "minItems",
-                        "maxItems",
-                    }
-                ):
-                    result.add(header["name"])
-                    continue
-                # an array of basic non-string type can be invalidated by replacing the
-                # items in the array with strings
-                if header_type["type"] == "array" and header_type["items"][
-                    "type"
-                ] not in [
-                    "string",
-                    "array",
-                    "object",
-                    "null",
-                ]:
-                    result.add(header["name"])
+                possible_schemas = [header.schema_]
+
+            for param_schema in possible_schemas:
+                if param_schema.can_be_invalidated:
+                    result.add(header.name)
+
         return result
 
     def get_required_properties_dict(self) -> dict[str, Any]:
@@ -211,7 +173,7 @@ class RequestData:
             for relation in relations
             if getattr(relation, "treat_as_mandatory", False)
         ]
-        required_properties: list[str] = self.dto_schema.get("required", [])
+        required_properties = self.body_schema.required if self.body_schema else []
         required_properties.extend(mandatory_properties)
 
         required_properties_dict: dict[str, Any] = {}
@@ -223,7 +185,10 @@ class RequestData:
     def get_minimal_body_dict(self) -> dict[str, Any]:
         required_properties_dict = self.get_required_properties_dict()
 
-        min_properties = self.dto_schema.get("minProperties", 0)
+        min_properties = 0
+        if self.body_schema and self.body_schema.minProperties is not None:
+            min_properties = self.body_schema.minProperties
+
         number_of_optional_properties_to_add = min_properties - len(
             required_properties_dict
         )
@@ -247,13 +212,13 @@ class RequestData:
 
         return {**required_properties_dict, **optional_properties_dict}
 
-    def get_required_params(self) -> dict[str, str]:
+    def get_required_params(self) -> dict[str, JSON]:
         """Get the params dict containing only the required query parameters."""
         return {
             k: v for k, v in self.params.items() if k in self.required_parameter_names
         }
 
-    def get_required_headers(self) -> dict[str, str]:
+    def get_required_headers(self) -> dict[str, JSON]:
         """Get the headers dict containing only the required headers."""
         return {
             k: v for k, v in self.headers.items() if k in self.required_parameter_names
@@ -271,11 +236,11 @@ class RequestData:
             for relation in relations
             if getattr(relation, "treat_as_mandatory", False)
         ]
-        parameter_names = [p["name"] for p in self.parameters]
+        parameter_names = [p.name for p in self.parameters]
         mandatory_parameters = [
             p for p in mandatory_property_names if p in parameter_names
         ]
 
-        required_parameters = [p["name"] for p in self.parameters if p.get("required")]
+        required_parameters = [p.name for p in self.parameters if p.required]
         required_parameters.extend(mandatory_parameters)
         return required_parameters

OpenApiLibCore/resource_relations.py

@@ -1,13 +1,12 @@
 """Module holding the functions related to relations between resources."""
 
-from typing import Any
-
 from requests import Response
 from robot.api import logger
 from robot.libraries.BuiltIn import BuiltIn
 
 import OpenApiLibCore.path_functions as pf
 from OpenApiLibCore.dto_base import IdReference
+from OpenApiLibCore.models import OpenApiObject
 from OpenApiLibCore.request_data import RequestData
 
 run_keyword = BuiltIn().run_keyword
@@ -16,7 +15,7 @@ run_keyword = BuiltIn().run_keyword
 def ensure_in_use(
     url: str,
     base_url: str,
-    openapi_spec: dict[str, Any],
+    openapi_spec: OpenApiObject,
     resource_relation: IdReference,
 ) -> None:
     resource_id = ""