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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panda-pytest-assertions
-Version: 0.1.1
+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.1.1 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_context/__init__.py

@@ -6,10 +6,11 @@ pytest.register_assert_rewrite(__name__ + '._assert_context')
 # isort: on
 
 
-from ._assert_context import assert_context, AssertContext
+from ._assert_context import assert_context, AssertContext, ExceptionMatch
 
 
 __all__ = [
     'assert_context',
     'AssertContext',
+    'ExceptionMatch',
 ]

{panda_pytest_assertions-0.1.1 → panda_pytest_assertions-0.2.1}/panda_pytest_assertions/assert_context/_assert_context.py

@@ -1,6 +1,6 @@
 from collections.abc import Generator
 from contextlib import contextmanager, ExitStack, nullcontext
-from typing import Any, overload
+from typing import Any, NamedTuple, overload
 
 import pytest
 
@@ -32,18 +32,29 @@ class AssertContext:
         assert expected_result == self._result
 
 
+class ExceptionMatch(NamedTuple):
+    #: type of expected exception
+    type_: type[BaseException]
+    #: match parameter passed to pytest.raises
+    match_: str
+
+
 @overload
 @contextmanager
 def assert_context(  # noqa: D418
     *,
-    exception: type[BaseException] | _Unset = ...,
+    exception: type[BaseException] | ExceptionMatch | None | _Unset = ...,
     result: Any | _Unset = ...,  # noqa: ANN401
 ) -> Generator[AssertContext, None, None]:
     """
     Context manager that makes sure `with` block behaved according to the arguments.
 
-    If the `exception` parameter is set, the `with` block is expected to raise an exception of provided type.
-    If it is NOT set, the `with` block is expected NOT TO raise any exceptions.
+    If the `exception` parameter is set to exception type, the `with` block is expected to raise an exception
+    of provided type. If the `exception` parameter is set to an instance of `ExceptionMatch` class, the `with`
+    block is expected to raise an exception of type specified in `type_` field and the value that matches the
+    string specified in `match_` field. For exact matching logic see `match` parameter of the `pytest.raises`.
+    If the `exception` parameter is NOT set or is set to `None`, the `with` block is expected NOT TO raise
+    any exceptions.
 
     If the `result` parameter is set, its value is expected to be equal to `with` block result. The `with`
     block result is set with the `set` method of an object yielded by the context manager. The comparison
@@ -51,7 +62,7 @@ def assert_context(  # noqa: D418
     If the `result` parameter is NOT set, the `set` method of yielded object is expected
     not to be called at all.
 
-    :param exception: type of exception, expected to be raised
+    :param exception: specification of exception, expected to be raised
     :param result: value expected to be set with `set` method of yielded object
     """
 
@@ -60,7 +71,7 @@ def assert_context(  # noqa: D418
 @contextmanager
 def assert_context(  # noqa: D418
     *,
-    behaviour: type[BaseException] | Any | _Unset = ...,  # noqa: ANN401
+    behaviour: type[BaseException] | ExceptionMatch | Any | _Unset = ...,  # noqa: ANN401
 ) -> Generator[AssertContext, None, None]:
     """
     Context manager that makes sure `with` block behaved according to the arguments.
@@ -68,9 +79,11 @@ def assert_context(  # noqa: D418
     Context manager yields a single object used that provides `set` method used to set the `with`
     block result that is to be asserted.
 
-    If the `behaviour` parameter is set to an exception type, the `with` block is expected
-    to raise an exception of provided type and the `set` method of yielded object is expected
-    not to be called at all.
+    If the `behaviour` parameter is set to exception type, the `with` block is expected to raise an exception
+    of provided type. If the `behaviour` parameter is set to an instance of `ExceptionMatch` class, the `with`
+    block is expected to raise an exception of type specified in `type_` field and the value that matches the
+    string specified in `match_` field. For exact matching logic see `match` parameter of the `pytest.raises`.
+    In both cases the `set` method of yielded object is expected not to be called at all.
 
     If the `behaviour` parameter is set to anything else, its value is expected to be equal to `with`
     block result. The comparison is used with `==` operator, where `result` argument is on the left side and
@@ -86,20 +99,24 @@ def assert_context(  # noqa: D418
 @contextmanager
 def assert_context(
     *,
-    exception: type[BaseException] | _Unset = _UNSET,
+    exception: type[BaseException] | ExceptionMatch | None | _Unset = _UNSET,
     result: Any | _Unset = _UNSET,
-    behaviour: type[BaseException] | Any | _Unset = _UNSET,
+    behaviour: type[BaseException] | ExceptionMatch | Any | _Unset = _UNSET,
 ) -> Generator[AssertContext, None, None]:
     """
     Context manager that makes sure `with` block behaved according to the arguments.
 
     Pair of parameters `exception` and `result` are exclusive with parameter `behaviour`. If `behaviour`
-    is set to an exception type, it is the same as if `exception` would be set to this value and `result`
-    would not be set. If `behaviour` is set to any other value, its treated as the value of `result` and the
-    `exception` remains unset.
+    is set to an exception type or `ExceptionMatch` instance, it is the same as if `exception` would be set to
+    this value and `result` would not be set. If `behaviour` is set to any other value, its treated as the
+    value of `result` and the `exception` remains unset.
 
-    If the `exception` parameter is set, the `with` block is expected to raise an exception of provided type.
-    If it is NOT set, the `with` block is expected NOT TO raise any exceptions.
+    If the `exception` parameter is set to exception type, the `with` block is expected to raise an exception
+    of provided type. If the `exception` parameter is set to an instance of `ExceptionMatch` class, the `with`
+    block is expected to raise an exception of type specified in `type_` field and the value that matches the
+    string specified in `match_` field. For exact matching logic see `match` parameter of the `pytest.raises`.
+    If the `exception` parameter is NOT set or is set to `None`, the `with` block is expected NOT TO raise
+    any exceptions.
 
     If the `result` parameter is set, its value is expected to be equal to `with` block result. The `with`
     block result is set with the `set` method of an object yielded by the context manager. The comparison
@@ -107,7 +124,7 @@ def assert_context(
     If the `result` parameter is NOT set, the `set` method of yielded object is expected
     not to be called at all.
 
-    :param exception: type of exception, expected to be raised
+    :param exception: specification of exception, expected to be raised
     :param result: value expected to be set with `set` method of yielded object
     :param behaviour: a common name for `exception` and `result` parameters, exclusive to them
     :yield: object used to set the result of a `with` block
@@ -115,12 +132,26 @@ def assert_context(
     if behaviour != _UNSET:
         assert exception == _UNSET
         assert result == _UNSET
-        if isinstance(behaviour, type) and issubclass(behaviour, BaseException):
+        if isinstance(behaviour, ExceptionMatch) or (
+            isinstance(behaviour, type) and issubclass(behaviour, BaseException)
+        ):
             exception = behaviour
         else:
             result = behaviour
+    if isinstance(exception, ExceptionMatch):
+        match_ = exception.match_
+        exception = exception.type_
+    else:
+        match_ = None
     context = AssertContext()
-    exception_behaviour = nullcontext() if isinstance(exception, _Unset) else pytest.raises(exception)
+    exception_behaviour = (
+        nullcontext()
+        if isinstance(exception, _Unset | None)
+        else pytest.raises(
+            exception,
+            match=match_,
+        )
+    )
 
     with ExitStack() as behaviours_stack:
         behaviours_stack.enter_context(context.assert_result_equal(result))

{panda_pytest_assertions-0.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → 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.1.1 → panda_pytest_assertions-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "panda-pytest-assertions"
-version = "0.1.1"
+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"