robotframework-openapitools 1.0.0b4__tar.gz → 1.0.0b5__tar.gz

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotframework-openapitools
-Version: 1.0.0b4
+Version: 1.0.0b5
 Summary: A set of Robot Framework libraries to test APIs for which the OAS is available.
 License: Apache License
                                     Version 2.0, January 2004

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name="robotframework-openapitools"
-version = "1.0.0b4"
+version = "1.0.0b5"
 description = "A set of Robot Framework libraries to test APIs for which the OAS is available."
 authors = [
     {name = "Robin Mackaij", email = "r.a.mackaij@gmail.com"},

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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."

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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>

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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}")

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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]]:

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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(

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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:

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/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 = ""

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/openapi_libcore.libspec

@@ -1,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<keywordspec name="OpenApiLibCore" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-05-11T17:22:53+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiLibCore/openapi_libcore.py" lineno="174">
-<version>1.0.0b3</version>
+<keywordspec name="OpenApiLibCore" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-06-09T18:38:28+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiLibCore/openapi_libcore.py" lineno="175">
+<version>1.0.0b5</version>
 <doc>&lt;p&gt;Main class providing the keywords and core logic to interact with an OpenAPI server.&lt;/p&gt;
 &lt;p&gt;Visit the &lt;a href="https://github.com/MarketSquare/robotframework-openapi-libcore"&gt;library page&lt;/a&gt; for an introduction.&lt;/p&gt;</doc>
 <tags>
 </tags>
 <inits>
-<init name="__init__" lineno="182">
+<init name="__init__" lineno="183">
 <arguments repr="source: str, origin: str = , base_path: str = , response_validation: ValidationLevel = WARN, disable_server_validation: bool = True, mappings_path: str | Path = , invalid_property_default_response: int = 422, default_id_property_name: str = id, faker_locale: str | list[str] = , require_body_for_invalid_url: bool = False, recursion_limit: int = 1, recursion_default: JSON = {}, username: str = , password: str = , security_token: str = , auth: AuthBase | None = None, cert: str | tuple[str, str] = , verify_tls: bool | str = True, extra_headers: Mapping[str, str] = {}, cookies: MutableMapping[str, str] | RequestsCookieJar | None = None, proxies: MutableMapping[str, str] | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="source: str">
 <name>source</name>
@@ -208,7 +208,7 @@
 </init>
 </inits>
 <keywords>
-<kw name="Assert Href To Resource Is Valid" lineno="722">
+<kw name="Assert Href To Resource Is Valid" lineno="729">
 <arguments repr="href: str, referenced_resource: dict[str, JSON]">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="href: str">
 <name>href</name>
@@ -225,7 +225,7 @@
 <doc>&lt;p&gt;Attempt to GET the resource referenced by the &lt;span class="name"&gt;href&lt;/span&gt; and validate it's equal to the provided &lt;span class="name"&gt;referenced_resource&lt;/span&gt; object / dictionary.&lt;/p&gt;</doc>
 <shortdoc>Attempt to GET the resource referenced by the `href` and validate it's equal to the provided `referenced_resource` object / dictionary.</shortdoc>
 </kw>
-<kw name="Authorized Request" lineno="642">
+<kw name="Authorized Request" lineno="649">
 <arguments repr="url: str, method: str, params: dict[str, Any] | None = None, headers: dict[str, str] | None = None, json_data: JSON | None = None, data: Any | None = None, files: Any | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -288,7 +288,7 @@
 &lt;p&gt;&amp;gt; Note: provided username / password or auth objects take precedence over token based security&lt;/p&gt;</doc>
 <shortdoc>Perform a request using the security token or authentication set in the library.</shortdoc>
 </kw>
-<kw name="Ensure In Use" lineno="627">
+<kw name="Ensure In Use" lineno="634">
 <arguments repr="url: str, resource_relation: IdReference">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -302,7 +302,7 @@
 <doc>&lt;p&gt;Ensure that the (right-most) &lt;span class="name"&gt;id&lt;/span&gt; of the resource referenced by the &lt;span class="name"&gt;url&lt;/span&gt; is used by the resource defined by the &lt;span class="name"&gt;resource_relation&lt;/span&gt;.&lt;/p&gt;</doc>
 <shortdoc>Ensure that the (right-most) `id` of the resource referenced by the `url` is used by the resource defined by the `resource_relation`.</shortdoc>
 </kw>
-<kw name="Get Ids From Url" lineno="592">
+<kw name="Get Ids From Url" lineno="599">
 <arguments repr="url: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -315,7 +315,7 @@
 <doc>&lt;p&gt;Perform a GET request on the &lt;span class="name"&gt;url&lt;/span&gt; and return the list of resource &lt;span class="name"&gt;ids&lt;/span&gt; from the response.&lt;/p&gt;</doc>
 <shortdoc>Perform a GET request on the `url` and return the list of resource `ids` from the response.</shortdoc>
 </kw>
-<kw name="Get Invalid Body Data" lineno="489">
+<kw name="Get Invalid Body Data" lineno="496">
 <arguments repr="url: str, method: str, status_code: int, request_data: RequestData">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -342,7 +342,7 @@
 &lt;p&gt;&amp;gt; Note: applicable UniquePropertyValueConstraint and IdReference Relations are considered before changes to &lt;span class="name"&gt;json_data&lt;/span&gt; are made.&lt;/p&gt;</doc>
 <shortdoc>Return `json_data` based on the `dto` on the `request_data` that will cause the provided `status_code` for the `method` operation on the `url`.</shortdoc>
 </kw>
-<kw name="Get Invalidated Parameters" lineno="512">
+<kw name="Get Invalidated Parameters" lineno="519">
 <arguments repr="status_code: int, request_data: RequestData">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="status_code: int">
 <name>status_code</name>
@@ -366,7 +366,7 @@
 <doc>&lt;p&gt;Returns a version of &lt;span class="name"&gt;params, headers&lt;/span&gt; as present on &lt;span class="name"&gt;request_data&lt;/span&gt; that has been modified to cause the provided &lt;span class="name"&gt;status_code&lt;/span&gt;.&lt;/p&gt;</doc>
 <shortdoc>Returns a version of `params, headers` as present on `request_data` that has been modified to cause the provided `status_code`.</shortdoc>
 </kw>
-<kw name="Get Invalidated Url" lineno="602">
+<kw name="Get Invalidated Url" lineno="609">
 <arguments repr="valid_url: str, path: str = , expected_status_code: int = 404">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="valid_url: str">
 <name>valid_url</name>
@@ -385,10 +385,10 @@
 </arguments>
 <returntype name="str" typedoc="string"/>
 <doc>&lt;p&gt;Return an url with all the path parameters in the &lt;span class="name"&gt;valid_url&lt;/span&gt; replaced by a random UUID if no PathPropertiesConstraint is mapped for the &lt;span class="name"&gt;"get"&lt;/span&gt; operation on the mapped &lt;a href="#type-Path" class="name"&gt;path&lt;/a&gt; and &lt;span class="name"&gt;expected_status_code&lt;/span&gt;. If a PathPropertiesConstraint is mapped, the &lt;span class="name"&gt;invalid_value&lt;/span&gt; is returned.&lt;/p&gt;
-&lt;p&gt;Raises ValueError if the valid_url cannot be invalidated.&lt;/p&gt;</doc>
+&lt;p&gt;Raises: ValueError if the valid_url cannot be invalidated.&lt;/p&gt;</doc>
 <shortdoc>Return an url with all the path parameters in the `valid_url` replaced by a random UUID if no PathPropertiesConstraint is mapped for the `"get"` operation on the mapped `path` and `expected_status_code`. If a PathPropertiesConstraint is mapped, the `invalid_value` is returned.</shortdoc>
 </kw>
-<kw name="Get Json Data With Conflict" lineno="528">
+<kw name="Get Json Data With Conflict" lineno="535">
 <arguments repr="url: str, method: str, dto: Dto, conflict_status_code: int">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -414,7 +414,7 @@
 <doc>&lt;p&gt;Return &lt;span class="name"&gt;json_data&lt;/span&gt; based on the &lt;span class="name"&gt;UniquePropertyValueConstraint&lt;/span&gt; that must be returned by the &lt;span class="name"&gt;get_relations&lt;/span&gt; implementation on the &lt;span class="name"&gt;dto&lt;/span&gt; for the given &lt;span class="name"&gt;conflict_status_code&lt;/span&gt;.&lt;/p&gt;</doc>
 <shortdoc>Return `json_data` based on the `UniquePropertyValueConstraint` that must be returned by the `get_relations` implementation on the `dto` for the given `conflict_status_code`.</shortdoc>
 </kw>
-<kw name="Get Parameterized Path From Url" lineno="578">
+<kw name="Get Parameterized Path From Url" lineno="585">
 <arguments repr="url: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -425,7 +425,7 @@
 <doc>&lt;p&gt;Return the path as found in the &lt;span class="name"&gt;paths&lt;/span&gt; section based on the given &lt;span class="name"&gt;url&lt;/span&gt;.&lt;/p&gt;</doc>
 <shortdoc>Return the path as found in the `paths` section based on the given `url`.</shortdoc>
 </kw>
-<kw name="Get Request Data" lineno="478">
+<kw name="Get Request Data" lineno="485">
 <arguments repr="path: str, method: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -440,7 +440,7 @@
 <doc>&lt;p&gt;Return an object with valid request data for body, headers and query params.&lt;/p&gt;</doc>
 <shortdoc>Return an object with valid request data for body, headers and query params.</shortdoc>
 </kw>
-<kw name="Get Request Values" lineno="437">
+<kw name="Get Request Values" lineno="444">
 <arguments repr="path: str, method: str, overrides: Mapping[str, JSON] = {}">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -463,7 +463,7 @@
 <doc>&lt;p&gt;Return an object with all (valid) request values needed to make a request.&lt;/p&gt;</doc>
 <shortdoc>Return an object with all (valid) request values needed to make a request.</shortdoc>
 </kw>
-<kw name="Get Valid Id For Path" lineno="566">
+<kw name="Get Valid Id For Path" lineno="573">
 <arguments repr="path: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -479,7 +479,7 @@
 &lt;p&gt;To prevent resource conflicts with other test cases, a new resource is created (by a POST operation) if possible.&lt;/p&gt;</doc>
 <shortdoc>Support keyword that returns the `id` for an existing resource at `path`.</shortdoc>
 </kw>
-<kw name="Get Valid Url" lineno="547">
+<kw name="Get Valid Url" lineno="554">
 <arguments repr="path: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -492,7 +492,7 @@
 &lt;p&gt;&amp;gt; Note: if valid ids cannot be retrieved within the scope of the API, the &lt;span class="name"&gt;PathPropertiesConstraint&lt;/span&gt; Relation can be used. More information can be found &lt;a href="https://marketsquare.github.io/robotframework-openapitools/advanced_use.html"&gt;here&lt;/a&gt;.&lt;/p&gt;</doc>
 <shortdoc>This keyword returns a valid url for the given `path`.</shortdoc>
 </kw>
-<kw name="Perform Validated Request" lineno="691">
+<kw name="Perform Validated Request" lineno="698">
 <arguments repr="path: str, status_code: int, request_values: RequestValues, original_data: Mapping[str, JSON] = {}">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -518,7 +518,7 @@
 <doc>&lt;p&gt;This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates, for &lt;span class="name"&gt;DELETE&lt;/span&gt; operations, whether the target resource was indeed deleted (OK response) or not (error responses).&lt;/p&gt;</doc>
 <shortdoc>This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates, for `DELETE` operations, whether the target resource was indeed deleted (OK response) or not (error responses).</shortdoc>
 </kw>
-<kw name="Set Auth" lineno="415">
+<kw name="Set Auth" lineno="422">
 <arguments repr="auth: AuthBase">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="auth: AuthBase">
 <name>auth</name>
@@ -529,7 +529,7 @@
 &lt;p&gt;After calling this keyword, subsequent requests will use the provided &lt;span class="name"&gt;auth&lt;/span&gt; instance.&lt;/p&gt;</doc>
 <shortdoc>Set the `auth` used for authentication after the library is imported.</shortdoc>
 </kw>
-<kw name="Set Basic Auth" lineno="403">
+<kw name="Set Basic Auth" lineno="410">
 <arguments repr="username: str, password: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="username: str">
 <name>username</name>
@@ -544,7 +544,7 @@
 &lt;p&gt;After calling this keyword, subsequent requests will use the provided credentials.&lt;/p&gt;</doc>
 <shortdoc>Set the `username` and `password` used for basic authentication after the library is imported.</shortdoc>
 </kw>
-<kw name="Set Extra Headers" lineno="425">
+<kw name="Set Extra Headers" lineno="432">
 <arguments repr="extra_headers: dict[str, str]">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="extra_headers: dict[str, str]">
 <name>extra_headers</name>
@@ -558,7 +558,7 @@
 &lt;p&gt;After calling this keyword, subsequent requests will use the provided &lt;span class="name"&gt;extra_headers&lt;/span&gt;.&lt;/p&gt;</doc>
 <shortdoc>Set the `extra_headers` used in requests after the library is imported.</shortdoc>
 </kw>
-<kw name="Set Origin" lineno="380">
+<kw name="Set Origin" lineno="387">
 <arguments repr="origin: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="origin: str">
 <name>origin</name>
@@ -570,7 +570,7 @@
 &lt;p&gt;In combination with OpenApiLibCore, the &lt;span class="name"&gt;origin&lt;/span&gt; can be used at any point to target another server that hosts an API that complies to the same OAS.&lt;/p&gt;</doc>
 <shortdoc>Set the `origin` after the library is imported.</shortdoc>
 </kw>
-<kw name="Set Security Token" lineno="394">
+<kw name="Set Security Token" lineno="401">
 <arguments repr="security_token: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="security_token: str">
 <name>security_token</name>
@@ -581,7 +581,7 @@
 &lt;p&gt;After calling this keyword, subsequent requests will use the provided token.&lt;/p&gt;</doc>
 <shortdoc>Set the `security_token` after the library is imported.</shortdoc>
 </kw>
-<kw name="Validate Response" lineno="737">
+<kw name="Validate Response" lineno="744">
 <arguments repr="path: str, response: Response, original_data: Mapping[str, JSON] = {}">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="path: str">
 <name>path</name>
@@ -611,7 +611,7 @@
 &lt;/ul&gt;</doc>
 <shortdoc>Validate the `response` by performing the following validations: - validate the `response` against the openapi schema for the `path` - validate that the response does not contain extra properties - validate that a href, if present, refers to the correct resource - validate that the value for a property that is in the response is equal to     the property value that was send - validate that no `original_data` is preserved when performing a PUT operation - validate that a PATCH operation only updates the provided properties</shortdoc>
 </kw>
-<kw name="Validate Response Using Validator" lineno="711">
+<kw name="Validate Response Using Validator" lineno="718">
 <arguments repr="response: Response">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="response: Response">
 <name>response</name>
@@ -621,7 +621,7 @@
 <doc>&lt;p&gt;Validate the &lt;span class="name"&gt;response&lt;/span&gt; against the OpenAPI Spec that is loaded during library initialization.&lt;/p&gt;</doc>
 <shortdoc>Validate the `response` against the OpenAPI Spec that is loaded during library initialization.</shortdoc>
 </kw>
-<kw name="Validate Send Response" lineno="767">
+<kw name="Validate Send Response" lineno="774">
 <arguments repr="response: Response, original_data: Mapping[str, JSON] = {}">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="response: Response">
 <name>response</name>

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/openapi_libcore.py

@@ -140,17 +140,18 @@ from robot.api.exceptions import FatalError
 from robot.libraries.BuiltIn import BuiltIn
 
 import OpenApiLibCore.data_generation as _data_generation
-import OpenApiLibCore.data_invalidation as di
-import OpenApiLibCore.path_functions as pf
-import OpenApiLibCore.path_invalidation as pi
-import OpenApiLibCore.resource_relations as rr
-import OpenApiLibCore.validation as val
+import OpenApiLibCore.data_invalidation as _data_invalidation
+import OpenApiLibCore.path_functions as _path_functions
+import OpenApiLibCore.path_invalidation as _path_invalidation
+import OpenApiLibCore.resource_relations as _resource_relations
+import OpenApiLibCore.validation as _validation
 from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import Dto, IdReference
 from OpenApiLibCore.dto_utils import (
     DEFAULT_ID_PROPERTY_NAME,
     get_dto_class,
     get_id_property_name,
+    get_path_dto_class,
 )
 from OpenApiLibCore.localized_faker import FAKE
 from OpenApiLibCore.models import (
@@ -184,7 +185,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         source: str,
         origin: str = "",
         base_path: str = "",
-        response_validation: val.ValidationLevel = val.ValidationLevel.WARN,
+        response_validation: _validation.ValidationLevel = _validation.ValidationLevel.WARN,
         disable_server_validation: bool = True,
         mappings_path: str | Path = "",
         invalid_property_default_response: int = 422,
@@ -359,12 +360,18 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
             self.get_dto_class = get_dto_class(
                 mappings_module_name=mappings_module_name
             )
+            self.get_path_dto_class = get_path_dto_class(
+                mappings_module_name=mappings_module_name
+            )
             self.get_id_property_name = get_id_property_name(
                 mappings_module_name=mappings_module_name
             )
             sys.path.pop()
         else:
             self.get_dto_class = get_dto_class(mappings_module_name="no mapping")
+            self.get_path_dto_class = get_path_dto_class(
+                mappings_module_name="no mapping"
+            )
             self.get_id_property_name = get_id_property_name(
                 mappings_module_name="no mapping"
             )
@@ -500,7 +507,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_body_data(
+        return _data_invalidation.get_invalid_body_data(
             url=url,
             method=method,
             status_code=status_code,
@@ -518,7 +525,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Returns a version of `params, headers` as present on `request_data` that has
         been modified to cause the provided `status_code`.
         """
-        return di.get_invalidated_parameters(
+        return _data_invalidation.get_invalidated_parameters(
             status_code=status_code,
             request_data=request_data,
             invalid_property_default_response=self.invalid_property_default_response,
@@ -533,7 +540,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         returned by the `get_relations` implementation on the `dto` for the given
         `conflict_status_code`.
         """
-        return di.get_json_data_with_conflict(
+        return _data_invalidation.get_json_data_with_conflict(
             url=url,
             base_url=self.base_url,
             method=method,
@@ -555,10 +562,10 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         `PathPropertiesConstraint` Relation can be used. More information can be found
         [https://marketsquare.github.io/robotframework-openapitools/advanced_use.html | here].
         """
-        return pf.get_valid_url(
+        return _path_functions.get_valid_url(
             path=path,
             base_url=self.base_url,
-            get_dto_class=self.get_dto_class,
+            get_path_dto_class=self.get_path_dto_class,
             openapi_spec=self.openapi_spec,
         )
 
@@ -570,7 +577,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         To prevent resource conflicts with other test cases, a new resource is created
         (by a POST operation) if possible.
         """
-        return pf.get_valid_id_for_path(
+        return _path_functions.get_valid_id_for_path(
             path=path, get_id_property_name=self.get_id_property_name
         )
 
@@ -583,7 +590,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         path_parts = path.split("/")
         # first part will be '' since a path starts with /
         path_parts.pop(0)
-        parameterized_path = pf.get_parametrized_path(
+        parameterized_path = _path_functions.get_parametrized_path(
             path=path, openapi_spec=self.openapi_spec
         )
         return parameterized_path
@@ -594,7 +601,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Perform a GET request on the `url` and return the list of resource
         `ids` from the response.
         """
-        return pf.get_ids_from_url(
+        return _path_functions.get_ids_from_url(
             url=url, get_id_property_name=self.get_id_property_name
         )
 
@@ -611,13 +618,13 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         on the mapped `path` and `expected_status_code`.
         If a PathPropertiesConstraint is mapped, the `invalid_value` is returned.
 
-        Raises ValueError if the valid_url cannot be invalidated.
+        Raises: ValueError if the valid_url cannot be invalidated.
         """
-        return pi.get_invalidated_url(
+        return _path_invalidation.get_invalidated_url(
             valid_url=valid_url,
             path=path,
             base_url=self.base_url,
-            get_dto_class=self.get_dto_class,
+            get_path_dto_class=self.get_path_dto_class,
             expected_status_code=expected_status_code,
         )
 
@@ -629,7 +636,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Ensure that the (right-most) `id` of the resource referenced by the `url`
         is used by the resource defined by the `resource_relation`.
         """
-        rr.ensure_in_use(
+        _resource_relations.ensure_in_use(
             url=url,
             base_url=self.base_url,
             openapi_spec=self.openapi_spec,
@@ -700,7 +707,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Response keyword and finally validates, for `DELETE` operations, whether
         the target resource was indeed deleted (OK response) or not (error responses).
         """
-        val.perform_validated_request(
+        _validation.perform_validated_request(
             path=path,
             status_code=status_code,
             request_values=request_values,
@@ -713,7 +720,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Validate the `response` against the OpenAPI Spec that is
         loaded during library initialization.
         """
-        val.validate_response_using_validator(
+        _validation.validate_response_using_validator(
             response=response,
             response_validator=self.response_validator,
         )
@@ -726,7 +733,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         Attempt to GET the resource referenced by the `href` and validate it's equal
         to the provided `referenced_resource` object / dictionary.
         """
-        val.assert_href_to_resource_is_valid(
+        _validation.assert_href_to_resource_is_valid(
             href=href,
             origin=self.origin,
             base_url=self.base_url,
@@ -750,7 +757,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         - validate that no `original_data` is preserved when performing a PUT operation
         - validate that a PATCH operation only updates the provided properties
         """
-        val.validate_response(
+        _validation.validate_response(
             path=path,
             response=response,
             response_validator=self.response_validator,
@@ -774,7 +781,9 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         In case a PATCH request, validate that only the properties that were patched
         have changed and that other properties are still at their pre-patch values.
         """
-        val.validate_send_response(response=response, original_data=original_data)
+        _validation.validate_send_response(
+            response=response, original_data=original_data
+        )
 
     # endregion
 
@@ -844,7 +853,7 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
             refstring: str,  # pylint: disable=unused-argument
             recursions: JSON,  # pylint: disable=unused-argument
         ) -> JSON:
-            return self._recursion_default
+            return self._recursion_default  # pragma: no cover
 
         try:
             # Since parsing of the OAS and creating the Spec can take a long time,
@@ -892,11 +901,11 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
 
             return parser, validation_spec, response_validator
 
-        except ResolutionError as exception:
+        except ResolutionError as exception:  # pragma: no cover
             raise FatalError(
                 f"ResolutionError while trying to load openapi spec: {exception}"
             ) from exception
-        except ValidationError as exception:
+        except ValidationError as exception:  # pragma: no cover
             raise FatalError(
                 f"ValidationError while trying to load openapi spec: {exception}"
             ) from exception

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/parameter_utils.py

@@ -24,7 +24,7 @@ def get_safe_name_for_oas_name(oas_name: str) -> str:
         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,7 +36,7 @@ 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
@@ -46,7 +46,7 @@ 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)
 

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/path_functions.py

@@ -8,9 +8,8 @@ from typing import Any
 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.protocols import GetIdPropertyNameType, GetPathDtoClassType
 from OpenApiLibCore.request_data import RequestData
 
 run_keyword = BuiltIn().run_keyword
@@ -64,7 +63,7 @@ def get_parametrized_path(path: str, openapi_spec: OpenApiObject) -> str:
 def get_valid_url(
     path: str,
     base_url: str,
-    get_dto_class: GetDtoClassType,
+    get_path_dto_class: GetPathDtoClassType,
     openapi_spec: OpenApiObject,
 ) -> str:
     try:
@@ -75,9 +74,9 @@ def get_valid_url(
         raise ValueError(
             f"{path} not found in paths section of the OpenAPI document."
         ) from None
-    dto_class = get_dto_class(path=path, method="get")
-    relations = dto_class.get_relations()
-    paths = [p.path for p in relations if isinstance(p, PathPropertiesConstraint)]
+    dto_class = get_path_dto_class(path=path)
+    relations = dto_class.get_path_relations()
+    paths = [p.path for p in relations]
     if paths:
         url = f"{base_url}{choice(paths)}"
         return url

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/path_invalidation.py

@@ -5,8 +5,7 @@ from uuid import uuid4
 
 from robot.libraries.BuiltIn import BuiltIn
 
-from OpenApiLibCore.dto_base import PathPropertiesConstraint
-from OpenApiLibCore.protocols import GetDtoClassType
+from OpenApiLibCore.protocols import GetPathDtoClassType
 
 run_keyword = BuiltIn().run_keyword
 
@@ -15,16 +14,15 @@ def get_invalidated_url(
     valid_url: str,
     path: str,
     base_url: str,
-    get_dto_class: GetDtoClassType,
+    get_path_dto_class: GetPathDtoClassType,
     expected_status_code: int,
 ) -> str:
-    dto_class = get_dto_class(path=path, method="get")
-    relations = dto_class.get_relations()
+    dto_class = get_path_dto_class(path=path)
+    relations = dto_class.get_path_relations()
     paths = [
         p.invalid_value
         for p in relations
-        if isinstance(p, PathPropertiesConstraint)
-        and p.invalid_value_error_code == expected_status_code
+        if p.invalid_value_error_code == expected_status_code
     ]
     if paths:
         url = f"{base_url}{choice(paths)}"

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/protocols.py

@@ -30,3 +30,9 @@ class GetIdPropertyNameType(Protocol):
     ) -> tuple[
         str, Callable[[str], str] | Callable[[int], int]
     ]: ...  # pragma: no cover
+
+
+class GetPathDtoClassType(Protocol):
+    def __init__(self, mappings_module_name: str) -> None: ...  # pragma: no cover
+
+    def __call__(self, path: str) -> Type[Dto]: ...  # pragma: no cover

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/resource_relations.py

@@ -4,7 +4,7 @@ from requests import Response
 from robot.api import logger
 from robot.libraries.BuiltIn import BuiltIn
 
-import OpenApiLibCore.path_functions as pf
+import OpenApiLibCore.path_functions as _path_functions
 from OpenApiLibCore.dto_base import IdReference
 from OpenApiLibCore.models import OpenApiObject
 from OpenApiLibCore.request_data import RequestData
@@ -22,7 +22,9 @@ def ensure_in_use(
 
     path = url.replace(base_url, "")
     path_parts = path.split("/")
-    parameterized_path = pf.get_parametrized_path(path=path, openapi_spec=openapi_spec)
+    parameterized_path = _path_functions.get_parametrized_path(
+        path=path, openapi_spec=openapi_spec
+    )
     parameterized_path_parts = parameterized_path.split("/")
     for part, param_part in zip(
         reversed(path_parts), reversed(parameterized_path_parts)

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/validation.py

@@ -75,7 +75,7 @@ def perform_validated_request(
             f"\nGot: {_json.dumps(response_json, indent=4, sort_keys=True)}"
         )
         raise AssertionError(
-            f"Response status_code {response.status_code} was not {status_code}"
+            f"Response status_code {response.status_code} was not {status_code}."
         )
 
     run_keyword("validate_response", path, response, original_data)
@@ -90,7 +90,7 @@ def perform_validated_request(
         if response.ok:
             if get_response.ok:
                 raise AssertionError(
-                    f"Resource still exists after deletion. Url was {request_values.url}"
+                    f"Resource still exists after deletion. Url was {request_values.url}."
                 )
             # if the path supports GET, 404 is expected, if not 405 is expected
             if get_response.status_code not in [404, 405]:
@@ -102,7 +102,7 @@ def perform_validated_request(
         elif not get_response.ok:
             raise AssertionError(
                 f"Resource could not be retrieved after failed deletion. "
-                f"Url was {request_values.url}, status_code was {get_response.status_code}"
+                f"Url was {request_values.url}, status_code was {get_response.status_code}."
             )
 
 
@@ -279,11 +279,6 @@ def validate_send_response(
         )
         return None
 
-    # FIXME: this applies to removed code
-    # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
-    # instead of a newly created resource. In this case, the send_json must be
-    # in the array of the 'array_item' property on {id}
-
     send_path: str = response.request.path_url
     response_path = response_data.get("href", None)
     if response_path and send_path not in response_path:
@@ -380,6 +375,6 @@ def _get_response_object(
     path_operations = path_item.get_operations()
     operation_data = path_operations.get(method)
     if operation_data is None:
-        raise ValueError(f"method '{method}' not supported for {path}")
+        raise ValueError(f"method '{method}' not supported for {path}.")
 
     return operation_data.responses[status]

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/OpenApiLibCore/value_utils.py

@@ -98,7 +98,7 @@ def get_invalid_value(
     # Violate min / max values or length if possible
     try:
         values_out_of_bounds = value_schema.get_values_out_of_bounds(
-            current_value=current_value
+            current_value=current_value  # type: ignore[arg-type]
         )
         invalid_values += values_out_of_bounds
     except ValueError:

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/openapi_libgen/generator.py

@@ -18,7 +18,7 @@ def load_openapi_spec(
     def recursion_limit_handler(
         limit: int, refstring: str, recursions: object
     ) -> object:  # pylint: disable=unused-argument
-        return recursion_default
+        return recursion_default  # pragma: no cover
 
     parser = ResolvingParser(
         source,
@@ -69,7 +69,7 @@ def generate(
     return f"Generated {library_name} at {output_folder.resolve().as_posix()}/{module_name}"
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     source = sys.argv[1]
     destination = Path(sys.argv[2])
     library_name = sys.argv[3]

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/openapi_libgen/parsing_utils.py

@@ -8,16 +8,20 @@ def remove_unsafe_characters_from_string(string: str) -> str:
         string_iterator = iter(string)
         capitalize_next_character = False
 
-        for character in string_iterator:
-            if character.isalpha():
-                yield character
-                break
+        # The first character must be A-z or _
+        first_character = next(string_iterator, "_")
+        if first_character.isalpha() or first_character == "_":
+            yield first_character
+        elif first_character.isnumeric():
+            yield "_" + first_character
 
         for character in string_iterator:
             if character.isalnum():
                 if capitalize_next_character:
                     capitalize_next_character = False
-                yield character
+                    yield character.upper()
+                else:
+                    yield character
 
             elif not capitalize_next_character:
                 capitalize_next_character = True

{robotframework_openapitools-1.0.0b4 → robotframework_openapitools-1.0.0b5}/src/openapi_libgen/spec_parser.py

@@ -79,7 +79,7 @@ def get_keyword_signature(operation_details: OperationDetails) -> str:
     else:
         keyword_name = remove_unsafe_characters_from_string(
             f"{operation_details.method}_{operation_details.path}"
-        )
+        ).lower()
 
     parameters = operation_details.parameters or []
     path_parameters = [p for p in parameters if p.in_ == "path" and p.schema_]
@@ -93,7 +93,7 @@ def get_keyword_signature(operation_details: OperationDetails) -> str:
     keyword_argument_names: set[str] = set()
 
     for parameter in path_parameters:
-        annotation = f"{parameter.schema_.annotation_string} = UNSET"
+        annotation = f"{parameter.schema_.annotation_string} = UNSET"  # type: ignore[union-attr]
         safe_name = get_safe_name_for_oas_name(parameter.name)
         keyword_argument_names.add(safe_name)
         argument = f", {safe_name}: {annotation}"
@@ -120,7 +120,7 @@ def get_keyword_signature(operation_details: OperationDetails) -> str:
             arguments += argument
 
     for parameter in query_parameters:
-        annotation = f"{parameter.schema_.annotation_string} = UNSET"
+        annotation = f"{parameter.schema_.annotation_string} = UNSET"  # type: ignore[union-attr]
         safe_name = get_safe_name_for_oas_name(parameter.name)
         if safe_name in keyword_argument_names:
             safe_name = "query_" + safe_name
@@ -129,7 +129,7 @@ def get_keyword_signature(operation_details: OperationDetails) -> str:
         arguments += argument
 
     for parameter in header_parameters:
-        annotation = f"{parameter.schema_.annotation_string} = UNSET"
+        annotation = f"{parameter.schema_.annotation_string} = UNSET"  # type: ignore[union-attr]
         safe_name = get_safe_name_for_oas_name(parameter.name)
         if safe_name in keyword_argument_names:
             safe_name = "header_" + safe_name