assertpy2 2.3.3__tar.gz → 2.3.4__tar.gz

{assertpy2-2.3.3 → assertpy2-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.3
+Version: 2.3.4
 Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
@@ -160,25 +160,25 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- **Composable matchers**: `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
-- **Structural matching**: `matches_structure()` for declarative dict/API response validation.
-- **Async assertions**: `eventually()` with polling/retry for async and eventual consistency testing.
-- **Structured errors**: `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
+- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
+- [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
+- [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- **Soft assertions**: thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
-- **Fluent chaining**: write assertions as readable one-liners that chain naturally.
-- **Dynamic assertions**: `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
-- **Dict comparison**: `is_equal_to()` with `ignore` and `include` for selective key matching.
-- **Extracting**: flatten collections on attributes with `filter` and `sort` support.
-- **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
-- **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
-- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
-- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
-- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
-- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
-- **Extensions**: add custom assertions via `add_extension()`.
-- Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
+- [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
+- [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
+- [**Extracting**](docs/api.md#objects): flatten collections on attributes with `filter` and `sort` support.
+- [**File assertions**](docs/api.md#files): `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
+- [**Snapshot testing**](docs/api.md#snapshot-testing): store and compare data structures in JSON format, inspired by Jest.
+- [**Allure integration**](docs/api.md#allure-integration): auto-attach structured diff and actual/expected data to Allure reports.
+- [**Behave step matchers**](docs/api.md#behave-step-matchers): ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- [**Custom matchers**](docs/api.md#custom-matchers---registering-domain-matchers): register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- [**Regex group extraction**](docs/api.md#regex-group-extraction): `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
+- [**Extensions**](docs/api.md#extension-system---adding-custom-assertions): add custom assertions via `add_extension()`.
+- [Strings](docs/api.md#strings), [numbers](docs/api.md#numbers), [lists](docs/api.md#lists), [tuples](docs/api.md#tuples), [sets](docs/api.md#sets), [dicts](docs/api.md#dicts), [dates](docs/api.md#dates), [booleans](docs/api.md#booleans), [objects](docs/api.md#objects), [exceptions](docs/api.md#failure).
 
 
 ## Composable matchers

{assertpy2-2.3.3 → assertpy2-2.3.4}/README.md

@@ -125,25 +125,25 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- **Composable matchers**: `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
-- **Structural matching**: `matches_structure()` for declarative dict/API response validation.
-- **Async assertions**: `eventually()` with polling/retry for async and eventual consistency testing.
-- **Structured errors**: `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
+- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
+- [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
+- [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- **Soft assertions**: thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
-- **Fluent chaining**: write assertions as readable one-liners that chain naturally.
-- **Dynamic assertions**: `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
-- **Dict comparison**: `is_equal_to()` with `ignore` and `include` for selective key matching.
-- **Extracting**: flatten collections on attributes with `filter` and `sort` support.
-- **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
-- **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
-- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
-- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
-- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
-- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
-- **Extensions**: add custom assertions via `add_extension()`.
-- Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
+- [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
+- [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
+- [**Extracting**](docs/api.md#objects): flatten collections on attributes with `filter` and `sort` support.
+- [**File assertions**](docs/api.md#files): `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
+- [**Snapshot testing**](docs/api.md#snapshot-testing): store and compare data structures in JSON format, inspired by Jest.
+- [**Allure integration**](docs/api.md#allure-integration): auto-attach structured diff and actual/expected data to Allure reports.
+- [**Behave step matchers**](docs/api.md#behave-step-matchers): ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- [**Custom matchers**](docs/api.md#custom-matchers---registering-domain-matchers): register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- [**Regex group extraction**](docs/api.md#regex-group-extraction): `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
+- [**Extensions**](docs/api.md#extension-system---adding-custom-assertions): add custom assertions via `add_extension()`.
+- [Strings](docs/api.md#strings), [numbers](docs/api.md#numbers), [lists](docs/api.md#lists), [tuples](docs/api.md#tuples), [sets](docs/api.md#sets), [dicts](docs/api.md#dicts), [dates](docs/api.md#dates), [booleans](docs/api.md#booleans), [objects](docs/api.md#objects), [exceptions](docs/api.md#failure).
 
 
 ## Composable matchers

{assertpy2-2.3.3 → assertpy2-2.3.4}/assertpy2/__init__.py

@@ -12,7 +12,7 @@ from .assertpy import (
 from .async_assertions import AsyncAssertionBuilder
 from .errors import AssertionFailure, DiffEntry, DiffResult
 from .file import contents_of
-from .matchers import Matcher, match, register_matcher, unregister_matcher
+from .matchers import Matcher, clear_custom_matchers, match, register_matcher, unregister_matcher
 
 __all__ = [
     "AssertionFailure",
@@ -25,6 +25,7 @@ __all__ = [
     "add_extension",
     "assert_that",
     "assert_warn",
+    "clear_custom_matchers",
     "contents_of",
     "fail",
     "match",

{assertpy2-2.3.3 → assertpy2-2.3.4}/assertpy2/assertpy.py

@@ -73,7 +73,7 @@ from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.3.3"
+__version__ = "2.3.4"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch

{assertpy2-2.3.3 → assertpy2-2.3.4}/assertpy2/matchers.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import threading
 import uuid as _uuid_mod
 from collections.abc import Callable
 from typing import Any, Protocol, runtime_checkable
@@ -117,7 +118,10 @@ class GreaterThanMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value > self.boundary
+        try:
+            return value > self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value greater than <{self.boundary}>"
@@ -128,7 +132,10 @@ class GreaterThanOrEqualToMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value >= self.boundary
+        try:
+            return value >= self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value greater than or equal to <{self.boundary}>"
@@ -139,7 +146,10 @@ class LessThanMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value < self.boundary
+        try:
+            return value < self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value less than <{self.boundary}>"
@@ -150,7 +160,10 @@ class LessThanOrEqualToMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value <= self.boundary
+        try:
+            return value <= self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value less than or equal to <{self.boundary}>"
@@ -162,7 +175,10 @@ class BetweenMatcher(BaseMatcher):
         self.high = high
 
     def matches(self, value: Any) -> bool:
-        return self.low <= value <= self.high
+        try:
+            return self.low <= value <= self.high
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value between <{self.low}> and <{self.high}>"
@@ -174,7 +190,10 @@ class CloseToMatcher(BaseMatcher):
         self.tolerance = tolerance
 
     def matches(self, value: Any) -> bool:
-        return abs(value - self.expected) <= self.tolerance
+        try:
+            return abs(value - self.expected) <= self.tolerance
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value within <{self.tolerance}> of <{self.expected}>"
@@ -502,7 +521,7 @@ class StructureMatcher(BaseMatcher):
     def matches(self, value: Any) -> bool:
         if not isinstance(value, dict):
             return False
-        return self._match_recursive(value, self._spec, "") is None
+        return self._match_recursive(value, self._spec, "", set()) is None
 
     def describe(self) -> str:
         return f"a dict matching structure {self._describe_spec(self._spec)}"
@@ -510,12 +529,16 @@ class StructureMatcher(BaseMatcher):
     def describe_mismatch(self, value: Any) -> str:
         if not isinstance(value, dict):
             return f"was not a dict: <{value}>"
-        error = self._match_recursive(value, self._spec, "")
+        error = self._match_recursive(value, self._spec, "", set())
         if error:
             return error
         return f"was <{value}>"
 
-    def _match_recursive(self, value: dict, spec: dict, path: str) -> str | None:
+    def _match_recursive(self, value: dict, spec: dict, path: str, seen: set[tuple[int, int]]) -> str | None:
+        pair_id = (id(value), id(spec))
+        if pair_id in seen:
+            return f"circular reference detected at <{path or 'root'}>"
+        seen.add(pair_id)
         for key, expected in spec.items():
             current_path = f"{path}.{key}" if path else str(key)
             if key not in value:
@@ -529,7 +552,7 @@ class StructureMatcher(BaseMatcher):
             elif isinstance(expected, dict):
                 if not isinstance(actual, dict):
                     return f"at <{current_path}>: expected a dict, but was <{actual}>"
-                error = self._match_recursive(actual, expected, current_path)
+                error = self._match_recursive(actual, expected, current_path, seen)
                 if error:
                     return error
             elif actual != expected:
@@ -551,6 +574,7 @@ class StructureMatcher(BaseMatcher):
 # --- Custom matcher registry ---
 
 _custom_matchers: dict[str, Callable[..., BaseMatcher]] = {}
+_custom_matchers_lock = threading.Lock()
 
 
 def register_matcher(name: str) -> Callable[[Callable[..., BaseMatcher]], Callable[..., BaseMatcher]]:
@@ -587,7 +611,8 @@ def register_matcher(name: str) -> Callable[[Callable[..., BaseMatcher]], Callab
     def decorator(func: Callable[..., BaseMatcher]) -> Callable[..., BaseMatcher]:
         if not callable(func):
             raise TypeError("func must be callable")
-        _custom_matchers[name] = func
+        with _custom_matchers_lock:
+            _custom_matchers[name] = func
         return func
 
     return decorator
@@ -602,9 +627,16 @@ def unregister_matcher(name: str) -> None:
     Raises:
         KeyError: if the name is not registered
     """
-    if name not in _custom_matchers:
-        raise KeyError(f"no custom matcher registered with name {name!r}")
-    del _custom_matchers[name]
+    with _custom_matchers_lock:
+        if name not in _custom_matchers:
+            raise KeyError(f"no custom matcher registered with name {name!r}")
+        del _custom_matchers[name]
+
+
+def clear_custom_matchers() -> None:
+    """Remove all registered custom matchers."""
+    with _custom_matchers_lock:
+        _custom_matchers.clear()
 
 
 # --- Namespace ---
@@ -766,10 +798,11 @@ class _MatchNamespace:
         return StructureMatcher(spec)
 
     def __getattr__(self, name: str) -> Callable[..., BaseMatcher]:
-        try:
-            factory = _custom_matchers[name]
-        except KeyError:
-            raise AttributeError(f"match has no matcher {name!r}") from None
+        with _custom_matchers_lock:
+            try:
+                factory = _custom_matchers[name]
+            except KeyError:
+                raise AttributeError(f"match has no matcher {name!r}") from None
         return factory
 
 

{assertpy2-2.3.3 → assertpy2-2.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.3.3"
+version = "2.3.4"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"

{assertpy2-2.3.3 → assertpy2-2.3.4}/tests/test_matcher_registry.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 import pytest
 
-from assertpy2 import assert_that, match, register_matcher, unregister_matcher
-from assertpy2.matchers import _custom_matchers
+from assertpy2 import assert_that, clear_custom_matchers, match, register_matcher, unregister_matcher
 
 
 class TestRegisterMatcher:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_simple_matcher(self):
         @register_matcher("is_short")
@@ -113,7 +112,7 @@ class TestRegisterMatcher:
 
 class TestRegisterMatcherErrors:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_name_not_string(self):
         with pytest.raises(TypeError, match="name must be a string"):
@@ -138,7 +137,7 @@ class TestRegisterMatcherErrors:
 
 class TestUnregisterMatcher:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_unregister(self):
         @register_matcher("temp")
@@ -153,3 +152,19 @@ class TestUnregisterMatcher:
     def test_unregister_unknown_name(self):
         with pytest.raises(KeyError, match="no custom matcher registered"):
             unregister_matcher("nonexistent")
+
+    def test_clear_custom_matchers(self):
+        @register_matcher("a")
+        def a():
+            return match.is_positive()
+
+        @register_matcher("b")
+        def b():
+            return match.is_negative()
+
+        assert_that(1).satisfies(match.a())
+        clear_custom_matchers()
+        with pytest.raises(AttributeError):
+            match.a()
+        with pytest.raises(AttributeError):
+            match.b()

{assertpy2-2.3.3 → assertpy2-2.3.4}/tests/test_matchers.py

@@ -118,6 +118,43 @@ class TestCloseToMatcher:
         assert_that(match.close_to(10.0, 0.5).describe()).is_equal_to("a value within <0.5> of <10.0>")
 
 
+class TestOrderingMatchersIncompatibleTypes:
+    def test_greater_than_incompatible(self):
+        assert_that(match.greater_than(5).matches("hello")).is_false()
+
+    def test_greater_than_none(self):
+        assert_that(match.greater_than(5).matches(None)).is_false()
+
+    def test_greater_than_or_equal_to_incompatible(self):
+        assert_that(match.greater_than_or_equal_to(5).matches("hello")).is_false()
+
+    def test_less_than_incompatible(self):
+        assert_that(match.less_than(5).matches("hello")).is_false()
+
+    def test_less_than_none(self):
+        assert_that(match.less_than(5).matches(None)).is_false()
+
+    def test_less_than_or_equal_to_incompatible(self):
+        assert_that(match.less_than_or_equal_to(5).matches([1, 2])).is_false()
+
+    def test_between_incompatible(self):
+        assert_that(match.between(1, 10).matches("hello")).is_false()
+
+    def test_between_none(self):
+        assert_that(match.between(1, 10).matches(None)).is_false()
+
+    def test_close_to_incompatible(self):
+        assert_that(match.close_to(10.0, 0.5).matches("hello")).is_false()
+
+    def test_close_to_none(self):
+        assert_that(match.close_to(10.0, 0.5).matches(None)).is_false()
+
+    def test_composition_with_type_check(self):
+        m = match.is_instance_of(int) & match.greater_than(5)
+        assert_that(m.matches("hello")).is_false()
+        assert_that(m.matches(10)).is_true()
+
+
 class TestIsNoneMatcher:
     def test_matches(self):
         assert_that(match.is_none().matches(None)).is_true()

{assertpy2-2.3.3 → assertpy2-2.3.4}/tests/test_structural.py

@@ -218,6 +218,30 @@ class TestStructureMatcher:
         m = match.structure({"a": 1})
         assert_that(m.describe_mismatch({"a": 1})).is_equal_to("was <{'a': 1}>")
 
+    def test_circular_reference_detected(self):
+        d = {}
+        d["self"] = d
+        spec = {}
+        spec["self"] = spec
+        m = match.structure(spec)
+        assert_that(m.matches(d)).is_false()
+        assert_that(m.describe_mismatch(d)).contains("circular reference")
+
+    def test_deep_nesting(self):
+        value = {"a": 1}
+        spec = {"a": 1}
+        current_v = value
+        current_s = spec
+        for _i in range(20):
+            inner_v = {"a": 1}
+            inner_s = {"a": 1}
+            current_v["nested"] = inner_v
+            current_s["nested"] = inner_s
+            current_v = inner_v
+            current_s = inner_s
+        m = match.structure(spec)
+        assert_that(m.matches(value)).is_true()
+
 
 class TestMatchesStructureMethod:
     def test_basic(self):