robotframework-openapitools 1.0.0b4__py3-none-any.whl → 1.0.1__py3-none-any.whl

OpenApiLibCore/openapi_libcore.py

@@ -1,123 +1,3 @@
-"""
-# OpenApiLibCore for Robot Framework
-
-The OpenApiLibCore library is a utility library that is meant to simplify creation
-of other Robot Framework libraries for API testing based on the information in
-an OpenAPI document (also known as Swagger document).
-This document explains how to use the OpenApiLibCore library.
-
-My RoboCon 2022 talk about OpenApiDriver and OpenApiLibCore can be found
-[here](https://www.youtube.com/watch?v=7YWZEHxk9Ps)
-
-For more information about Robot Framework, see http://robotframework.org.
-
----
-
-> Note: OpenApiLibCore is still being developed so there are currently
-restrictions / limitations that you may encounter when using this library to run
-tests against an API. See [Limitations](#limitations) for details.
-
----
-
-## Installation
-
-If you already have Python >= 3.8 with pip installed, you can simply run:
-
-`pip install --upgrade robotframework-openapi-libcore`
-
----
-
-## OpenAPI (aka Swagger)
-
-The OpenAPI Specification (OAS) defines a standard, language-agnostic interface
-to RESTful APIs, see https://swagger.io/specification/
-
-The OpenApiLibCore implements a number of Robot Framework keywords that make it
-easy to interact with an OpenAPI implementation by using the information in the
-openapi document (Swagger file), for examply by automatic generation of valid values
-for requests based on the schema information in the document.
-
-> Note: OpenApiLibCore is designed for APIs based on the OAS v3
-The library has not been tested for APIs based on the OAS v2.
-
----
-
-## Getting started
-
-Before trying to use the keywords exposed by OpenApiLibCore on the target API
-it's recommended to first ensure that the openapi document for the API is valid
-under the OpenAPI Specification.
-
-This can be done using the command line interface of a package that is installed as
-a prerequisite for OpenApiLibCore.
-Both a local openapi.json or openapi.yaml file or one hosted by the API server
-can be checked using the `prance validate <reference_to_file>` shell command:
-
-```shell
-prance validate --backend=openapi-spec-validator http://localhost:8000/openapi.json
-Processing "http://localhost:8000/openapi.json"...
- -> Resolving external references.
-Validates OK as OpenAPI 3.0.2!
-
-prance validate --backend=openapi-spec-validator /tests/files/petstore_openapi.yaml
-Processing "/tests/files/petstore_openapi.yaml"...
- -> Resolving external references.
-Validates OK as OpenAPI 3.0.2!
-```
-
-You'll have to change the url or file reference to the location of the openapi
-document for your API.
-
-> Note: Although recursion is technically allowed under the OAS, tool support is limited
-and changing the OAS to not use recursion is recommended.
-OpenApiLibCore has limited support for parsing OpenAPI documents with
-recursion in them. See the `recursion_limit` and `recursion_default` parameters.
-
-If the openapi document passes this validation, the next step is trying to do a test
-run with a minimal test suite.
-The example below can be used, with `source`, `origin` and `path` altered to
-fit your situation.
-
-``` robotframework
-*** Settings ***
-Library            OpenApiLibCore
-...                    source=http://localhost:8000/openapi.json
-...                    origin=http://localhost:8000
-
-*** Test Cases ***
-Getting Started
-    ${url}=    Get Valid Url    path=/employees/{employee_id}
-
-```
-
-Running the above suite for the first time may result in an error / failed test.
-You should look at the Robot Framework `log.html` to determine the reasons
-for the failing tests.
-Depending on the reasons for the failures, different solutions are possible.
-
-Details about the OpenApiLibCore library parameters and keywords that you may need can be found
-[here](https://marketsquare.github.io/robotframework-openapi-libcore/openapi_libcore.html).
-
-The OpenApiLibCore also support handling of relations between resources within the scope
-of the API being validated as well as handling dependencies on resources outside the
-scope of the API. In addition there is support for handling restrictions on the values
-of parameters and properties.
-
-Details about the `mappings_path` variable usage can be found
-[here](https://marketsquare.github.io/robotframework-openapi-libcore/advanced_use.html).
-
----
-
-## Limitations
-
-There are currently a number of limitations to supported API structures, supported
-data types and properties. The following list details the most important ones:
-- Only JSON request and response bodies are supported.
-- No support for per-endpoint authorization levels.
-- Parsing of OAS 3.1 documents is supported by the parsing tools, but runtime behavior is untested.
-
-"""
-
 import json as _json
 import sys
 from collections.abc import Mapping, MutableMapping
@@ -140,17 +20,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 (
@@ -164,27 +45,24 @@ from OpenApiLibCore.parameter_utils import (
 )
 from OpenApiLibCore.protocols import ResponseValidatorType
 from OpenApiLibCore.request_data import RequestData, RequestValues
+from openapitools_docs.docstrings import (
+    OPENAPILIBCORE_INIT_DOCSTRING,
+    OPENAPILIBCORE_LIBRARY_DOCSTRING,
+)
 
 run_keyword = BuiltIn().run_keyword
 default_str_mapping: Mapping[str, str] = MappingProxyType({})
 default_json_mapping: Mapping[str, JSON] = MappingProxyType({})
 
 
-@library(scope="SUITE", doc_format="ROBOT")
+@library(scope="SUITE", doc_format="HTML")
 class OpenApiLibCore:  # pylint: disable=too-many-public-methods
-    """
-    Main class providing the keywords and core logic to interact with an OpenAPI server.
-
-    Visit the [https://github.com/MarketSquare/robotframework-openapi-libcore | library page]
-    for an introduction.
-    """
-
     def __init__(  # noqa: PLR0913, pylint: disable=dangerous-default-value
         self,
         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,
@@ -203,126 +81,6 @@ class OpenApiLibCore:  # pylint: disable=too-many-public-methods
         cookies: MutableMapping[str, str] | CookieJar | None = None,
         proxies: MutableMapping[str, str] | None = None,
     ) -> None:
-        """
-        == Base parameters ==
-
-        === source ===
-        An absolute path to an openapi.json or openapi.yaml file or an url to such a file.
-
-        === origin ===
-        The server (and port) of the target server. E.g. ``https://localhost:8000``
-
-        === base_path ===
-        The routing between ``origin`` and the paths as found in the ``paths``
-        section in the openapi document.
-        E.g. ``/petshop/v2``.
-
-        == Test case execution ==
-
-        === response_validation ===
-         By default, a ``WARN`` is logged when the Response received after a Request does not
-         comply with the schema as defined in the openapi document for the given operation. The
-         following values are supported:
-
-         - ``DISABLED``: All Response validation errors will be ignored
-         - ``INFO``: Any Response validation erros will be logged at ``INFO`` level
-         - ``WARN``: Any Response validation erros will be logged at ``WARN`` level
-         - ``STRICT``: The Test Case will fail on any Response validation errors
-
-         === disable_server_validation ===
-         If enabled by setting this parameter to ``True``, the Response validation will also
-         include possible errors for Requests made to a server address that is not defined in
-         the list of servers in the openapi document. This generally means that if there is a
-         mismatch, every Test Case will raise this error. Note that ``localhost`` and
-         ``127.0.0.1`` are not considered the same by Response validation.
-
-        == API-specific configurations ==
-
-        === mappings_path ===
-        See [https://marketsquare.github.io/robotframework-openapi-libcore/advanced_use.html | this page]
-        for an in-depth explanation.
-
-        === invalid_property_default_response ===
-        The default response code for requests with a JSON body that does not comply
-        with the schema.
-        Example: a value outside the specified range or a string value
-        for a property defined as integer in the schema.
-
-        === default_id_property_name ===
-        The default name for the property that identifies a resource (i.e. a unique
-        entity) within the API.
-        The default value for this property name is ``id``.
-        If the target API uses a different name for all the resources within the API,
-        you can configure it globally using this property.
-
-        If different property names are used for the unique identifier for different
-        types of resources, an ``ID_MAPPING`` can be implemented using the ``mappings_path``.
-
-        === faker_locale ===
-        A locale string or list of locale strings to pass to the Faker library to be
-        used in generation of string data for supported format types.
-
-        === require_body_for_invalid_url ===
-         When a request is made against an invalid url, this usually is because of a "404" request;
-         a request for a resource that does not exist. Depending on API implementation, when a
-         request with a missing or invalid request body is made on a non-existent resource,
-         either a 404 or a 422 or 400 Response is normally returned. If the API being tested
-         processes the request body before checking if the requested resource exists, set
-         this parameter to True.
-
-        == Parsing parameters ==
-
-        === recursion_limit ===
-        The recursion depth to which to fully parse recursive references before the
-        `recursion_default` is used to end the recursion.
-
-        === recursion_default ===
-        The value that is used instead of the referenced schema when the
-        `recursion_limit` has been reached.
-        The default `{}` represents an empty object in JSON.
-        Depending on schema definitions, this may cause schema validation errors.
-        If this is the case, 'None' (``${NONE}`` in Robot Framework) or an empty list
-        can be tried as an alternative.
-
-        == Security-related parameters ==
-        _Note: these parameters are equivalent to those in the ``requests`` library._
-
-        === username ===
-        The username to be used for Basic Authentication.
-
-        === password ===
-        The password to be used for Basic Authentication.
-
-        === security_token ===
-        The token to be used for token based security using the ``Authorization`` header.
-
-        === auth ===
-        A [https://requests.readthedocs.io/en/latest/api/#authentication | requests ``AuthBase`` instance]
-        to be used for authentication instead of the ``username`` and ``password``.
-
-        === cert ===
-        The SSL certificate to use with all requests.
-        If string: the path to ssl client cert file (.pem).
-        If tuple: the ('cert', 'key') pair.
-
-        === verify_tls ===
-        Whether or not to verify the TLS / SSL certificate of the server.
-        If boolean: whether or not to verify the server TLS certificate.
-        If string: path to a CA bundle to use for verification.
-
-        === extra_headers ===
-        A dictionary with extra / custom headers that will be send with every request.
-        This parameter can be used to send headers that are not documented in the
-        openapi document or to provide an API-key.
-
-        === cookies ===
-        A dictionary or
-        [https://docs.python.org/3/library/http.cookiejar.html#http.cookiejar.CookieJar | CookieJar object]
-        to send with all requests.
-
-        === proxies ===
-        A dictionary of 'protocol': 'proxy url' to use for all requests.
-        """
         self._source = source
         self._origin = origin
         self._base_path = base_path
@@ -359,12 +117,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 +264,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 +282,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 +297,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 +319,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 +334,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 +347,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 +358,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 +375,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 +393,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 +464,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 +477,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 +490,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 +514,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 +538,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 +610,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,14 +658,19 @@ 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
 
     def read_paths(self) -> dict[str, PathItemObject]:
         return self.openapi_spec.paths
+
+    __init__.__doc__ = OPENAPILIBCORE_INIT_DOCSTRING
+
+
+OpenApiLibCore.__doc__ = OPENAPILIBCORE_LIBRARY_DOCSTRING

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)
 

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

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)}"

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

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)

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]

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:

openapi_libgen/__init__.py

@@ -0,0 +1,3 @@
+from openapitools_docs.docstrings import OPENAPILIBGEN_DOCUMENTATION
+
+__doc__ = OPENAPILIBGEN_DOCUMENTATION