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

OpenApiDriver/openapi_executors.py

@@ -133,11 +133,15 @@ class OpenApiExecutors(OpenApiLibCore):
         """
         valid_url: str = run_keyword("get_valid_url", path)
 
-        if not (
-            url := run_keyword(
+        try:
+            url = run_keyword(
                 "get_invalidated_url", valid_url, path, expected_status_code
             )
-        ):
+        except Exception as exception:
+            message = getattr(exception, "message", "")
+            if not message.startswith("ValueError"):
+                raise exception  # pragma: no cover
+
             raise SkipExecution(
                 f"Path {path} does not contain resource references that "
                 f"can be invalidated."

OpenApiDriver/openapidriver.libspec

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<keywordspec name="OpenApiDriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-05-11T17:23:01+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapidriver.py" lineno="358">
-<version>1.0.0b3</version>
+<keywordspec name="OpenApiDriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-06-09T18:38:35+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapidriver.py" lineno="358">
+<version>1.0.0b5</version>
 <doc>&lt;p&gt;Visit the &lt;a href="https://github.com/MarketSquare/robotframework-openapidriver"&gt;library page&lt;/a&gt; for an introduction and examples.&lt;/p&gt;</doc>
 <tags>
 </tags>
@@ -247,7 +247,7 @@
 </init>
 </inits>
 <keywords>
-<kw name="Test Endpoint" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapi_executors.py" lineno="162">
+<kw name="Test Endpoint" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapi_executors.py" lineno="166">
 <arguments repr="path: str, method: str, status_code: int">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>

OpenApiLibCore/data_generation/body_data_generation.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from robot.api import logger
 
-import OpenApiLibCore.path_functions as pf
+import OpenApiLibCore.path_functions as _path_functions
 from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import (
     Dto,
@@ -72,7 +72,7 @@ def get_dict_data_for_dto_class(
     property_names = get_property_names_to_process(schema=schema, dto_class=dto_class)
 
     for property_name in property_names:
-        property_schema = schema.properties.root[property_name]
+        property_schema = schema.properties.root[property_name]  # type: ignore[union-attr]
         if property_schema.readOnly:
             continue
 
@@ -178,7 +178,7 @@ def get_property_names_to_process(
 ) -> list[str]:
     property_names = []
 
-    for property_name in schema.properties.root:
+    for property_name in schema.properties.root:  # type: ignore[union-attr]
         # register the oas_name
         _ = get_safe_name_for_oas_name(property_name)
         if constrained_values := get_constrained_values(
@@ -243,7 +243,7 @@ def get_dependent_id(
         except ValueError:
             return None
 
-    valid_id = pf.get_valid_id_for_path(
+    valid_id = _path_functions.get_valid_id_for_path(
         path=id_get_path, get_id_property_name=get_id_property_name
     )
     logger.debug(f"get_dependent_id for {id_get_path} returned {valid_id}")

OpenApiLibCore/data_generation/data_generation_core.py

@@ -3,14 +3,13 @@ Module holding the main functions related to data generation
 for the requests made as part of keyword exection.
 """
 
-import re
 from dataclasses import Field, field, make_dataclass
 from random import choice
 from typing import Any, cast
 
 from robot.api import logger
 
-import OpenApiLibCore.path_functions as pf
+import OpenApiLibCore.path_functions as _path_functions
 from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import (
     Dto,
@@ -23,7 +22,6 @@ from OpenApiLibCore.models import (
     OpenApiObject,
     OperationObject,
     ParameterObject,
-    RequestBodyObject,
     UnionTypeSchema,
 )
 from OpenApiLibCore.parameter_utils import get_safe_name_for_oas_name
@@ -47,11 +45,13 @@ def get_request_data(
     dto_cls_name = get_dto_cls_name(path=path, method=method)
     # The path can contain already resolved Ids that have to be matched
     # against the parametrized paths in the paths section.
-    spec_path = pf.get_parametrized_path(path=path, openapi_spec=openapi_spec)
+    spec_path = _path_functions.get_parametrized_path(
+        path=path, openapi_spec=openapi_spec
+    )
     dto_class = get_dto_class(path=spec_path, method=method)
     try:
         path_item = openapi_spec.paths[spec_path]
-        operation_spec = getattr(path_item, method)
+        operation_spec: OperationObject | None = getattr(path_item, method)
         if operation_spec is None:
             raise AttributeError
     except AttributeError:
@@ -77,38 +77,30 @@ def get_request_data(
             has_body=False,
         )
 
-    headers.update({"content-type": get_content_type(operation_spec.requestBody)})
-
-    body_schema = operation_spec.requestBody
-    media_type_dict = body_schema.content
-    supported_types = [v for k, v in media_type_dict.items() if "json" in k]
-    supported_schemas = [t.schema_ for t in supported_types if t.schema_ is not None]
+    body_schema = operation_spec.requestBody.schema_
 
-    if not supported_schemas:
-        raise ValueError(f"No supported content schema found: {media_type_dict}")
-
-    if len(supported_schemas) > 1:
-        logger.warn(
-            f"Multiple JSON media types defined for requestBody, using the first candidate {media_type_dict}"
+    if not body_schema:
+        raise ValueError(
+            f"No supported content schema found: {operation_spec.requestBody.content}"
         )
 
-    schema = supported_schemas[0]
+    headers.update({"content-type": operation_spec.requestBody.mime_type})
 
-    if isinstance(schema, UnionTypeSchema):
-        resolved_schemas = schema.resolved_schemas
-        schema = choice(resolved_schemas)
+    if isinstance(body_schema, UnionTypeSchema):
+        resolved_schemas = body_schema.resolved_schemas
+        body_schema = choice(resolved_schemas)
 
-    if not isinstance(schema, ObjectSchema):
-        raise ValueError(f"Selected schema is not an object schema: {schema}")
+    if not isinstance(body_schema, ObjectSchema):
+        raise ValueError(f"Selected schema is not an object schema: {body_schema}")
 
     dto_data = _get_json_data_for_dto_class(
-        schema=schema,
+        schema=body_schema,
         dto_class=dto_class,
         get_id_property_name=get_id_property_name,
         operation_id=operation_spec.operationId,
     )
     dto_instance = _get_dto_instance_from_dto_data(
-        object_schema=schema,
+        object_schema=body_schema,
         dto_class=dto_class,
         dto_data=dto_data,
         method_spec=operation_spec,
@@ -116,7 +108,7 @@ def get_request_data(
     )
     return RequestData(
         dto=dto_instance,
-        body_schema=schema,
+        body_schema=body_schema,
         parameters=parameters,
         params=params,
         headers=headers,
@@ -198,25 +190,6 @@ def get_dto_cls_name(path: str, method: str) -> str:
     return result
 
 
-def get_content_type(body_spec: RequestBodyObject) -> str:
-    """Get and validate the first supported content type from the requested body spec
-
-    Should be application/json like content type,
-    e.g "application/json;charset=utf-8" or "application/merge-patch+json"
-    """
-    content_types: list[str] = list(body_spec.content.keys())
-    json_regex = r"application/([a-z\-]+\+)?json(;\s?charset=(.+))?"
-    for content_type in content_types:
-        if re.search(json_regex, content_type):
-            return content_type
-
-    # At present no supported for other types.
-    raise NotImplementedError(
-        f"Only content types like 'application/json' are supported. "
-        f"Content types definded in the spec are '{content_types}'."
-    )
-
-
 def get_request_parameters(
     dto_class: Dto | type[Dto], method_spec: OperationObject
 ) -> tuple[list[ParameterObject], dict[str, Any], dict[str, str]]:

OpenApiLibCore/data_invalidation.py

@@ -16,7 +16,6 @@ from OpenApiLibCore.dto_base import (
     NOT_SET,
     Dto,
     IdReference,
-    PathPropertiesConstraint,
     PropertyValueConstraint,
     UniquePropertyValueConstraint,
 )
@@ -35,10 +34,7 @@ def get_invalid_body_data(
     invalid_property_default_response: int,
 ) -> dict[str, Any]:
     method = method.lower()
-    data_relations = request_data.dto.get_relations_for_error_code(status_code)
-    data_relations = [
-        r for r in data_relations if not isinstance(r, PathPropertiesConstraint)
-    ]
+    data_relations = request_data.dto.get_body_relations_for_error_code(status_code)
     if not data_relations:
         if request_data.body_schema is None:
             raise ValueError(

OpenApiLibCore/dto_base.py

@@ -83,17 +83,17 @@ class Dto(ABC):
     """Base class for the Dto class."""
 
     @staticmethod
-    def get_parameter_relations() -> list[ResourceRelation]:
+    def get_path_relations() -> list[PathPropertiesConstraint]:
         """Return the list of Relations for the header and query parameters."""
         return []
 
-    def get_parameter_relations_for_error_code(
+    def get_path_relations_for_error_code(
         self, error_code: int
-    ) -> list[ResourceRelation]:
+    ) -> list[PathPropertiesConstraint]:
         """Return the list of Relations associated with the given error_code."""
-        relations: list[ResourceRelation] = [
+        relations: list[PathPropertiesConstraint] = [
             r
-            for r in self.get_parameter_relations()
+            for r in self.get_path_relations()
             if r.error_code == error_code
             or (
                 getattr(r, "invalid_value_error_code", None) == error_code
@@ -103,15 +103,17 @@ class Dto(ABC):
         return relations
 
     @staticmethod
-    def get_relations() -> list[ResourceRelation]:
-        """Return the list of Relations for the (json) body."""
+    def get_parameter_relations() -> list[ResourceRelation]:
+        """Return the list of Relations for the header and query parameters."""
         return []
 
-    def get_relations_for_error_code(self, error_code: int) -> list[ResourceRelation]:
+    def get_parameter_relations_for_error_code(
+        self, error_code: int
+    ) -> list[ResourceRelation]:
         """Return the list of Relations associated with the given error_code."""
         relations: list[ResourceRelation] = [
             r
-            for r in self.get_relations()
+            for r in self.get_parameter_relations()
             if r.error_code == error_code
             or (
                 getattr(r, "invalid_value_error_code", None) == error_code
@@ -120,6 +122,11 @@ class Dto(ABC):
         ]
         return relations
 
+    @staticmethod
+    def get_relations() -> list[ResourceRelation]:
+        """Return the list of Relations for the (json) body."""
+        return []
+
     def get_body_relations_for_error_code(
         self, error_code: int
     ) -> list[ResourceRelation]:
@@ -127,8 +134,16 @@ class Dto(ABC):
         Return the list of Relations associated with the given error_code that are
         applicable to the body / payload of the request.
         """
-        all_relations = self.get_relations_for_error_code(error_code=error_code)
-        return [r for r in all_relations if not isinstance(r, PathPropertiesConstraint)]
+        relations: list[ResourceRelation] = [
+            r
+            for r in self.get_relations()
+            if r.error_code == error_code
+            or (
+                getattr(r, "invalid_value_error_code", None) == error_code
+                and getattr(r, "invalid_value", None) != NOT_SET
+            )
+        ]
+        return relations
 
     def get_invalidated_data(
         self,
@@ -139,17 +154,11 @@ class Dto(ABC):
         """Return a data set with one of the properties set to an invalid value or type."""
         properties: dict[str, Any] = self.as_dict()
 
-        # schema = resolve_schema(schema)
-
-        relations = self.get_relations_for_error_code(error_code=status_code)
-        # filter PathProperyConstraints since in that case no data can be invalidated
-        relations = [
-            r for r in relations if not isinstance(r, PathPropertiesConstraint)
-        ]
+        relations = self.get_body_relations_for_error_code(error_code=status_code)
         property_names = [r.property_name for r in relations]
         if status_code == invalid_property_default_code:
             # add all properties defined in the schema, including optional properties
-            property_names.extend((schema.properties.root.keys()))
+            property_names.extend((schema.properties.root.keys()))  # type: ignore[union-attr]
         if not property_names:
             raise ValueError(
                 f"No property can be invalidated to cause status_code {status_code}"
@@ -167,8 +176,8 @@ class Dto(ABC):
             if id_dependencies:
                 invalid_id = uuid4().hex
                 logger.debug(
-                    f"Breaking IdDependency for status_code {status_code}: replacing "
-                    f"{properties[property_name]} with {invalid_id}"
+                    f"Breaking IdDependency for status_code {status_code}: setting "
+                    f"{property_name} to {invalid_id}"
                 )
                 properties[property_name] = invalid_id
                 return properties
@@ -191,7 +200,7 @@ class Dto(ABC):
                 )
                 return properties
 
-            value_schema = schema.properties.root[property_name]
+            value_schema = schema.properties.root[property_name]  # type: ignore[union-attr]
             if isinstance(value_schema, UnionTypeSchema):
                 # Filter "type": "null" from the possible types since this indicates an
                 # optional / nullable property that can only be invalidated by sending

OpenApiLibCore/dto_utils.py

@@ -7,7 +7,11 @@ from typing import Any, Callable, Type, overload
 from robot.api import logger
 
 from OpenApiLibCore.dto_base import Dto
-from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
+from OpenApiLibCore.protocols import (
+    GetDtoClassType,
+    GetIdPropertyNameType,
+    GetPathDtoClassType,
+)
 
 
 @dataclass
@@ -49,6 +53,30 @@ class GetDtoClass:
             return DefaultDto
 
 
+def get_path_dto_class(mappings_module_name: str) -> GetPathDtoClassType:
+    return GetPathDtoClass(mappings_module_name=mappings_module_name)
+
+
+class GetPathDtoClass:
+    """Callable class to return Dtos from user-implemented mappings file."""
+
+    def __init__(self, mappings_module_name: str) -> None:
+        try:
+            mappings_module = import_module(mappings_module_name)
+            self.dto_mapping: dict[str, Type[Dto]] = mappings_module.PATH_MAPPING
+        except (ImportError, AttributeError, ValueError) as exception:
+            if mappings_module_name != "no mapping":
+                logger.error(f"PATH_MAPPING was not imported: {exception}")
+            self.dto_mapping = {}
+
+    def __call__(self, path: str) -> Type[Dto]:
+        try:
+            return self.dto_mapping[path]
+        except KeyError:
+            logger.debug(f"No Dto mapping for {path}.")
+            return DefaultDto
+
+
 def get_id_property_name(mappings_module_name: str) -> GetIdPropertyNameType:
     return GetIdPropertyName(mappings_module_name=mappings_module_name)
 
@@ -86,11 +114,11 @@ class GetIdPropertyName:
 
 
 @overload
-def dummy_transformer(valid_id: str) -> str: ...
+def dummy_transformer(valid_id: str) -> str: ...  # pragma: no cover
 
 
 @overload
-def dummy_transformer(valid_id: int) -> int: ...
+def dummy_transformer(valid_id: int) -> int: ...  # pragma: no cover
 
 
 def dummy_transformer(valid_id: Any) -> Any:

OpenApiLibCore/models.py

@@ -234,7 +234,7 @@ class IntegerSchema(SchemaBase[int], frozen=True):
 
         return randint(self._min_value, self._max_value)
 
-    def get_values_out_of_bounds(self, current_value: int) -> list[int]:
+    def get_values_out_of_bounds(self, current_value: int) -> list[int]:  # pylint: disable=unused-argument
         invalid_values: list[int] = []
 
         if self._min_value > self._min_int:
@@ -333,7 +333,7 @@ class NumberSchema(SchemaBase[float], frozen=True):
 
         return uniform(self._min_value, self._max_value)
 
-    def get_values_out_of_bounds(self, current_value: float) -> list[float]:
+    def get_values_out_of_bounds(self, current_value: float) -> list[float]:  # pylint: disable=unused-argument
         invalid_values: list[float] = []
 
         if self._min_value > self._min_float:
@@ -643,21 +643,33 @@ class RequestBodyObject(BaseModel):
     required: bool = False
     description: str = ""
 
-    @property
+    @cached_property
     def schema_(self) -> SchemaObjectTypes | None:
-        schemas = [
-            media_type.schema_
-            for mime_type, media_type in self.content.items()
-            if "json" in mime_type
-        ]
-        if None in schemas:
-            schemas.remove(None)
-        if not schemas:
+        if not self.mime_type:
+            return None
+
+        if len(self._json_schemas) > 1:
+            logger.info(
+                f"Multiple JSON media types defined for requestBody, "
+                f"using the first candidate from {self.content}"
+            )
+        return self._json_schemas[self.mime_type]
+
+    @cached_property
+    def mime_type(self) -> str | None:
+        if not self._json_schemas:
             return None
 
-        if len(schemas) > 1:
-            logger.warn(f"Multiple schemas defined for request body: {self.content}")
-        return schemas.pop()
+        return next(iter(self._json_schemas))
+
+    @cached_property
+    def _json_schemas(self) -> dict[str, SchemaObjectTypes]:
+        json_schemas = {
+            mime_type: media_type.schema_
+            for mime_type, media_type in self.content.items()
+            if "json" in mime_type and media_type.schema_ is not None
+        }
+        return json_schemas
 
 
 class HeaderObject(BaseModel): ...
@@ -673,10 +685,6 @@ class ResponseObject(BaseModel):
     links: dict[str, LinkObject] = {}
 
 
-# class ComponentsObject(BaseModel):
-#     schemas: dict[str, SchemaObjectTypes]
-
-
 class OperationObject(BaseModel):
     operationId: str | None = None
     summary: str = ""