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

OpenApiDriver/openapidriver.py

@@ -1,127 +1,3 @@
-"""
-# OpenApiDriver for Robot Framework®
-
-OpenApiDriver is an extension of the Robot Framework® DataDriver library that allows
-for generation and execution of test cases based on the information in an OpenAPI
-document (also known as Swagger document).
-This document explains how to use the OpenApiDriver library.
-
-For more information about Robot Framework®, see http://robotframework.org.
-
-For more information about the DataDriver library, see
-https://github.com/Snooz82/robotframework-datadriver.
-
----
-
-> Note: OpenApiDriver is still under development 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-openapidriver`
-
----
-
-## OpenAPI (aka Swagger)
-
-The OpenAPI Specification (OAS) defines a standard, language-agnostic interface
-to RESTful APIs, see https://swagger.io/specification/
-
-The OpenApiDriver module implements a reader class that generates a test case for
-each path, method and response (i.e. every response for each endpoint) that is defined
-in an OpenAPI document, typically an openapi.json or openapi.yaml file.
-
-> Note: OpenApiDriver 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 OpenApiDriver to run automatic validations 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 OpenApiDriver.
-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.
-OpenApiDriver 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` and `origin` altered to fit your situation.
-
-``` robotframework
-*** Settings ***
-Library            OpenApiDriver
-...                    source=http://localhost:8000/openapi.json
-...                    origin=http://localhost:8000
-Test Template      Validate Using Test Endpoint Keyword
-
-*** Test Cases ***
-Test Endpoint for ${method} on ${path} where ${status_code} is expected
-
-*** Keywords ***
-Validate Using Test Endpoint Keyword
-    [Arguments]    ${path}    ${method}    ${status_code}
-    Test Endpoint
-    ...    path=${path}    method=${method}    status_code=${status_code}
-
-```
-
-Running the above suite for the first time is likely to result in some
-errors / failed tests.
-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 OpenApiDriver library parameters that you may need can be found
-[here](https://marketsquare.github.io/robotframework-openapidriver/openapidriver.html).
-
-The OpenApiDriver 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-path authorization levels (only simple 401 / 403 validation).
-
-"""
-
 from collections.abc import Mapping, MutableMapping
 from pathlib import Path
 from types import MappingProxyType
@@ -136,17 +12,16 @@ from OpenApiDriver.openapi_executors import OpenApiExecutors
 from OpenApiDriver.openapi_reader import OpenApiReader
 from OpenApiLibCore import ValidationLevel
 from OpenApiLibCore.annotations import JSON
+from openapitools_docs.docstrings import (
+    OPENAPIDRIVER_INIT_DOCSTRING,
+    OPENAPIDRIVER_LIBRARY_DOCSTRING,
+)
 
 default_str_mapping: Mapping[str, str] = MappingProxyType({})
 
 
-@library(scope="SUITE", doc_format="ROBOT")
+@library(scope="SUITE", doc_format="HTML")
 class OpenApiDriver(OpenApiExecutors, DataDriver):
-    """
-    Visit the [https://github.com/MarketSquare/robotframework-openapidriver | library page]
-    for an introduction and examples.
-    """
-
     def __init__(  # noqa: PLR0913, pylint: disable=dangerous-default-value
         self,
         source: str,
@@ -174,144 +49,7 @@ class OpenApiDriver(OpenApiExecutors, DataDriver):
         extra_headers: Mapping[str, str] = default_str_mapping,
         cookies: MutableMapping[str, str] | CookieJar | None = None,
         proxies: MutableMapping[str, str] | 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 endpoints as found in the ``paths``
-         section in the openapi document.
-         E.g. ``/petshop/v2``.
-
-         == Test case generation and execution ==
-
-         === included_paths ===
-         A list of paths that will be included when generating the test cases.
-         The ``*`` character can be used at the end of a partial path to include all paths
-         starting with the partial path (wildcard include).
-
-         === ignored_paths ===
-         A list of paths that will be ignored when generating the test cases.
-         The ``*`` character can be used at the end of a partial path to ignore all paths
-         starting with the partial path (wildcard ignore).
-
-         === ignored_responses ===
-         A list of responses that will be ignored when generating the test cases.
-
-         === ignored_testcases ===
-         A list of specific test cases that, if it would be generated, will be ignored.
-         Specific test cases to ignore must be specified as a ``tuple`` or ``list``
-         of ``path``, ``method`` and ``response``.
-
-         === 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.
-        """
+    ) -> None:
         included_paths = included_paths if included_paths else ()
         ignored_paths = ignored_paths if ignored_paths else ()
         ignored_responses = ignored_responses if ignored_responses else ()
@@ -354,16 +92,7 @@ class OpenApiDriver(OpenApiExecutors, DataDriver):
             ignored_testcases=ignored_testcases,
         )
 
+    __init__.__doc__ = OPENAPIDRIVER_INIT_DOCSTRING
 
-class DocumentationGenerator(OpenApiDriver):
-    __doc__ = OpenApiDriver.__doc__
 
-    @staticmethod
-    def get_keyword_names() -> list[str]:
-        """Curated keywords for libdoc and libspec."""
-        return [
-            "test_unauthorized",
-            "test_forbidden",
-            "test_invalid_url",
-            "test_endpoint",
-        ]  # pragma: no cover
+OpenApiDriver.__doc__ = OPENAPIDRIVER_LIBRARY_DOCSTRING

OpenApiLibCore/__init__.py

@@ -36,6 +36,32 @@ except Exception:  # pragma: no cover pylint: disable=broad-exception-caught
     pass
 
 
+KEYWORD_NAMES = [
+    "set_origin",
+    "set_security_token",
+    "set_basic_auth",
+    "set_auth",
+    "set_extra_headers",
+    "get_request_values",
+    "get_request_data",
+    "get_invalid_body_data",
+    "get_invalidated_parameters",
+    "get_json_data_with_conflict",
+    "get_valid_url",
+    "get_valid_id_for_path",
+    "get_parameterized_path_from_url",
+    "get_ids_from_url",
+    "get_invalidated_url",
+    "ensure_in_use",
+    "authorized_request",
+    "perform_validated_request",
+    "validate_response_using_validator",
+    "assert_href_to_resource_is_valid",
+    "validate_response",
+    "validate_send_response",
+]
+
+
 __all__ = [
     "IGNORE",
     "UNSET",

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