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

OpenApiLibCore/dto_utils.py

@@ -1,85 +1,125 @@
-"""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,
+    GetPathDtoClassType,
+)
+
+
+@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_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)
+
+
+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: ...  # pragma: no cover
+
+
+@overload
+def dummy_transformer(valid_id: int) -> int: ...  # pragma: no cover
+
+
+def dummy_transformer(valid_id: Any) -> Any:
+    return valid_id

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()