robotframework-openapitools 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

OpenApiDriver/__init__.py

@@ -1,41 +1,45 @@
-"""
-The OpenApiDriver package is intended to be used as a Robot Framework library.
-The following classes and constants are exposed to be used by the library user:
-- OpenApiDriver: The class to be used as a Library in the *** Settings *** section
-- IdDependency, IdReference, PathPropertiesConstraint, PropertyValueConstraint,
-    UniquePropertyValueConstraint: Classes to be subclassed by the library user
-    when implementing a custom mapping module (advanced use).
-- Dto, Relation: Base classes that can be used for type annotations.
-- IGNORE: A special constant that can be used as a value in the PropertyValueConstraint.
-"""
-
-from importlib.metadata import version
-
-from OpenApiDriver.openapidriver import OpenApiDriver
-from OpenApiLibCore.dto_base import (
-    Dto,
-    IdDependency,
-    IdReference,
-    PathPropertiesConstraint,
-    PropertyValueConstraint,
-    Relation,
-    UniquePropertyValueConstraint,
-)
-from OpenApiLibCore.value_utils import IGNORE
-
-try:
-    __version__ = version("robotframework-openapidriver")
-except Exception:  # pragma: no cover
-    pass
-
-__all__ = [
-    "Dto",
-    "IdDependency",
-    "IdReference",
-    "PathPropertiesConstraint",
-    "PropertyValueConstraint",
-    "Relation",
-    "UniquePropertyValueConstraint",
-    "IGNORE",
-    "OpenApiDriver",
-]
+# pylint: disable=invalid-name
+"""
+The OpenApiDriver package is intended to be used as a Robot Framework library.
+The following classes and constants are exposed to be used by the library user:
+- OpenApiDriver: The class to be used as a Library in the *** Settings *** section
+- IdDependency, IdReference, PathPropertiesConstraint, PropertyValueConstraint,
+    UniquePropertyValueConstraint: Classes to be subclassed by the library user
+    when implementing a custom mapping module (advanced use).
+- Dto, Relation: Base classes that can be used for type annotations.
+- IGNORE: A special constant that can be used as a value in the PropertyValueConstraint.
+"""
+
+from importlib.metadata import version
+
+from OpenApiDriver.openapidriver import OpenApiDriver
+from OpenApiLibCore.dto_base import (
+    Dto,
+    IdDependency,
+    IdReference,
+    PathPropertiesConstraint,
+    PropertyValueConstraint,
+    ResourceRelation,
+    UniquePropertyValueConstraint,
+)
+from OpenApiLibCore.validation import ValidationLevel
+from OpenApiLibCore.value_utils import IGNORE
+
+try:
+    __version__ = version("robotframework-openapidriver")
+except Exception:  # pragma: no cover pylint: disable=broad-exception-caught
+    pass
+
+
+__all__ = [
+    "IGNORE",
+    "Dto",
+    "IdDependency",
+    "IdReference",
+    "OpenApiDriver",
+    "PathPropertiesConstraint",
+    "PropertyValueConstraint",
+    "ResourceRelation",
+    "UniquePropertyValueConstraint",
+    "ValidationLevel",
+]

OpenApiDriver/openapi_executors.py

@@ -1,52 +1,70 @@
 """Module containing the classes to perform automatic OpenAPI contract validation."""
 
-from logging import getLogger
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from os import getenv
 from pathlib import Path
 from random import choice
-from typing import Any, Dict, List, Optional, Tuple, Union
+from types import MappingProxyType
 
 from requests import Response
 from requests.auth import AuthBase
 from requests.cookies import RequestsCookieJar as CookieJar
-from robot.api import SkipExecution
+from robot.api import logger
 from robot.api.deco import keyword, library
+from robot.api.exceptions import SkipExecution
 from robot.libraries.BuiltIn import BuiltIn
 
-from OpenApiLibCore import OpenApiLibCore, RequestData, RequestValues, ValidationLevel
+from OpenApiLibCore import (
+    KEYWORD_NAMES as LIBCORE_KEYWORD_NAMES,
+)
+from OpenApiLibCore import (
+    OpenApiLibCore,
+    RequestData,
+    RequestValues,
+    ValidationLevel,
+)
+from OpenApiLibCore.annotations import JSON
 
 run_keyword = BuiltIn().run_keyword
+default_str_mapping: Mapping[str, str] = MappingProxyType({})
 
 
-logger = getLogger(__name__)
+KEYWORD_NAMES = [
+    "test_unauthorized",
+    "test_forbidden",
+    "test_invalid_url",
+    "test_endpoint",
+]
 
 
 @library(scope="SUITE", doc_format="ROBOT")
-class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-attributes
+class OpenApiExecutors(OpenApiLibCore):
     """Main class providing the keywords and core logic to perform endpoint validations."""
 
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(  # noqa: PLR0913, pylint: disable=dangerous-default-value
         self,
         source: str,
         origin: str = "",
         base_path: str = "",
         response_validation: ValidationLevel = ValidationLevel.WARN,
         disable_server_validation: bool = True,
-        mappings_path: Union[str, Path] = "",
+        mappings_path: str | Path = "",
         invalid_property_default_response: int = 422,
         default_id_property_name: str = "id",
-        faker_locale: Optional[Union[str, List[str]]] = None,
+        faker_locale: str | list[str] = "",
         require_body_for_invalid_url: bool = False,
         recursion_limit: int = 1,
-        recursion_default: Any = {},
+        recursion_default: JSON = {},
         username: str = "",
         password: str = "",
         security_token: str = "",
-        auth: Optional[AuthBase] = None,
-        cert: Optional[Union[str, Tuple[str, str]]] = None,
-        verify_tls: Optional[Union[bool, str]] = True,
-        extra_headers: Optional[Dict[str, str]] = None,
-        cookies: Optional[Union[Dict[str, str], CookieJar]] = None,
-        proxies: Optional[Dict[str, str]] = None,
+        auth: AuthBase | None = None,
+        cert: str | tuple[str, str] = "",
+        verify_tls: bool | str = True,
+        extra_headers: Mapping[str, str] = default_str_mapping,
+        cookies: MutableMapping[str, str] | CookieJar | None = None,
+        proxies: MutableMapping[str, str] | None = None,
     ) -> None:
         super().__init__(
             source=source,
@@ -84,13 +102,13 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         > Note: No headers or (json) body are send with the request. For security
         reasons, the authorization validation should be checked first.
         """
-        url: str = run_keyword("get_valid_url", path, method)
+        url: str = run_keyword("get_valid_url", path)
         response = self.session.request(
             method=method,
             url=url,
             verify=False,
         )
-        if response.status_code != 401:
+        if response.status_code != int(HTTPStatus.UNAUTHORIZED):
             raise AssertionError(f"Response {response.status_code} was not 401.")
 
     @keyword
@@ -105,9 +123,9 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         > Note: No headers or (json) body are send with the request. For security
         reasons, the access rights validation should be checked first.
         """
-        url: str = run_keyword("get_valid_url", path, method)
+        url: str = run_keyword("get_valid_url", path)
         response: Response = run_keyword("authorized_request", url, method)
-        if response.status_code != 403:
+        if response.status_code != int(HTTPStatus.FORBIDDEN):
             raise AssertionError(f"Response {response.status_code} was not 403.")
 
     @keyword
@@ -118,8 +136,9 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         Perform a request for the provided 'path' and 'method' where the url for
         the `path` is invalidated.
 
-        This keyword will be `SKIPPED` if the path contains no parts that
-        can be invalidated.
+        This keyword will be `SKIPPED` if the path contains no parts
+        that can be invalidated and there is no mapping for a
+        PathPropertiesConstraint for the `expected_status_code`.
 
         The optional `expected_status_code` parameter (default: 404) can be set to the
         expected status code for APIs that do not return a 404 on invalid urls.
@@ -129,9 +148,17 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         parameters are send with the request. The `require_body_for_invalid_url`
         parameter can be set to `True` if needed.
         """
-        valid_url: str = run_keyword("get_valid_url", path, method)
+        valid_url: str = run_keyword("get_valid_url", path)
+
+        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
 
-        if not (url := run_keyword("get_invalidated_url", valid_url)):
             raise SkipExecution(
                 f"Path {path} does not contain resource references that "
                 f"can be invalidated."
@@ -139,7 +166,7 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
 
         params, headers, json_data = None, None, None
         if self.require_body_for_invalid_url:
-            request_data = self.get_request_data(method=method, endpoint=path)
+            request_data: RequestData = run_keyword("get_request_data", path, method)
             params = request_data.params
             headers = request_data.headers
             dto = request_data.dto
@@ -164,11 +191,11 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         The keyword calls other keywords to generate the neccesary data to perform
         the desired operation and validate the response against the openapi document.
         """
-        json_data: Optional[Dict[str, Any]] = None
-        original_data = None
+        json_data: dict[str, JSON] = {}
+        original_data = {}
 
-        url: str = run_keyword("get_valid_url", path, method)
-        request_data: RequestData = self.get_request_data(method=method, endpoint=path)
+        url: str = run_keyword("get_valid_url", path)
+        request_data: RequestData = run_keyword("get_request_data", path, method)
         params = request_data.params
         headers = request_data.headers
         if request_data.has_body:
@@ -177,10 +204,10 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         if method == "PATCH":
             original_data = self.get_original_data(url=url)
         # in case of a status code indicating an error, ensure the error occurs
-        if status_code >= 400:
+        if status_code >= int(HTTPStatus.BAD_REQUEST):
             invalidation_keyword_data = {
-                "get_invalid_json_data": [
-                    "get_invalid_json_data",
+                "get_invalid_body_data": [
+                    "get_invalid_body_data",
                     url,
                     method,
                     status_code,
@@ -194,14 +221,14 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
             }
             invalidation_keywords = []
 
-            if request_data.dto.get_relations_for_error_code(status_code):
-                invalidation_keywords.append("get_invalid_json_data")
+            if request_data.dto.get_body_relations_for_error_code(status_code):
+                invalidation_keywords.append("get_invalid_body_data")
             if request_data.dto.get_parameter_relations_for_error_code(status_code):
                 invalidation_keywords.append("get_invalidated_parameters")
             if invalidation_keywords:
                 if (
                     invalidation_keyword := choice(invalidation_keywords)
-                ) == "get_invalid_json_data":
+                ) == "get_invalid_body_data":
                     json_data = run_keyword(
                         *invalidation_keyword_data[invalidation_keyword]
                     )
@@ -219,13 +246,13 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
                     params, headers = run_keyword(
                         *invalidation_keyword_data["get_invalidated_parameters"]
                     )
-                    if request_data.dto_schema:
+                    if request_data.body_schema:
                         json_data = run_keyword(
-                            *invalidation_keyword_data["get_invalid_json_data"]
+                            *invalidation_keyword_data["get_invalid_body_data"]
                         )
-                elif request_data.dto_schema:
+                elif request_data.body_schema:
                     json_data = run_keyword(
-                        *invalidation_keyword_data["get_invalid_json_data"]
+                        *invalidation_keyword_data["get_invalid_body_data"]
                     )
                 else:
                     raise SkipExecution(
@@ -248,20 +275,20 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
             ),
             original_data,
         )
-        if status_code < 300 and (
+        if status_code < int(HTTPStatus.MULTIPLE_CHOICES) and (
             request_data.has_optional_properties
             or request_data.has_optional_params
             or request_data.has_optional_headers
         ):
             logger.info("Performing request without optional properties and parameters")
-            url = run_keyword("get_valid_url", path, method)
-            request_data = self.get_request_data(method=method, endpoint=path)
+            url = run_keyword("get_valid_url", path)
+            request_data = run_keyword("get_request_data", path, method)
             params = request_data.get_required_params()
             headers = request_data.get_required_headers()
             json_data = (
-                request_data.get_minimal_body_dict() if request_data.has_body else None
+                request_data.get_minimal_body_dict() if request_data.has_body else {}
             )
-            original_data = None
+            original_data = {}
             if method == "PATCH":
                 original_data = self.get_original_data(url=url)
             run_keyword(
@@ -278,15 +305,15 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
                 original_data,
             )
 
-    def get_original_data(self, url: str) -> Optional[Dict[str, Any]]:
+    def get_original_data(self, url: str) -> dict[str, JSON]:
         """
         Attempt to GET the current data for the given url and return it.
 
-        If the GET request fails, None is returned.
+        If the GET request fails, an empty dict is returned.
         """
-        original_data = None
-        path = self.get_parameterized_endpoint_from_url(url)
-        get_request_data = self.get_request_data(endpoint=path, method="GET")
+        original_data = {}
+        path = self.get_parameterized_path_from_url(url)
+        get_request_data: RequestData = run_keyword("get_request_data", path, "GET")
         get_params = get_request_data.params
         get_headers = get_request_data.headers
         response: Response = run_keyword(
@@ -295,3 +322,10 @@ class OpenApiExecutors(OpenApiLibCore):  # pylint: disable=too-many-instance-att
         if response.ok:
             original_data = response.json()
         return original_data
+
+    @staticmethod
+    def get_keyword_names() -> list[str]:
+        """Curated keywords for libdoc and libspec."""
+        if getenv("HIDE_INHERITED_KEYWORDS") == "true":
+            return KEYWORD_NAMES
+        return KEYWORD_NAMES + LIBCORE_KEYWORD_NAMES

OpenApiDriver/openapi_reader.py

@@ -1,116 +1,114 @@
-"""Module holding the OpenApiReader reader_class implementation."""
-
-from typing import Any, Dict, List, Union
-
-from DataDriver.AbstractReaderClass import AbstractReaderClass
-from DataDriver.ReaderConfig import TestCaseData
-
-
-# pylint: disable=too-few-public-methods
-class Test:
-    """
-    Helper class to support ignoring endpoint responses when generating the test cases.
-    """
-
-    def __init__(self, path: str, method: str, response: Union[str, int]):
-        self.path = path
-        self.method = method.lower()
-        self.response = str(response)
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, type(self)):
-            return False
-        return (
-            self.path == other.path
-            and self.method == other.method
-            and self.response == other.response
-        )
-
-
-class OpenApiReader(AbstractReaderClass):
-    """Implementation of the reader_class used by DataDriver."""
-
-    def get_data_from_source(self) -> List[TestCaseData]:
-        test_data: List[TestCaseData] = []
-
-        read_paths_method = getattr(self, "read_paths_method")
-        paths: Dict[str, Any] = read_paths_method()
-        self._filter_paths(paths)
-
-        ignored_responses_ = [
-            str(response) for response in getattr(self, "ignored_responses", [])
-        ]
-
-        ignored_tests = [Test(*test) for test in getattr(self, "ignored_testcases", [])]
-
-        for path, path_item in paths.items():
-            # by reseversing the items, post/put operations come before get and delete
-            for item_name, item_data in reversed(path_item.items()):
-                # this level of the OAS also contains data that's not related to a
-                # path operation
-                if item_name not in ["get", "put", "post", "delete", "patch"]:
-                    continue
-                method, method_data = item_name, item_data
-                tags_from_spec = method_data.get("tags", [])
-                for response in method_data.get("responses"):
-                    # 'default' applies to all status codes that are not specified, in
-                    # which case we don't know what to expect and therefore can't verify
-                    if (
-                        response == "default"
-                        or response in ignored_responses_
-                        or Test(path, method, response) in ignored_tests
-                    ):
-                        continue
-
-                    tag_list = _get_tag_list(
-                        tags=tags_from_spec, method=method, response=response
-                    )
-                    test_data.append(
-                        TestCaseData(
-                            arguments={
-                                "${path}": path,
-                                "${method}": method.upper(),
-                                "${status_code}": response,
-                            },
-                            tags=tag_list,
-                        ),
-                    )
-        return test_data
-
-    def _filter_paths(self, paths: Dict[str, Any]) -> None:
-        def matches_include_pattern(path: str) -> bool:
-            for included_path in included_paths:
-                if path == included_path:
-                    return True
-                if included_path.endswith("*"):
-                    wildcard_include, _, _ = included_path.partition("*")
-                    if path.startswith(wildcard_include):
-                        return True
-            return False
-
-        def matches_ignore_pattern(path: str) -> bool:
-            for ignored_path in ignored_paths:
-                if path == ignored_path:
-                    return True
-
-                if ignored_path.endswith("*"):
-                    wildcard_ignore, _, _ = ignored_path.partition("*")
-                    if path.startswith(wildcard_ignore):
-                        return True
-            return False
-
-        if included_paths := getattr(self, "included_paths", ()):
-            path_list = list(paths.keys())
-            for path in path_list:
-                if not matches_include_pattern(path):
-                    paths.pop(path)
-
-        if ignored_paths := getattr(self, "ignored_paths", ()):
-            path_list = list(paths.keys())
-            for path in path_list:
-                if matches_ignore_pattern(path):
-                    paths.pop(path)
-
-
-def _get_tag_list(tags: List[str], method: str, response: str) -> List[str]:
-    return [*tags, f"Method: {method.upper()}", f"Response: {response}"]
+"""Module holding the OpenApiReader reader_class implementation."""
+
+from typing import Sequence
+
+from DataDriver.AbstractReaderClass import AbstractReaderClass
+from DataDriver.ReaderConfig import TestCaseData
+
+from OpenApiLibCore.models import PathItemObject
+
+
+class Test:
+    """
+    Helper class to support ignoring endpoint responses when generating the test cases.
+    """
+
+    def __init__(self, path: str, method: str, response: str | int) -> None:
+        self.path = path
+        self.method = method.lower()
+        self.response = str(response)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+        return (
+            self.path == other.path
+            and self.method == other.method
+            and self.response == other.response
+        )
+
+
+class OpenApiReader(AbstractReaderClass):
+    """Implementation of the reader_class used by DataDriver."""
+
+    def get_data_from_source(self) -> list[TestCaseData]:
+        test_data: list[TestCaseData] = []
+
+        read_paths_method = getattr(self, "read_paths_method")
+        paths: dict[str, PathItemObject] = read_paths_method()
+        self._filter_paths(paths)
+
+        ignored_responses_ = [
+            str(response) for response in getattr(self, "ignored_responses", [])
+        ]
+
+        ignored_tests = [Test(*test) for test in getattr(self, "ignored_testcases", [])]
+
+        for path, path_item in paths.items():
+            path_operations = path_item.get_operations()
+
+            # by reseversing the items, post/put operations come before get and delete
+            for method, operation_data in reversed(path_operations.items()):
+                tags_from_spec = operation_data.tags
+                for response in operation_data.responses.keys():
+                    # 'default' applies to all status codes that are not specified, in
+                    # which case we don't know what to expect and therefore can't verify
+                    if (
+                        response == "default"
+                        or response in ignored_responses_
+                        or Test(path, method, response) in ignored_tests
+                    ):
+                        continue
+
+                    tag_list = _get_tag_list(
+                        tags=tags_from_spec, method=method, response=response
+                    )
+                    test_data.append(
+                        TestCaseData(
+                            arguments={
+                                "${path}": path,
+                                "${method}": method.upper(),
+                                "${status_code}": response,
+                            },
+                            tags=tag_list,
+                        ),
+                    )
+        return test_data
+
+    def _filter_paths(self, paths: dict[str, PathItemObject]) -> None:
+        def matches_include_pattern(path: str) -> bool:
+            for included_path in included_paths:
+                if path == included_path:
+                    return True
+                if included_path.endswith("*"):
+                    wildcard_include, _, _ = included_path.partition("*")
+                    if path.startswith(wildcard_include):
+                        return True
+            return False
+
+        def matches_ignore_pattern(path: str) -> bool:
+            for ignored_path in ignored_paths:
+                if path == ignored_path:
+                    return True
+
+                if ignored_path.endswith("*"):
+                    wildcard_ignore, _, _ = ignored_path.partition("*")
+                    if path.startswith(wildcard_ignore):
+                        return True
+            return False
+
+        if included_paths := getattr(self, "included_paths", ()):
+            path_list = list(paths.keys())
+            for path in path_list:
+                if not matches_include_pattern(path):
+                    paths.pop(path)
+
+        if ignored_paths := getattr(self, "ignored_paths", ()):
+            path_list = list(paths.keys())
+            for path in path_list:
+                if matches_ignore_pattern(path):
+                    paths.pop(path)
+
+
+def _get_tag_list(tags: Sequence[str], method: str, response: str) -> list[str]:
+    return [*tags, f"Method: {method.upper()}", f"Response: {response}"]