panda-pytest-assertions 0.2.0__tar.gz → 0.2.1__tar.gz

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panda-pytest-assertions
-Version: 0.2.0
+Version: 0.2.1
 Summary: Complex assertions that can be used when writing test with pytest
 Home-page: https://github.com/KRunchPL/panda-pytest-assertions
 License: Apache-2.0

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/__init__.py

@@ -7,6 +7,9 @@ from ._converters import (
     ExpectationYamlLoader,
 )
 from ._expectation_modificators import (
+    Is,
+    is_type,
+    IsType,
     MappingSubset,
     ObjectAttributes,
     Stringified,
@@ -27,6 +30,9 @@ __all__ = [
     'expectation_from_yaml',
     'ExpectationYamlDumper',
     'ExpectationYamlLoader',
+    'Is',
+    'is_type',
+    'IsType',
     'MappingSubset',
     'ObjectAttributes',
     'Stringified',

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/_asserter_factories/built_in_asserter_factory.py

@@ -1,5 +1,7 @@
 from panda_pytest_assertions.assert_object._objects_asserters import (
     EqualityAsserter,
+    IdentityAsserter,
+    IsTypeAsserter,
     MappingAsserter,
     MappingSubsetAsserter,
     ObjectAttributesAsserter,
@@ -20,6 +22,8 @@ class BuiltInAsserterFactory(AsserterFactory):
 
 # MUST be the first one as it implements a fallback mechanism and matches everything
 BuiltInAsserterFactory.register_asserter(EqualityAsserter)
+BuiltInAsserterFactory.register_asserter(IdentityAsserter)
+BuiltInAsserterFactory.register_asserter(IsTypeAsserter)
 BuiltInAsserterFactory.register_asserter(MappingAsserter)
 BuiltInAsserterFactory.register_asserter(MappingSubsetAsserter)
 BuiltInAsserterFactory.register_asserter(ObjectAttributesAsserter)

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/_converters/expectation_from_yaml.py

@@ -5,6 +5,7 @@ import yaml
 from yaml.constructor import ConstructorError
 
 from panda_pytest_assertions.assert_object._expectation_modificators import (
+    IsType,
     MappingSubset,
     ObjectAttributes,
     Stringified,
@@ -112,3 +113,32 @@ def _(loader: ExpectationYamlLoader, node: yaml.Node) -> WithType:
             problem_mark=node.start_mark,
         )
     return WithType(node_data['expectation'], expected_type_name, expected_type_module)
+
+
+_IS_TYPE_KEYS = {'expected_type_name', 'expected_type_module'}
+
+
+@ExpectationYamlLoader.add_construct('!IsType')
+def _(loader: ExpectationYamlLoader, node: yaml.Node) -> IsType:
+    if not isinstance(node, yaml.MappingNode):
+        raise ConstructorError(
+            problem=f'expected a mapping node, but found {type(node)}',
+            problem_mark=node.start_mark,
+        )
+    node_data = loader.construct_mapping(node)
+    if node_data.keys() != _IS_TYPE_KEYS:
+        raise ConstructorError(
+            problem=f'IsType keys must be {_IS_TYPE_KEYS}',
+            problem_mark=node.start_mark,
+        )
+    if not isinstance(expected_type_name := node_data['expected_type_name'], str):
+        raise ConstructorError(
+            problem='value of IsType "expected_type_name" must be a string',
+            problem_mark=node.start_mark,
+        )
+    if not isinstance(expected_type_module := node_data['expected_type_module'], str | None):
+        raise ConstructorError(
+            problem='value of IsType "expected_type_module" must be a string or None',
+            problem_mark=node.start_mark,
+        )
+    return IsType(expected_type_name, expected_type_module)

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/_converters/expectation_to_yaml.py

@@ -5,6 +5,7 @@ from typing import Any, TypeVar
 import yaml
 
 from panda_pytest_assertions.assert_object._expectation_modificators import (
+    IsType,
     MappingSubset,
     ObjectAttributes,
     Stringified,
@@ -72,6 +73,11 @@ def _with_type_representer(dumper: ExpectationYamlDumper, data: WithType) -> yam
     return dumper.represent_mapping('!WithType', data.__dict__)
 
 
+@ExpectationYamlDumper.add_repr(IsType)
+def _(dumper: ExpectationYamlDumper, data: IsType) -> yaml.MappingNode:
+    return dumper.represent_mapping('!IsType', data.__dict__)
+
+
 @ExpectationYamlDumper.add_repr(Enum, is_multi=True)
 def _(dumper: ExpectationYamlDumper, data: Enum) -> yaml.Node:
     expectation = with_type(type(data))(Stringified(str(data)))

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/_expectation_modificators/__init__.py

@@ -1,3 +1,5 @@
+from .identity import Is
+from .is_type import is_type, IsType
 from .mapping_subset import MappingSubset
 from .object_attibutes import ObjectAttributes
 from .stringified import Stringified
@@ -6,6 +8,9 @@ from .with_type import with_type, WithType
 
 
 __all__ = [
+    'Is',
+    'is_type',
+    'IsType',
     'MappingSubset',
     'ObjectAttributes',
     'Stringified',

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/_expectation_modificators/identity.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+
+class Is:
+    """
+    Wrapper for the expectation that describes object identity (compared with `is` operator).
+    """
+
+    def __init__(self, value: Any, /) -> None:  # noqa: ANN401
+        #: expected object
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f'Is({self.value!r})'

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/_expectation_modificators/is_type.py

@@ -0,0 +1,90 @@
+from typing import Any, overload
+
+
+class IsType:
+    """
+    Wrapper for the expectation that checks object's type.
+    """
+
+    def __init__(
+        self,
+        expected_type_name: str,
+        expected_type_module: str | None,
+        /,
+    ) -> None:
+        #: expected name of the object type
+        self.expected_type_name = expected_type_name
+        #: expected module of the object type
+        self.expected_type_module = expected_type_module
+
+    def __repr__(self) -> str:
+        return (
+            f'IsType('
+            f'expected_type_name={self.expected_type_name!r}, '
+            f'expected_type_module={self.expected_type_module!r}'
+            f')'
+        )
+
+
+@overload
+def is_type(value_type: type[Any], /) -> IsType:  # noqa: D418
+    """
+    Create IsType expectation asserting object type.
+
+    Expected type name and type module will be extracted from the provided type.
+
+    :param value_type: type to extract expected type name and module from
+    """
+
+
+@overload
+def is_type(  # noqa: D418
+    value_type_name: str,
+    value_type_module: str | None = None,
+    /,
+) -> IsType:
+    """
+    Create IsType expectation asserting object type.
+
+    Expected type name will be equal to `value_type_name` and expected module name will be
+    equal to `value_type_module` (which can be not set if is not supposed to be asserted).
+
+    :param value_type_name: name of the expected type
+    :param value_type_module: module of the expected type
+    """
+
+
+def is_type(
+    value_type: type[Any] | str,
+    value_type_module: str | None = None,
+    /,
+) -> IsType:
+    """
+    Create IsType expectation asserting object type.
+
+    If `value_type` is a type, expected type name and type module will be extracted from this type.
+
+    If `value_type` is a string, expected type name will be equal to it and expected module name will be
+    equal to provided `value_type_module` (which can be not set if is not supposed to be asserted).
+
+    :param value_type: expected type or name of the type
+    :param value_type_module: expected type's module
+    :return: created expectation
+    """
+    match value_type, value_type_module:
+        case str(), str() | None:
+            expected_type_name = value_type
+            expected_type_module = value_type_module
+        case type(), None:
+            expected_type_name = value_type.__name__
+            expected_type_module = value_type.__module__
+        case _:
+            msg = (
+                f'IsType helper constructor does not accept the following arguments: '
+                f'{(value_type, value_type_module)}'
+            )
+            raise ValueError(msg)
+    return IsType(
+        expected_type_name,
+        expected_type_module,
+    )

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/_objects_asserters/__init__.py

@@ -3,6 +3,8 @@
 import pytest
 
 pytest.register_assert_rewrite(__name__ + '.equality_asserter')
+pytest.register_assert_rewrite(__name__ + '.identity_asserter')
+pytest.register_assert_rewrite(__name__ + '.is_type_asserter')
 pytest.register_assert_rewrite(__name__ + '.mapping_asserter')
 pytest.register_assert_rewrite(__name__ + '.mapping_subset_asserter')
 pytest.register_assert_rewrite(__name__ + '.object_attributes_asserter')
@@ -14,6 +16,8 @@ pytest.register_assert_rewrite(__name__ + '.with_type_asserter')
 
 from .asserter import Asserter
 from .equality_asserter import EqualityAsserter
+from .identity_asserter import IdentityAsserter
+from .is_type_asserter import IsTypeAsserter
 from .mapping_asserter import MappingAsserter
 from .mapping_subset_asserter import MappingSubsetAsserter
 from .object_attributes_asserter import ObjectAttributesAsserter
@@ -26,6 +30,8 @@ from .with_type_asserter import WithTypeAsserter
 __all__ = [
     'Asserter',
     'EqualityAsserter',
+    'IdentityAsserter',
+    'IsTypeAsserter',
     'MappingAsserter',
     'MappingSubsetAsserter',
     'ObjectAttributesAsserter',

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/_objects_asserters/identity_asserter.py

@@ -0,0 +1,36 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object._protocols import AsserterFactoryProtocol
+
+from .._expectation_modificators import Is  # noqa: TID252
+from .asserter import Asserter
+
+
+class IdentityAsserter(Asserter):
+    """
+    Assert that the object is identical to the expectation's value.
+    """
+
+    @classmethod
+    def matches(cls, expectation: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided expectation can be handled by this asserter.
+
+        This asserter can handle an Is expectation.
+
+        :param expectation: expectation to be tested
+        :return: whether expectation can be handled by this asserter
+        """
+        return isinstance(expectation, Is)
+
+    def __init__(self, asserter_factory: type[AsserterFactoryProtocol], expectation: Is) -> None:
+        super().__init__(asserter_factory, expectation)
+        self.expected_object = expectation.value
+
+    def assert_object(self, object_: Any) -> None:  # noqa: ANN401
+        """
+        Assert if the expectation is fulfilled by an object.
+
+        :param object_: an object to be tested
+        """
+        assert self.expected_object is object_

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/_objects_asserters/is_type_asserter.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from panda_pytest_assertions.assert_object._protocols import AsserterFactoryProtocol
+
+from .._expectation_modificators import IsType  # noqa: TID252
+from .asserter import Asserter
+
+
+class IsTypeAsserter(Asserter):
+    """
+    Assert that the object is of a proper type.
+    """
+
+    @classmethod
+    def matches(cls, expectation: Any) -> bool:  # noqa: ANN401
+        """
+        Decide whether provided expectation can be handled by this asserter.
+
+        This asserter can handle a IsType expectation.
+
+        :param expectation: expectation to be tested
+        :return: whether expectation can be handled by this asserter
+        """
+        return isinstance(expectation, IsType)
+
+    def __init__(self, asserter_factory: type[AsserterFactoryProtocol], expectation: IsType) -> None:
+        super().__init__(asserter_factory, expectation)
+        self.expected_type_name = expectation.expected_type_name
+        self.expected_type_module = expectation.expected_type_module
+
+    def assert_object(self, object_: Any) -> None:  # noqa: ANN401
+        """
+        Assert if the expectation is fulfilled by an object.
+
+        :param object_: an object to be tested
+        """
+        if object_.__class__.__name__ != self.expected_type_name:
+            msg = (
+                f'Object type ("{type(object_)}") has invalid name. '
+                f'Expected "{self.expected_type_name}", got "{object_.__class__.__name__}".'
+            )
+            raise AssertionError(msg)
+        if (
+            self.expected_type_module is not None
+            and object_.__class__.__module__ != self.expected_type_module
+        ):
+            msg = (
+                f'Object type ("{type(object_)}") is from invalid module. '
+                f'Expected "{self.expected_type_module}", got "{object_.__class__.__module__}".'
+            )
+            raise AssertionError(msg)

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/generators/__init__.py

@@ -1,5 +1,6 @@
 from ._expectation_definitions import (
     EqualityDef,
+    IsTypeDef,
     MappingDef,
     MappingSubsetDef,
     ObjectAttributesDef,
@@ -21,6 +22,7 @@ from ._generators import Generator
 
 __all__ = [
     'EqualityDef',
+    'IsTypeDef',
     'MappingDef',
     'MappingSubsetDef',
     'ObjectAttributesDef',

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/generators/_expectation_definitions/__init__.py

@@ -1,4 +1,5 @@
 from .equality import EqualityDef
+from .is_type import IsTypeDef
 from .mapping import MappingDef
 from .mapping_subset import MappingSubsetDef
 from .object_attributes import ObjectAttributesDef
@@ -14,6 +15,7 @@ from .with_type import with_type_def, WithTypeDef
 
 __all__ = [
     'EqualityDef',
+    'IsTypeDef',
     'MappingDef',
     'MappingSubsetDef',
     'ObjectAttributesDef',

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/generators/_expectation_definitions/is_type.py

@@ -0,0 +1,8 @@
+class IsTypeDef:
+    """
+    Defines expectation validating object type.
+    """
+
+    def __init__(self, /, *, include_module: bool = True) -> None:
+        #: indicator whether module shall be included in IsType expectation
+        self.include_module = include_module

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/generators/_generator_factories/built_in_generator_factory.py

@@ -1,6 +1,7 @@
 from .._generators import (  # noqa: TID252
     EqualityGenerator,
     EqualityKeyMappingGenerator,
+    IsTypeGenerator,
     MappingGenerator,
     MappingSubsetGenerator,
     ObjectAttributesGenerator,
@@ -25,6 +26,7 @@ class BuiltInGeneratorFactory(GeneratorFactory):
 
 BuiltInGeneratorFactory.register_generator(EqualityGenerator)
 BuiltInGeneratorFactory.register_generator(EqualityKeyMappingGenerator)
+BuiltInGeneratorFactory.register_generator(IsTypeGenerator)
 BuiltInGeneratorFactory.register_generator(MappingGenerator)
 BuiltInGeneratorFactory.register_generator(MappingSubsetGenerator)
 BuiltInGeneratorFactory.register_generator(ObjectAttributesGenerator)

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_object/generators/_generators/__init__.py

@@ -1,6 +1,7 @@
 from .equality_generator import EqualityGenerator
 from .equality_key_mapping_generator import EqualityKeyMappingGenerator
 from .generator import Generator
+from .is_type_generator import IsTypeGenerator
 from .mapping_generator import MappingGenerator
 from .mapping_subset_generator import MappingSubsetGenerator
 from .object_attributes_generator import ObjectAttributesGenerator
@@ -17,6 +18,7 @@ from .with_type_generator import WithTypeGenerator
 
 __all__ = [
     'Generator',
+    'IsTypeGenerator',
     'EqualityGenerator',
     'EqualityKeyMappingGenerator',
     'MappingGenerator',

panda_pytest_assertions-0.2.1/panda_pytest_assertions/assert_object/generators/_generators/is_type_generator.py

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

{panda_pytest_assertions-0.2.0 → panda_pytest_assertions-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "panda-pytest-assertions"
-version = "0.2.0"
+version = "0.2.1"
 description = "Complex assertions that can be used when writing test with pytest"
 authors = ["Cyber Panda <krunchfrompoland@gmail.com>"]
 readme = "README.md"