robotframework-openapitools 1.0.0b3__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

OpenApiLibCore/dto_base.py

@@ -5,7 +5,6 @@ test and constraints / restrictions on properties of the resources.
 """
 
 from abc import ABC
-from copy import deepcopy
 from dataclasses import dataclass, fields
 from random import choice, shuffle
 from typing import Any
@@ -14,77 +13,13 @@ from uuid import uuid4
 from robot.api import logger
 
 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):
     """ABC for all resource relations or restrictions within the API."""
 
@@ -148,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
@@ -168,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
@@ -185,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]:
@@ -192,29 +134,31 @@ 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,
-        schema: dict[str, Any],
+        schema: ObjectSchema,
         status_code: int,
         invalid_property_default_code: int,
     ) -> 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()
 
-        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 and schema.get("properties"):
+        if status_code == invalid_property_default_code:
             # add all properties defined in the schema, including optional properties
-            property_names.extend((schema["properties"].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}"
@@ -232,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
@@ -256,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]
@@ -311,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

OpenApiLibCore/dto_utils.py

@@ -7,7 +7,11 @@ from typing import Any, Callable, Type, overload
 from robot.api import logger
 
 from OpenApiLibCore.dto_base import Dto
-from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
+from OpenApiLibCore.protocols import (
+    GetDtoClassType,
+    GetIdPropertyNameType,
+    GetPathDtoClassType,
+)
 
 
 @dataclass
@@ -49,6 +53,30 @@ class GetDtoClass:
             return DefaultDto
 
 
+def get_path_dto_class(mappings_module_name: str) -> GetPathDtoClassType:
+    return GetPathDtoClass(mappings_module_name=mappings_module_name)
+
+
+class GetPathDtoClass:
+    """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[str, Type[Dto]] = mappings_module.PATH_MAPPING
+        except (ImportError, AttributeError, ValueError) as exception:
+            if mappings_module_name != "no mapping":
+                logger.error(f"PATH_MAPPING was not imported: {exception}")
+            self.dto_mapping = {}
+
+    def __call__(self, path: str) -> Type[Dto]:
+        try:
+            return self.dto_mapping[path]
+        except KeyError:
+            logger.debug(f"No Dto mapping for {path}.")
+            return DefaultDto
+
+
 def get_id_property_name(mappings_module_name: str) -> GetIdPropertyNameType:
     return GetIdPropertyName(mappings_module_name=mappings_module_name)
 
@@ -86,11 +114,11 @@ class GetIdPropertyName:
 
 
 @overload
-def dummy_transformer(valid_id: str) -> str: ...
+def dummy_transformer(valid_id: str) -> str: ...  # pragma: no cover
 
 
 @overload
-def dummy_transformer(valid_id: int) -> int: ...
+def dummy_transformer(valid_id: int) -> int: ...  # pragma: no cover
 
 
 def dummy_transformer(valid_id: Any) -> Any:

OpenApiLibCore/localized_faker.py

@@ -0,0 +1,88 @@
+import datetime
+from typing import Callable
+
+import faker
+
+
+def fake_string(string_format: str) -> str:
+    """
+    Generate a random string based on the provided format if the format is supported.
+    """
+    # format names may contain -, which is invalid in Python naming
+    string_format = string_format.replace("-", "_")
+    fake_generator = getattr(FAKE, string_format, FAKE.uuid)
+    value: str = fake_generator()
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%dT%H:%M:%SZ")
+    return value
+
+
+class LocalizedFaker:
+    """Class to support setting a locale post-init."""
+
+    # pylint: disable=missing-function-docstring
+    def __init__(self) -> None:
+        self.fake = faker.Faker()
+
+    def set_locale(self, locale: str | list[str]) -> None:
+        """Update the fake attribute with a Faker instance with the provided locale."""
+        self.fake = faker.Faker(locale)
+
+    @property
+    def date(self) -> Callable[[], str]:
+        return self.fake.date
+
+    @property
+    def date_time(self) -> Callable[[], datetime.datetime]:
+        return self.fake.date_time
+
+    @property
+    def password(self) -> Callable[[], str]:
+        return self.fake.password
+
+    @property
+    def binary(self) -> Callable[[], bytes]:
+        return self.fake.binary
+
+    @property
+    def email(self) -> Callable[[], str]:
+        return self.fake.safe_email
+
+    @property
+    def uuid(self) -> Callable[[], str]:
+        return self.fake.uuid4
+
+    @property
+    def uri(self) -> Callable[[], str]:
+        return self.fake.uri
+
+    @property
+    def url(self) -> Callable[[], str]:
+        return self.fake.url
+
+    @property
+    def hostname(self) -> Callable[[], str]:
+        return self.fake.hostname
+
+    @property
+    def ipv4(self) -> Callable[[], str]:
+        return self.fake.ipv4
+
+    @property
+    def ipv6(self) -> Callable[[], str]:
+        return self.fake.ipv6
+
+    @property
+    def name(self) -> Callable[[], str]:
+        return self.fake.name
+
+    @property
+    def text(self) -> Callable[[], str]:
+        return self.fake.text
+
+    @property
+    def description(self) -> Callable[[], str]:
+        return self.fake.text
+
+
+FAKE = LocalizedFaker()