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

OpenApiLibCore/data_invalidation.py

@@ -0,0 +1,281 @@
+"""
+Module holding the functions related to invalidation of valid data (generated
+to make 2xx requests) to support testing for 4xx responses.
+"""
+
+from copy import deepcopy
+from random import choice
+from typing import Any
+
+from requests import Response
+from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore.dto_base import (
+    NOT_SET,
+    Dto,
+    IdReference,
+    PathPropertiesConstraint,
+    PropertyValueConstraint,
+    UniquePropertyValueConstraint,
+    resolve_schema,
+)
+from OpenApiLibCore.request_data import RequestData
+from OpenApiLibCore.value_utils import IGNORE, get_invalid_value, get_valid_value
+
+run_keyword = BuiltIn().run_keyword
+
+
+def get_invalid_json_data(
+    url: str,
+    method: str,
+    status_code: int,
+    request_data: RequestData,
+    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)
+    ]
+    if not data_relations:
+        if not request_data.dto_schema:
+            raise ValueError(
+                "Failed to invalidate: no data_relations and empty schema."
+            )
+        json_data = request_data.dto.get_invalidated_data(
+            schema=request_data.dto_schema,
+            status_code=status_code,
+            invalid_property_default_code=invalid_property_default_response,
+        )
+        return json_data
+    resource_relation = choice(data_relations)
+    if isinstance(resource_relation, UniquePropertyValueConstraint):
+        json_data = run_keyword(
+            "get_json_data_with_conflict",
+            url,
+            method,
+            request_data.dto,
+            status_code,
+        )
+    elif isinstance(resource_relation, IdReference):
+        run_keyword("ensure_in_use", url, resource_relation)
+        json_data = request_data.dto.as_dict()
+    else:
+        json_data = request_data.dto.get_invalidated_data(
+            schema=request_data.dto_schema,
+            status_code=status_code,
+            invalid_property_default_code=invalid_property_default_response,
+        )
+    return json_data
+
+
+def get_invalidated_parameters(
+    status_code: int, request_data: RequestData, invalid_property_default_response: int
+) -> tuple[dict[str, Any], dict[str, str]]:
+    if not request_data.parameters:
+        raise ValueError("No params or headers to invalidate.")
+
+    # ensure the status_code can be triggered
+    relations = request_data.dto.get_parameter_relations_for_error_code(status_code)
+    relations_for_status_code = [
+        r
+        for r in relations
+        if isinstance(r, PropertyValueConstraint)
+        and (status_code in (r.error_code, r.invalid_value_error_code))
+    ]
+    parameters_to_ignore = {
+        r.property_name
+        for r in relations_for_status_code
+        if r.invalid_value_error_code == status_code and r.invalid_value == IGNORE
+    }
+    relation_property_names = {r.property_name for r in relations_for_status_code}
+    if not relation_property_names:
+        if status_code != invalid_property_default_response:
+            raise ValueError(f"No relations to cause status_code {status_code} found.")
+
+    # ensure we're not modifying mutable properties
+    params = deepcopy(request_data.params)
+    headers = deepcopy(request_data.headers)
+
+    if status_code == invalid_property_default_response:
+        # take the params and headers that can be invalidated based on data type
+        # and expand the set with properties that can be invalided by relations
+        parameter_names = set(request_data.params_that_can_be_invalidated).union(
+            request_data.headers_that_can_be_invalidated
+        )
+        parameter_names.update(relation_property_names)
+        if not parameter_names:
+            raise ValueError(
+                "None of the query parameters and headers can be invalidated."
+            )
+    else:
+        # non-default status_codes can only be the result of a Relation
+        parameter_names = relation_property_names
+
+    # Dto mappings may contain generic mappings for properties that are not present
+    # in this specific schema
+    request_data_parameter_names = [p.get("name") for p in request_data.parameters]
+    additional_relation_property_names = {
+        n for n in relation_property_names if n not in request_data_parameter_names
+    }
+    if additional_relation_property_names:
+        logger.warn(
+            f"get_parameter_relations_for_error_code yielded properties that are "
+            f"not defined in the schema: {additional_relation_property_names}\n"
+            f"These properties will be ignored for parameter invalidation."
+        )
+        parameter_names = parameter_names - additional_relation_property_names
+
+    if not parameter_names:
+        raise ValueError(
+            f"No parameter can be changed to cause status_code {status_code}."
+        )
+
+    parameter_names = parameter_names - parameters_to_ignore
+    parameter_to_invalidate = choice(tuple(parameter_names))
+
+    # check for invalid parameters in the provided request_data
+    try:
+        [parameter_data] = [
+            data
+            for data in request_data.parameters
+            if data["name"] == parameter_to_invalidate
+        ]
+    except Exception:
+        raise ValueError(
+            f"{parameter_to_invalidate} not found in provided parameters."
+        ) from None
+
+    # get the invalid_value for the chosen parameter
+    try:
+        [invalid_value_for_error_code] = [
+            r.invalid_value
+            for r in relations_for_status_code
+            if r.property_name == parameter_to_invalidate
+            and r.invalid_value_error_code == status_code
+        ]
+    except ValueError:
+        invalid_value_for_error_code = NOT_SET
+
+    # get the constraint values if available for the chosen parameter
+    try:
+        [values_from_constraint] = [
+            r.values
+            for r in relations_for_status_code
+            if r.property_name == parameter_to_invalidate
+        ]
+    except ValueError:
+        values_from_constraint = []
+
+    # if the parameter was not provided, add it to params / headers
+    params, headers = ensure_parameter_in_parameters(
+        parameter_to_invalidate=parameter_to_invalidate,
+        params=params,
+        headers=headers,
+        parameter_data=parameter_data,
+        values_from_constraint=values_from_constraint,
+    )
+
+    # determine the invalid_value
+    if invalid_value_for_error_code != NOT_SET:
+        invalid_value = invalid_value_for_error_code
+    else:
+        if parameter_to_invalidate in params.keys():
+            valid_value = params[parameter_to_invalidate]
+        else:
+            valid_value = headers[parameter_to_invalidate]
+
+        value_schema = resolve_schema(parameter_data["schema"])
+        invalid_value = get_invalid_value(
+            value_schema=value_schema,
+            current_value=valid_value,
+            values_from_constraint=values_from_constraint,
+        )
+    logger.debug(f"{parameter_to_invalidate} changed to {invalid_value}")
+
+    # update the params / headers and return
+    if parameter_to_invalidate in params.keys():
+        params[parameter_to_invalidate] = invalid_value
+    else:
+        headers[parameter_to_invalidate] = str(invalid_value)
+    return params, headers
+
+
+def ensure_parameter_in_parameters(
+    parameter_to_invalidate: str,
+    params: dict[str, Any],
+    headers: dict[str, str],
+    parameter_data: dict[str, Any],
+    values_from_constraint: list[Any],
+) -> tuple[dict[str, Any], dict[str, str]]:
+    """
+    Returns the params, headers tuple with parameter_to_invalidate with a valid
+    value to params or headers if not originally present.
+    """
+    if (
+        parameter_to_invalidate not in params.keys()
+        and parameter_to_invalidate not in headers.keys()
+    ):
+        if values_from_constraint:
+            valid_value = choice(values_from_constraint)
+        else:
+            parameter_schema = resolve_schema(parameter_data["schema"])
+            valid_value = get_valid_value(parameter_schema)
+        if (
+            parameter_data["in"] == "query"
+            and parameter_to_invalidate not in params.keys()
+        ):
+            params[parameter_to_invalidate] = valid_value
+        if (
+            parameter_data["in"] == "header"
+            and parameter_to_invalidate not in headers.keys()
+        ):
+            headers[parameter_to_invalidate] = str(valid_value)
+    return params, headers
+
+
+def get_json_data_with_conflict(
+    url: str, base_url: str, method: str, dto: Dto, conflict_status_code: int
+) -> dict[str, Any]:
+    method = method.lower()
+    json_data = dto.as_dict()
+    unique_property_value_constraints = [
+        r for r in dto.get_relations() if isinstance(r, UniquePropertyValueConstraint)
+    ]
+    for relation in unique_property_value_constraints:
+        json_data[relation.property_name] = relation.value
+        # create a new resource that the original request will conflict with
+        if method in ["patch", "put"]:
+            post_url_parts = url.split("/")[:-1]
+            post_url = "/".join(post_url_parts)
+            # the PATCH or PUT may use a different dto than required for POST
+            # so a valid POST dto must be constructed
+            path = post_url.replace(base_url, "")
+            request_data: RequestData = run_keyword("get_request_data", path, "post")
+            post_json = request_data.dto.as_dict()
+            for key in post_json.keys():
+                if key in json_data:
+                    post_json[key] = json_data.get(key)
+        else:
+            post_url = url
+            post_json = json_data
+            path = post_url.replace(base_url, "")
+            request_data = run_keyword("get_request_data", path, "post")
+
+        response: Response = run_keyword(
+            "authorized_request",
+            post_url,
+            "post",
+            request_data.params,
+            request_data.headers,
+            post_json,
+        )
+        # conflicting resource may already exist
+        assert response.ok or response.status_code == conflict_status_code, (
+            f"get_json_data_with_conflict received {response.status_code}: {response.json()}"
+        )
+        return json_data
+    raise ValueError(
+        f"No UniquePropertyValueConstraint in the get_relations list on dto {dto}."
+    )

OpenApiLibCore/dto_base.py

@@ -7,20 +7,19 @@ test and constraints / restrictions on properties of the resources.
 from abc import ABC
 from copy import deepcopy
 from dataclasses import dataclass, fields
-from logging import getLogger
 from random import choice, shuffle
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from uuid import uuid4
 
-from OpenApiLibCore import value_utils
+from robot.api import logger
 
-logger = getLogger(__name__)
+from OpenApiLibCore import value_utils
 
 NOT_SET = object()
 SENTINEL = object()
 
 
-def resolve_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+def resolve_schema(schema: dict[str, Any]) -> dict[str, Any]:
     """
     Helper function to resolve allOf, anyOf and oneOf instances in a schema.
 
@@ -64,7 +63,7 @@ def resolve_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
     return resolved_schema
 
 
-def merge_schemas(first: Dict[str, Any], second: Dict[str, Any]) -> Dict[str, Any]:
+def merge_schemas(first: dict[str, Any], second: dict[str, Any]) -> dict[str, Any]:
     """Helper method to merge two schemas, recursively."""
     merged_schema = deepcopy(first)
     for key, value in second.items():
@@ -86,7 +85,7 @@ def merge_schemas(first: Dict[str, Any], second: Dict[str, Any]) -> Dict[str, An
     return merged_schema
 
 
-class ResourceRelation(ABC):  # pylint: disable=too-few-public-methods
+class ResourceRelation(ABC):
     """ABC for all resource relations or restrictions within the API."""
 
     property_name: str
@@ -95,10 +94,12 @@ class ResourceRelation(ABC):  # pylint: disable=too-few-public-methods
 
 @dataclass
 class PathPropertiesConstraint(ResourceRelation):
-    """The resolved path for the endpoint."""
+    """The value to be used as the ``path`` for related requests."""
 
     path: str
     property_name: str = "id"
+    invalid_value: Any = NOT_SET
+    invalid_value_error_code: int = 422
     error_code: int = 404
 
 
@@ -107,10 +108,11 @@ class PropertyValueConstraint(ResourceRelation):
     """The allowed values for property_name."""
 
     property_name: str
-    values: List[Any]
+    values: list[Any]
     invalid_value: Any = NOT_SET
     invalid_value_error_code: int = 422
     error_code: int = 422
+    treat_as_mandatory: bool = False
 
 
 @dataclass
@@ -119,7 +121,7 @@ class IdDependency(ResourceRelation):
 
     property_name: str
     get_path: str
-    operation_id: Optional[str] = None
+    operation_id: str = ""
     error_code: int = 422
 
 
@@ -141,27 +143,20 @@ class UniquePropertyValueConstraint(ResourceRelation):
     error_code: int = 422
 
 
-Relation = Union[
-    IdDependency,
-    IdReference,
-    PathPropertiesConstraint,
-    PropertyValueConstraint,
-    UniquePropertyValueConstraint,
-]
-
-
 @dataclass
 class Dto(ABC):
     """Base class for the Dto class."""
 
     @staticmethod
-    def get_parameter_relations() -> List[Relation]:
+    def get_parameter_relations() -> list[ResourceRelation]:
         """Return the list of Relations for the header and query parameters."""
         return []
 
-    def get_parameter_relations_for_error_code(self, error_code: int) -> List[Relation]:
+    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[Relation] = [
+        relations: list[ResourceRelation] = [
             r
             for r in self.get_parameter_relations()
             if r.error_code == error_code
@@ -173,13 +168,13 @@ class Dto(ABC):
         return relations
 
     @staticmethod
-    def get_relations() -> List[Relation]:
+    def get_relations() -> list[ResourceRelation]:
         """Return the list of Relations for the (json) body."""
         return []
 
-    def get_relations_for_error_code(self, error_code: int) -> List[Relation]:
+    def get_relations_for_error_code(self, error_code: int) -> list[ResourceRelation]:
         """Return the list of Relations associated with the given error_code."""
-        relations: List[Relation] = [
+        relations: list[ResourceRelation] = [
             r
             for r in self.get_relations()
             if r.error_code == error_code
@@ -190,14 +185,24 @@ class Dto(ABC):
         ]
         return relations
 
+    def get_body_relations_for_error_code(
+        self, error_code: int
+    ) -> list[ResourceRelation]:
+        """
+        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)]
+
     def get_invalidated_data(
         self,
-        schema: Dict[str, Any],
+        schema: dict[str, Any],
         status_code: int,
         invalid_property_default_code: int,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Return a data set with one of the properties set to an invalid value or type."""
-        properties: Dict[str, Any] = self.as_dict()
+        properties: dict[str, Any] = self.as_dict()
 
         schema = resolve_schema(schema)
 
@@ -207,18 +212,16 @@ class Dto(ABC):
             r for r in relations if not isinstance(r, PathPropertiesConstraint)
         ]
         property_names = [r.property_name for r in relations]
-        if status_code == invalid_property_default_code:
+        if status_code == invalid_property_default_code and schema.get("properties"):
             # add all properties defined in the schema, including optional properties
             property_names.extend((schema["properties"].keys()))
-            # remove duplicates
-            property_names = list(set(property_names))
         if not property_names:
             raise ValueError(
                 f"No property can be invalidated to cause status_code {status_code}"
             )
-        # shuffle the property_names so different properties on the Dto are invalidated
-        # when rerunning the test
-        shuffle(property_names)
+        # Remove duplicates, then shuffle the property_names so different properties on
+        # the Dto are invalidated when rerunning the test.
+        shuffle(list(set(property_names)))
         for property_name in property_names:
             # if possible, invalidate a constraint but send otherwise valid data
             id_dependencies = [
@@ -227,12 +230,12 @@ class Dto(ABC):
                 if isinstance(r, IdDependency) and r.property_name == property_name
             ]
             if id_dependencies:
-                invalid_value = uuid4().hex
+                invalid_id = uuid4().hex
                 logger.debug(
                     f"Breaking IdDependency for status_code {status_code}: replacing "
-                    f"{properties[property_name]} with {invalid_value}"
+                    f"{properties[property_name]} with {invalid_id}"
                 )
-                properties[property_name] = invalid_value
+                properties[property_name] = invalid_id
                 return properties
 
             invalid_value_from_constraint = [
@@ -293,14 +296,14 @@ class Dto(ABC):
             )
             properties[property_name] = invalid_value
             logger.debug(
-                f"Property {property_name} changed to {invalid_value} (received from "
+                f"Property {property_name} changed to {invalid_value!r} (received from "
                 f"get_invalid_value)"
             )
             return properties
-        logger.warning("get_invalidated_data returned unchanged properties")
+        logger.warn("get_invalidated_data returned unchanged properties")
         return properties  # pragma: no cover
 
-    def as_dict(self) -> Dict[Any, Any]:
+    def as_dict(self) -> dict[Any, Any]:
         """Return the dict representation of the Dto."""
         result = {}
 

OpenApiLibCore/dto_utils.py

@@ -1,85 +1,97 @@
-"""Module for helper methods and classes used by the openapi_executors module."""
-
-from dataclasses import dataclass
-from importlib import import_module
-from logging import getLogger
-from typing import Callable, Dict, Tuple, Type, Union
-
-from OpenApiLibCore.dto_base import Dto
-
-logger = getLogger(__name__)
-
-
-@dataclass
-class _DefaultIdPropertyName:
-    id_property_name: str = "id"
-
-
-DEFAULT_ID_PROPERTY_NAME = _DefaultIdPropertyName()
-
-
-@dataclass
-class DefaultDto(Dto):
-    """A default Dto that can be instantiated."""
-
-
-# pylint: disable=invalid-name, too-few-public-methods
-class get_dto_class:
-    """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[Tuple[str, str], Type[Dto]] = (
-                mappings_module.DTO_MAPPING
-            )
-        except (ImportError, AttributeError, ValueError) as exception:
-            if mappings_module_name != "no mapping":
-                logger.error(f"DTO_MAPPING was not imported: {exception}")
-            self.dto_mapping = {}
-
-    def __call__(self, endpoint: str, method: str) -> Type[Dto]:
-        try:
-            return self.dto_mapping[(endpoint, method.lower())]
-        except KeyError:
-            logger.debug(f"No Dto mapping for {endpoint} {method}.")
-            return DefaultDto
-
-
-# pylint: disable=invalid-name, too-few-public-methods
-class get_id_property_name:
-    """
-    Callable class to return the name of the property that uniquely identifies
-    the resource from user-implemented mappings file.
-    """
-
-    def __init__(self, mappings_module_name: str) -> None:
-        try:
-            mappings_module = import_module(mappings_module_name)
-            self.id_mapping: Dict[
-                str,
-                Union[
-                    str,
-                    Tuple[
-                        str, Callable[[Union[str, int, float]], Union[str, int, float]]
-                    ],
-                ],
-            ] = mappings_module.ID_MAPPING
-        except (ImportError, AttributeError, ValueError) as exception:
-            if mappings_module_name != "no mapping":
-                logger.error(f"ID_MAPPING was not imported: {exception}")
-            self.id_mapping = {}
-
-    def __call__(
-        self, endpoint: str
-    ) -> Union[
-        str, Tuple[str, Callable[[Union[str, int, float]], Union[str, int, float]]]
-    ]:
-        try:
-            return self.id_mapping[endpoint]
-        except KeyError:
-            default_id_name = DEFAULT_ID_PROPERTY_NAME.id_property_name
-            logger.debug(
-                f"No id mapping for {endpoint} ('{default_id_name}' will be used)"
-            )
-            return default_id_name
+"""Module for helper methods and classes used by the openapi_executors module."""
+
+from dataclasses import dataclass
+from importlib import import_module
+from typing import Any, Callable, Type, overload
+
+from robot.api import logger
+
+from OpenApiLibCore.dto_base import Dto
+from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
+
+
+@dataclass
+class _DefaultIdPropertyName:
+    id_property_name: str = "id"
+
+
+DEFAULT_ID_PROPERTY_NAME = _DefaultIdPropertyName()
+
+
+@dataclass
+class DefaultDto(Dto):
+    """A default Dto that can be instantiated."""
+
+
+def get_dto_class(mappings_module_name: str) -> GetDtoClassType:
+    return GetDtoClass(mappings_module_name=mappings_module_name)
+
+
+class GetDtoClass:
+    """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[tuple[str, str], Type[Dto]] = (
+                mappings_module.DTO_MAPPING
+            )
+        except (ImportError, AttributeError, ValueError) as exception:
+            if mappings_module_name != "no mapping":
+                logger.error(f"DTO_MAPPING was not imported: {exception}")
+            self.dto_mapping = {}
+
+    def __call__(self, path: str, method: str) -> Type[Dto]:
+        try:
+            return self.dto_mapping[(path, method.lower())]
+        except KeyError:
+            logger.debug(f"No Dto mapping for {path} {method}.")
+            return DefaultDto
+
+
+def get_id_property_name(mappings_module_name: str) -> GetIdPropertyNameType:
+    return GetIdPropertyName(mappings_module_name=mappings_module_name)
+
+
+class GetIdPropertyName:
+    """
+    Callable class to return the name of the property that uniquely identifies
+    the resource from user-implemented mappings file.
+    """
+
+    def __init__(self, mappings_module_name: str) -> None:
+        try:
+            mappings_module = import_module(mappings_module_name)
+            self.id_mapping: dict[
+                str,
+                str | tuple[str, Callable[[str], str] | Callable[[int], int]],
+            ] = mappings_module.ID_MAPPING
+        except (ImportError, AttributeError, ValueError) as exception:
+            if mappings_module_name != "no mapping":
+                logger.error(f"ID_MAPPING was not imported: {exception}")
+            self.id_mapping = {}
+
+    def __call__(
+        self, path: str
+    ) -> tuple[str, Callable[[str], str] | Callable[[int], int]]:
+        try:
+            value_or_mapping = self.id_mapping[path]
+            if isinstance(value_or_mapping, str):
+                return (value_or_mapping, dummy_transformer)
+            return value_or_mapping
+        except KeyError:
+            default_id_name = DEFAULT_ID_PROPERTY_NAME.id_property_name
+            logger.debug(f"No id mapping for {path} ('{default_id_name}' will be used)")
+            return (default_id_name, dummy_transformer)
+
+
+@overload
+def dummy_transformer(valid_id: str) -> str: ...
+
+
+@overload
+def dummy_transformer(valid_id: int) -> int: ...
+
+
+def dummy_transformer(valid_id: Any) -> Any:
+    return valid_id