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

OpenApiLibCore/data_invalidation.py

@@ -0,0 +1,294 @@
+"""
+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.annotations import JSON
+from OpenApiLibCore.dto_base import (
+    NOT_SET,
+    Dto,
+    IdReference,
+    PropertyValueConstraint,
+    UniquePropertyValueConstraint,
+)
+from OpenApiLibCore.models import ParameterObject, UnionTypeSchema
+from OpenApiLibCore.request_data import RequestData
+from OpenApiLibCore.value_utils import IGNORE, get_invalid_value
+
+run_keyword = BuiltIn().run_keyword
+
+
+def get_invalid_body_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_body_relations_for_error_code(status_code)
+    if not data_relations:
+        if request_data.body_schema is None:
+            raise ValueError(
+                "Failed to invalidate: request_data does not contain a body_schema."
+            )
+        json_data = request_data.dto.get_invalidated_data(
+            schema=request_data.body_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:
+        if request_data.body_schema is None:
+            raise ValueError(
+                "Failed to invalidate: request_data does not contain a body_schema."
+            )
+        json_data = request_data.dto.get_invalidated_data(
+            schema=request_data.body_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, JSON], dict[str, JSON]]:
+    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.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 = parameter_data.schema_
+        if value_schema is None:
+            raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+        if isinstance(value_schema, UnionTypeSchema):
+            # FIXME: extra handling may be needed in case of values_from_constraint
+            value_schema = choice(value_schema.resolved_schemas)
+
+        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, JSON],
+    headers: dict[str, JSON],
+    parameter_data: ParameterObject,
+    values_from_constraint: list[JSON],
+) -> tuple[dict[str, JSON], dict[str, JSON]]:
+    """
+    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:
+            value_schema = parameter_data.schema_
+            if value_schema is None:
+                raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+            if isinstance(value_schema, UnionTypeSchema):
+                value_schema = choice(value_schema.resolved_schemas)
+            valid_value = value_schema.get_valid_value()
+        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

@@ -5,88 +5,22 @@ 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
+from OpenApiLibCore.models import NullSchema, ObjectSchema, UnionTypeSchema
+from OpenApiLibCore.parameter_utils import get_oas_name_from_safe_name
 
 NOT_SET = object()
 SENTINEL = object()
 
 
-def resolve_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Helper function to resolve allOf, anyOf and oneOf instances in a schema.
-
-    The schemas are used to generate values for headers, query parameters and json
-    bodies to be able to make requests.
-    """
-    # Schema is mutable, so deepcopy to prevent mutation of original schema argument
-    resolved_schema = deepcopy(schema)
-
-    # allOf / anyOf / oneOf may be nested, so recursively resolve the dict-typed values
-    for key, value in resolved_schema.items():
-        if isinstance(value, dict):
-            resolved_schema[key] = resolve_schema(value)
-
-    # When handling allOf there should no duplicate keys, so the schema parts can
-    # just be merged after resolving the individual parts
-    if schema_parts := resolved_schema.pop("allOf", None):
-        for schema_part in schema_parts:
-            resolved_part = resolve_schema(schema_part)
-            resolved_schema = merge_schemas(resolved_schema, resolved_part)
-    # Handling anyOf and oneOf requires extra logic to deal with the "type" information.
-    # Some properties / parameters may be of different types and each type may have its
-    # own restrictions e.g. a parameter that accepts an enum value (string) or an
-    # integer value within a certain range.
-    # Since the library needs all this information for different purposes, the
-    # schema_parts cannot be merged, so a helper property / key "types" is introduced.
-    any_of = resolved_schema.pop("anyOf", [])
-    one_of = resolved_schema.pop("oneOf", [])
-    schema_parts = any_of if any_of else one_of
-
-    for schema_part in schema_parts:
-        resolved_part = resolve_schema(schema_part)
-        if isinstance(resolved_part, dict) and "type" in resolved_part.keys():
-            if "types" in resolved_schema.keys():
-                resolved_schema["types"].append(resolved_part)
-            else:
-                resolved_schema["types"] = [resolved_part]
-        else:
-            resolved_schema = merge_schemas(resolved_schema, resolved_part)
-
-    return resolved_schema
-
-
-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():
-        # for existing keys, merge dict and list values, leave others unchanged
-        if key in merged_schema.keys():
-            if isinstance(value, dict):
-                # if the key holds a dict, merge the values (e.g. 'properties')
-                merged_schema[key].update(value)
-            elif isinstance(value, list):
-                # if the key holds a list, extend the values (e.g. 'required')
-                merged_schema[key].extend(value)
-            elif value != merged_schema[key]:
-                logger.debug(
-                    f"key '{key}' with value '{merged_schema[key]}'"
-                    f" not updated to '{value}'"
-                )
-        else:
-            merged_schema[key] = value
-    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 +29,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 +43,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 +56,7 @@ class IdDependency(ResourceRelation):
 
     property_name: str
     get_path: str
-    operation_id: Optional[str] = None
+    operation_id: str = ""
     error_code: int = 422
 
 
@@ -141,27 +78,40 @@ 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_path_relations() -> list[PathPropertiesConstraint]:
+        """Return the list of Relations for the header and query parameters."""
+        return []
+
+    def get_path_relations_for_error_code(
+        self, error_code: int
+    ) -> list[PathPropertiesConstraint]:
+        """Return the list of Relations associated with the given error_code."""
+        relations: list[PathPropertiesConstraint] = [
+            r
+            for r in self.get_path_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
+
+    @staticmethod
+    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 +123,18 @@ 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]:
-        """Return the list of Relations associated with the given error_code."""
-        relations: List[Relation] = [
+    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.
+        """
+        relations: list[ResourceRelation] = [
             r
             for r in self.get_relations()
             if r.error_code == error_code
@@ -192,33 +147,25 @@ class Dto(ABC):
 
     def get_invalidated_data(
         self,
-        schema: Dict[str, Any],
+        schema: ObjectSchema,
         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)
-
-        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"].keys()))
-            # remove duplicates
-            property_names = list(set(property_names))
+            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}"
             )
-        # 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 +174,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"Breaking IdDependency for status_code {status_code}: setting "
+                    f"{property_name} to {invalid_id}"
                 )
-                properties[property_name] = invalid_value
+                properties[property_name] = invalid_id
                 return properties
 
             invalid_value_from_constraint = [
@@ -253,31 +200,30 @@ class Dto(ABC):
                 )
                 return properties
 
-            value_schema = schema["properties"][property_name]
-            value_schema = resolve_schema(value_schema)
-
-            # Filter "type": "null" from the possible types since this indicates an
-            # optional / nullable property that can only be invalidated by sending
-            # invalid data of a non-null type
-            if value_schemas := value_schema.get("types"):
-                if len(value_schemas) > 1:
-                    value_schemas = [
-                        schema for schema in value_schemas if schema["type"] != "null"
-                    ]
-                value_schema = choice(value_schemas)
+            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
+                # invalid data of a non-null type
+                non_null_schemas = [
+                    s
+                    for s in value_schema.resolved_schemas
+                    if not isinstance(s, NullSchema)
+                ]
+                value_schema = choice(non_null_schemas)
 
             # there may not be a current_value when invalidating an optional property
             current_value = properties.get(property_name, SENTINEL)
             if current_value is SENTINEL:
                 # the current_value isn't very relevant as long as the type is correct
                 # so no logic to handle Relations / objects / arrays here
-                property_type = value_schema["type"]
+                property_type = value_schema.type
                 if property_type == "object":
                     current_value = {}
                 elif property_type == "array":
                     current_value = []
                 else:
-                    current_value = value_utils.get_valid_value(value_schema)
+                    current_value = value_schema.get_valid_value()
 
             values_from_constraint = [
                 r.values[0]
@@ -293,14 +239,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 = {}
 
@@ -308,7 +254,7 @@ class Dto(ABC):
             field_name = field.name
             if field_name not in self.__dict__:
                 continue
-            original_name = field.metadata["original_property_name"]
+            original_name = get_oas_name_from_safe_name(field_name)
             result[original_name] = getattr(self, field_name)
 
         return result