panda-pytest-assertions 0.1.0__py3-none-any.whl

panda_pytest_assertions/assert_object/generators/_generators/mapping_generator.py

@@ -0,0 +1,60 @@
+from collections.abc import Mapping
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .._expectation_definitions import MappingDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class MappingGenerator(Generator):
+    """
+    Generates Mapping expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle MappingDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, MappingDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: MappingDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.keys_generator = generator_factory.create(definition.keys_definition)
+        self.items_generators = {
+            key: generator_factory.create(value) for key, value in definition.items_definitions.items()
+        }
+
+    def generate_expectation(self, object_: Any) -> Mapping[Any, Any]:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Mapping):
+            msg = f'Expected mapping, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        if object_.keys() != self.items_generators.keys():
+            msg = (
+                f'Object has invalid keys. '
+                f'Expected: {set(self.items_generators.keys())}, got {set(object_.keys())}.'
+            )
+            raise ObjectNotMatchingDefinitionError(msg)
+        expectation = {}
+        for key, value_generator in self.items_generators.items():
+            key_expectation = self.keys_generator.generate_expectation(key)
+            value_expectation = value_generator.generate_expectation(object_[key])
+            expectation[key_expectation] = value_expectation
+        return expectation

panda_pytest_assertions/assert_object/generators/_generators/mapping_subset_generator.py

@@ -0,0 +1,57 @@
+from collections.abc import Mapping
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol, MappingSubset
+
+from .._expectation_definitions import MappingSubsetDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class MappingSubsetGenerator(Generator):
+    """
+    Generates MappingSubset expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle MappingSubsetDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, MappingSubsetDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: MappingSubsetDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.keys_generator = generator_factory.create(definition.keys_definition)
+        self.items_generators = {
+            key: generator_factory.create(value) for key, value in definition.items_definitions.items()
+        }
+
+    def generate_expectation(self, object_: Any) -> MappingSubset:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Mapping):
+            msg = f'Expected mapping, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        items_expectations = {}
+        for key, value_generator in self.items_generators.items():
+            if key not in object_:
+                msg = f'"{object_}" does not contain a key "{key}"'
+                raise ObjectNotMatchingDefinitionError(msg)
+            key_expectation = self.keys_generator.generate_expectation(key)
+            value_expectation = value_generator.generate_expectation(object_[key])
+            items_expectations[key_expectation] = value_expectation
+        return MappingSubset(items_expectations)

panda_pytest_assertions/assert_object/generators/_generators/object_attributes_generator.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol, ObjectAttributes
+
+from .._expectation_definitions import ObjectAttributesDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class ObjectAttributesGenerator(Generator):
+    """
+    Generates ObjectAttributes expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle ObjectAttributesDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, ObjectAttributesDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: ObjectAttributesDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.attributes_generators = {
+            attr_name: generator_factory.create(attr_definition)
+            for attr_name, attr_definition in definition.attributes_definitions.items()
+        }
+
+    def generate_expectation(self, object_: Any) -> ObjectAttributes:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        attributes_expectations = {}
+        for attr_name, attr_generator in self.attributes_generators.items():
+            if not hasattr(object_, attr_name):
+                msg = f'"{object_}" does not have an attribute names "{attr_name}"'
+                raise ObjectNotMatchingDefinitionError(msg)
+            attributes_expectations[attr_name] = attr_generator.generate_expectation(
+                getattr(object_, attr_name),
+            )
+        return ObjectAttributes(attributes_expectations)

panda_pytest_assertions/assert_object/generators/_generators/of_type_generator.py

@@ -0,0 +1,47 @@
+from types import NoneType
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .._expectation_definitions import OfTypeDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class OfTypeGenerator(Generator):
+    """
+    Generates custom expectation, but only if the object is of a correct type.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle OfTypeDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, OfTypeDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: OfTypeDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.object_generator = generator_factory.create(definition.object_definition)
+        self.expected_type = definition.expected_type if definition.expected_type is not None else NoneType
+
+    def generate_expectation(self, object_: Any) -> Any:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, self.expected_type):
+            msg = f'Object is expected to be "{self.expected_type}" type. Got "{type(object_)}".'
+            raise ObjectNotMatchingDefinitionError(msg)
+        return self.object_generator.generate_expectation(object_)

panda_pytest_assertions/assert_object/generators/_generators/ordered_generator.py

@@ -0,0 +1,55 @@
+from collections.abc import Iterable
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class OrderedGenerator(Generator):
+    """
+    Generates ordered collection expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle any list or tuple definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, list | tuple)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: list[Any] | tuple[Any, ...],
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.elements_generators = [generator_factory.create(element) for element in definition]
+        self.expectation_type = type(definition)
+
+    def generate_expectation(self, object_: Any) -> list[Any] | tuple[Any, ...]:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Iterable):
+            msg = f'Expected iterale, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        elements = list(object_)
+        if len(elements) != len(self.elements_generators):
+            msg = (
+                f'Object has incorrect lenght. Expected {len(self.elements_generators)}, got {len(elements)}.'
+            )
+            raise ObjectNotMatchingDefinitionError(msg)
+        return self.expectation_type(
+            generator.generate_expectation(element)
+            for element, generator in zip(elements, self.elements_generators, strict=True)
+        )

panda_pytest_assertions/assert_object/generators/_generators/stringified_generator.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object import Stringified
+
+from .._expectation_definitions import StringifiedDef  # noqa: TID252
+from .generator import Generator
+
+
+class StringifiedGenerator(Generator):
+    """
+    Generates Stringified expectation from the object.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle StringifiedDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, StringifiedDef) or (
+            isinstance(definition, type) and issubclass(definition, StringifiedDef)
+        )
+
+    def generate_expectation(self, object_: Any) -> Any:  # noqa: ANN401
+        """
+        Generate Stringified expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        return Stringified(str(object_))

panda_pytest_assertions/assert_object/generators/_generators/uniform_mapping_generator.py

@@ -0,0 +1,50 @@
+from collections.abc import Mapping
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .._expectation_definitions import UniformMappingDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class UniformMappingGenerator(Generator):
+    """
+    Generates mapping expectation using the same definition for each value.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle UniformMappingDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, UniformMappingDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: UniformMappingDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.keys_generator = generator_factory.create(definition.keys_definition)
+        self.values_generator = generator_factory.create(definition.values_definition)
+
+    def generate_expectation(self, object_: Any) -> Mapping[Any, Any]:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Mapping):
+            msg = f'Expected mapping, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        return {
+            self.keys_generator.generate_expectation(key): self.values_generator.generate_expectation(value)
+            for key, value in object_.items()
+        }

panda_pytest_assertions/assert_object/generators/_generators/uniform_mapping_subset_generator.py

@@ -0,0 +1,52 @@
+from collections.abc import Mapping
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol, MappingSubset
+
+from .._expectation_definitions import UniformMappingSubsetDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class UniformMappingSubsetGenerator(Generator):
+    """
+    Generates MappingSubset expectation using the same definition for each value.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle UniformMappingSubsetDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, UniformMappingSubsetDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: UniformMappingSubsetDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.keys_generator = generator_factory.create(definition.keys_definition)
+        self.values_generator = generator_factory.create(definition.values_definition)
+
+    def generate_expectation(self, object_: Any) -> MappingSubset:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Mapping):
+            msg = f'Expected mapping, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        items_expectations = {}
+        for key, value in object_.items():
+            key_expectation = self.keys_generator.generate_expectation(key)
+            value_expectation = self.values_generator.generate_expectation(value)
+            items_expectations[key_expectation] = value_expectation
+        return MappingSubset(items_expectations)

panda_pytest_assertions/assert_object/generators/_generators/uniform_ordered_generator.py

@@ -0,0 +1,49 @@
+from collections.abc import Iterable
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .._expectation_definitions import UniformOrderedDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class UniformOrderedGenerator(Generator):
+    """
+    Generates ordered collection expectation using the same definition for each element.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle OrderedDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, UniformOrderedDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: UniformOrderedDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.elements_generator = generator_factory.create(definition.elements_definition)
+        self.expectation_type = definition.expectation_type
+
+    def generate_expectation(self, object_: Any) -> list[Any] | tuple[Any, ...]:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Iterable):
+            msg = f'Expected iterale, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        return self.expectation_type(
+            self.elements_generator.generate_expectation(element) for element in object_
+        )

panda_pytest_assertions/assert_object/generators/_generators/union_generator.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol
+
+from .._expectation_definitions import UnionDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class UnionGenerator(Generator):
+    """
+    Generates expectation using the first definition that matches the value.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle UniformMappingDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, UnionDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: UnionDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.generators = tuple(
+            generator_factory.create(single_definition) for single_definition in definition.definitions
+        )
+
+    def generate_expectation(self, object_: Any) -> Any:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        exceptions = []
+        for generator in self.generators:
+            try:
+                return generator.generate_expectation(object_)
+            except ObjectNotMatchingDefinitionError as exc:
+                exceptions.append(exc)
+        msg = f'Object "{object_}" did not match any of the expectation definition. Errors: {exceptions!r}'
+        raise ObjectNotMatchingDefinitionError(msg)

panda_pytest_assertions/assert_object/generators/_generators/unordered_generator.py

@@ -0,0 +1,46 @@
+from collections.abc import Iterable
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol, Unordered
+
+from .._expectation_definitions import UniformUnorderedDef  # noqa: TID252
+from .exceptions import ObjectNotMatchingDefinitionError
+from .generator import Generator
+
+
+class UnorderedGenerator(Generator):
+    """
+    Generates unordered collection expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle UniformUnorderedDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, UniformUnorderedDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: UniformUnorderedDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.elements_generator = generator_factory.create(definition.elements_definition)
+
+    def generate_expectation(self, object_: Any) -> Unordered:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        if not isinstance(object_, Iterable):
+            msg = f'Expected iterale, got {type(object_)}'
+            raise ObjectNotMatchingDefinitionError(msg)
+        return Unordered([self.elements_generator.generate_expectation(element) for element in object_])

panda_pytest_assertions/assert_object/generators/_generators/with_type_generator.py

@@ -0,0 +1,46 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object import GeneratorFactoryProtocol, WithType
+
+from .._expectation_definitions import WithTypeDef  # noqa: TID252
+from .generator import Generator
+
+
+class WithTypeGenerator(Generator):
+    """
+    Generates WithType expectation.
+    """
+
+    @classmethod
+    def matches(cls, definition: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided definiton can be handled by this generator.
+
+        This generator can handle WithTypeDef definition.
+
+        :param definition: definition to be tested
+        :return: whether definition can be handled by this generator
+        """
+        return isinstance(definition, WithTypeDef)
+
+    def __init__(
+        self,
+        generator_factory: type[GeneratorFactoryProtocol],
+        definition: WithTypeDef,
+    ) -> None:
+        super().__init__(generator_factory, definition)
+        self.object_generator = generator_factory.create(definition.object_definition)
+        self.include_module = definition.include_module
+
+    def generate_expectation(self, object_: Any) -> WithType:  # noqa: ANN401
+        """
+        Generate expectation from given object.
+
+        :param object_: an object to generate expectation from
+        :return: generated expectation
+        """
+        return WithType(
+            self.object_generator.generate_expectation(object_),
+            object_.__class__.__name__,
+            object_.__class__.__module__ if self.include_module else None,
+        )