assertpy2 2.7.0__tar.gz → 2.8.0__tar.gz

{assertpy2-2.7.0 → assertpy2-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.7.0
+Version: 2.8.0
 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
@@ -86,24 +86,49 @@ def test_user():
 
 ## Why fluent assertions?
 
-```py
-# bare assert - passes, but failure message is useless
-assert user["age"] >= 18
-# AssertionError
-
-# assertpy2 - same check, clear failure message
-assert_that(user["age"]).is_greater_than_or_equal_to(18)
-# AssertionError: Expected <16> to be greater than or equal to <18>, but was not.
+A fluent chain reads as one intent and replaces several bare asserts - and your IDE
+offers only the methods that fit the value's type:
 
-# bare assert - three separate statements
+```py
+# bare - three statements, no autocomplete help
 assert isinstance(items, list)
 assert len(items) == 3
 assert "admin" in items
 
-# assertpy2 - one fluent chain
+# assertpy2 - one chain, type-aware autocomplete
 assert_that(items).is_type_of(list).is_length(3).contains("admin")
 ```
 
+The real difference shows up when a test fails. Here a nested response has two wrong
+fields. Plain `assert` dumps both structures and leaves you to find them:
+
+```text
+assert response == expected
+E   AssertionError: assert {'id': 1, ...} == {'id': 1, ...}
+E     Omitting 1 identical items, use -vv to show
+E     Differing items:
+E     {'user': {'name': 'Alice', 'role': 'superadmin'}} != {'user': {'name': 'Alice', 'role': 'admin'}}
+E     {'status': 'active'} != {'status': 'disabled'}
+```
+
+assertpy2 reports the exact path to every difference:
+
+```text
+assert_that(response).is_equal_to(expected)
+--- Structured Diff ---
+diff (dict):
+  status:
+    - 'active'
+    + 'disabled'
+  user.role:
+    - 'superadmin'
+    + 'admin'
+```
+
+Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
+For responses with dynamic fields (IDs, timestamps), validate a subset with
+`matches_structure()` instead of exact equality.
+
 ## Type-aware autocomplete
 
 `assert_that()` uses `@overload` to return type-specific Protocols.
@@ -124,7 +149,7 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 **Fluent API**
 
 - [**Composable matchers**](https://solganis.github.io/assertpy2/matchers/): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
-- [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation, reporting the exact path to each mismatch on failure.
 - [**Universal negation**](https://solganis.github.io/assertpy2/fluent/#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
 - [**Collection pipeline**](https://solganis.github.io/assertpy2/fluent/#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
 - [**Fluent chaining**](https://solganis.github.io/assertpy2/fluent/#chaining): write assertions as readable one-liners that chain naturally.
@@ -143,7 +168,7 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 - [**Soft assertions**](https://solganis.github.io/assertpy2/testing/#soft-assertions): thread-safe, async-safe via `contextvars`. Group errors with `sa.group()`, or use `assert_all()`.
 - [**Async assertions**](https://solganis.github.io/assertpy2/testing/#async-assertions): `eventually()` with polling/retry for eventual consistency.
 - [**Structured errors**](https://solganis.github.io/assertpy2/errors/#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes.
-- [**Rich pytest diffs**](https://solganis.github.io/assertpy2/errors/#rich-pytest-diffs): recursive structural diffs for lists, sets, strings, dicts, dataclasses, namedtuples, Pydantic models. Circular reference protection.
+- [**Rich pytest diffs**](https://solganis.github.io/assertpy2/errors/#rich-pytest-diffs): recursive structural diffs for lists, sets, strings, dicts, dataclasses, namedtuples, Pydantic models, and matcher-based assertions (`matches_structure()`, `satisfies()`, `each()`). Circular reference protection.
 - [**Snapshot testing**](https://solganis.github.io/assertpy2/testing/#snapshot-testing): store and compare data structures in JSON format.
 
 **Type safety**

{assertpy2-2.7.0 → assertpy2-2.8.0}/README.md

@@ -48,24 +48,49 @@ def test_user():
 
 ## Why fluent assertions?
 
-```py
-# bare assert - passes, but failure message is useless
-assert user["age"] >= 18
-# AssertionError
-
-# assertpy2 - same check, clear failure message
-assert_that(user["age"]).is_greater_than_or_equal_to(18)
-# AssertionError: Expected <16> to be greater than or equal to <18>, but was not.
+A fluent chain reads as one intent and replaces several bare asserts - and your IDE
+offers only the methods that fit the value's type:
 
-# bare assert - three separate statements
+```py
+# bare - three statements, no autocomplete help
 assert isinstance(items, list)
 assert len(items) == 3
 assert "admin" in items
 
-# assertpy2 - one fluent chain
+# assertpy2 - one chain, type-aware autocomplete
 assert_that(items).is_type_of(list).is_length(3).contains("admin")
 ```
 
+The real difference shows up when a test fails. Here a nested response has two wrong
+fields. Plain `assert` dumps both structures and leaves you to find them:
+
+```text
+assert response == expected
+E   AssertionError: assert {'id': 1, ...} == {'id': 1, ...}
+E     Omitting 1 identical items, use -vv to show
+E     Differing items:
+E     {'user': {'name': 'Alice', 'role': 'superadmin'}} != {'user': {'name': 'Alice', 'role': 'admin'}}
+E     {'status': 'active'} != {'status': 'disabled'}
+```
+
+assertpy2 reports the exact path to every difference:
+
+```text
+assert_that(response).is_equal_to(expected)
+--- Structured Diff ---
+diff (dict):
+  status:
+    - 'active'
+    + 'disabled'
+  user.role:
+    - 'superadmin'
+    + 'admin'
+```
+
+Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
+For responses with dynamic fields (IDs, timestamps), validate a subset with
+`matches_structure()` instead of exact equality.
+
 ## Type-aware autocomplete
 
 `assert_that()` uses `@overload` to return type-specific Protocols.
@@ -86,7 +111,7 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 **Fluent API**
 
 - [**Composable matchers**](https://solganis.github.io/assertpy2/matchers/): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
-- [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation, reporting the exact path to each mismatch on failure.
 - [**Universal negation**](https://solganis.github.io/assertpy2/fluent/#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
 - [**Collection pipeline**](https://solganis.github.io/assertpy2/fluent/#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
 - [**Fluent chaining**](https://solganis.github.io/assertpy2/fluent/#chaining): write assertions as readable one-liners that chain naturally.
@@ -105,7 +130,7 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 - [**Soft assertions**](https://solganis.github.io/assertpy2/testing/#soft-assertions): thread-safe, async-safe via `contextvars`. Group errors with `sa.group()`, or use `assert_all()`.
 - [**Async assertions**](https://solganis.github.io/assertpy2/testing/#async-assertions): `eventually()` with polling/retry for eventual consistency.
 - [**Structured errors**](https://solganis.github.io/assertpy2/errors/#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes.
-- [**Rich pytest diffs**](https://solganis.github.io/assertpy2/errors/#rich-pytest-diffs): recursive structural diffs for lists, sets, strings, dicts, dataclasses, namedtuples, Pydantic models. Circular reference protection.
+- [**Rich pytest diffs**](https://solganis.github.io/assertpy2/errors/#rich-pytest-diffs): recursive structural diffs for lists, sets, strings, dicts, dataclasses, namedtuples, Pydantic models, and matcher-based assertions (`matches_structure()`, `satisfies()`, `each()`). Circular reference protection.
 - [**Snapshot testing**](https://solganis.github.io/assertpy2/testing/#snapshot-testing): store and compare data structures in JSON format.
 
 **Type safety**

{assertpy2-2.7.0 → assertpy2-2.8.0}/assertpy2/assertpy.py

@@ -47,7 +47,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.7.0"
+__version__ = "2.8.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch

{assertpy2-2.7.0 → assertpy2-2.8.0}/assertpy2/base.py

@@ -430,7 +430,13 @@ class BaseMixin(_MixinBase):
         """
         if isinstance(matcher, Matcher):
             if not matcher.matches(self.val):
-                return self.error(f"Expected {matcher.describe()}, but {matcher.describe_mismatch(self.val)}.")
+                description = matcher.describe()
+                return self.error(
+                    f"Expected {description}, but {matcher.describe_mismatch(self.val)}.",
+                    actual=self.val,
+                    expected=description,
+                    diff=DiffResult(kind="match", entries=[DiffEntry(path=".", actual=self.val, expected=description)]),
+                )
         elif callable(matcher):
             if not matcher(self.val):
                 return self.error(f"Expected <{self.val}> to satisfy <{matcher}>, but did not.")
@@ -466,11 +472,17 @@ class BaseMixin(_MixinBase):
         if not isinstance(self.val, collections.abc.Iterable):
             raise TypeError("val is not iterable")
         if isinstance(matcher, Matcher):
+            description = matcher.describe()
             for i, item in enumerate(self.val):
                 if not matcher.matches(item):
                     return self.error(
-                        f"Expected all items to satisfy {matcher.describe()}, but item at index {i} <{item}> did not:"
-                        f" {matcher.describe_mismatch(item)}."
+                        f"Expected all items to satisfy {description}, but item at index {i} <{item}> did not:"
+                        f" {matcher.describe_mismatch(item)}.",
+                        actual=item,
+                        expected=description,
+                        diff=DiffResult(
+                            kind="match", entries=[DiffEntry(path=f"[{i}]", actual=item, expected=description)]
+                        ),
                     )
         elif callable(matcher):
             for i, item in enumerate(self.val):
@@ -515,10 +527,17 @@ class BaseMixin(_MixinBase):
         if not isinstance(spec, dict):
             raise TypeError("given arg must be a dict")
         matcher = StructureMatcher(spec)
-        if not matcher.matches(self.val):
+        mismatches = matcher.collect_mismatches(self.val)
+        if mismatches:
+            entries = [
+                DiffEntry(path=path, actual=actual, expected=description) for path, actual, description in mismatches
+            ]
             return self.error(
                 f"Expected <{self.val}> to match structure {matcher.describe()}, but"
-                f" {matcher.describe_mismatch(self.val)}."
+                f" {matcher.describe_mismatch(self.val)}.",
+                actual=self.val,
+                expected=spec,
+                diff=DiffResult(kind="match", entries=entries),
             )
         return self
 

{assertpy2-2.7.0 → assertpy2-2.8.0}/assertpy2/matchers.py

@@ -512,6 +512,26 @@ class EachMatcher(BaseMatcher):
         return f"was <{value}>"
 
 
+class _MissingSentinel:
+    """Placeholder recorded for a spec key absent from the value during structural matching."""
+
+    def __repr__(self) -> str:
+        return "<missing>"
+
+
+_MISSING = _MissingSentinel()
+
+
+def _describe_spec_value(value: object) -> str:
+    """Describe a single structure-spec value (matcher, nested dict spec, or raw value)."""
+    if isinstance(value, Matcher):
+        return value.describe()
+    if isinstance(value, dict):
+        parts = [f"{key}: {_describe_spec_value(sub_value)}" for key, sub_value in value.items()]
+        return f"{{{', '.join(parts)}}}"
+    return f"<{value}>"
+
+
 class StructureMatcher(BaseMatcher):
     """Matches dicts against a structure spec where values are matchers, raw values, or nested dicts."""
 
@@ -559,16 +579,42 @@ class StructureMatcher(BaseMatcher):
                 return f"at <{current_path}>: expected <{expected}>, but was <{actual}>"
         return None
 
+    def collect_mismatches(self, value: dict) -> list[tuple[str, object, str]]:
+        """Collect every structural mismatch as ``(path, actual, expected_description)``.
+
+        Unlike :meth:`describe_mismatch`, this does not stop at the first failure and joins nested
+        paths, so callers can build a path-level :class:`~assertpy2.errors.DiffResult`.
+        """
+        return self._collect(value, self._spec, "", set())
+
+    def _collect(self, value: dict, spec: dict, path: str, seen: set[tuple[int, int]]) -> list[tuple[str, object, str]]:
+        pair_id = (id(value), id(spec))
+        if pair_id in seen:
+            return [(path or "root", "<circular ref>", "<circular ref>")]
+        seen = seen | {pair_id}
+        mismatches: list[tuple[str, object, str]] = []
+        for key, expected in spec.items():
+            current_path = f"{path}.{key}" if path else str(key)
+            if key not in value:
+                mismatches.append((current_path, _MISSING, _describe_spec_value(expected)))
+                continue
+            actual = value[key]
+            if isinstance(expected, StructureMatcher) and isinstance(actual, dict):
+                mismatches.extend(self._collect(actual, expected._spec, current_path, seen))
+            elif isinstance(expected, Matcher):
+                if not expected.matches(actual):
+                    mismatches.append((current_path, actual, expected.describe()))
+            elif isinstance(expected, dict):
+                if isinstance(actual, dict):
+                    mismatches.extend(self._collect(actual, expected, current_path, seen))
+                else:
+                    mismatches.append((current_path, actual, "a dict"))
+            elif actual != expected:
+                mismatches.append((current_path, actual, f"<{expected}>"))
+        return mismatches
+
     def _describe_spec(self, spec: dict) -> str:
-        parts = []
-        for key, value in spec.items():
-            if isinstance(value, Matcher):
-                parts.append(f"{key}: {value.describe()}")
-            elif isinstance(value, dict):
-                parts.append(f"{key}: {self._describe_spec(value)}")
-            else:
-                parts.append(f"{key}: <{value}>")
-        return f"{{{', '.join(parts)}}}"
+        return _describe_spec_value(spec)
 
 
 # --- Custom matcher registry ---

{assertpy2-2.7.0 → assertpy2-2.8.0}/assertpy2/pytest_plugin.py

@@ -121,6 +121,11 @@ def _format_diff(diff, *, color: bool = False, max_entries: int = 50) -> str:
                 lines.append(f"  {path}:")
                 lines.append(f"    {red}- {entry.actual!r}{reset}")
                 lines.append(f"    {green}+ {entry.expected!r}{reset}")
+    elif kind == "match":
+        for entry in visible:
+            lines.append(
+                f"  {cyan}{entry.path}{reset}: expected {entry.expected}, but was {red}{entry.actual!r}{reset}"
+            )
     elif kind in {"set", "contains"}:
         extra = [e for e in visible if e.path == "extra"]
         missing = [e for e in visible if e.path == "missing"]

{assertpy2-2.7.0 → assertpy2-2.8.0}/docs/comparison.md

@@ -82,6 +82,41 @@ The same check - `id` is a positive integer and `name` is a non-empty string - i
 
 Only assertpy2 offers both the typed structural form and the `==` form from a single import.
 
+## When it fails
+
+A nested response, after `role` comes back as `"superadmin"`. What each library prints on failure:
+
+=== "assertpy2"
+
+    ```text
+    assert_that(response).matches_structure({...})
+    --- Structured Diff ---
+    diff (match):
+      user.role: expected a value in <('admin', 'user')>, but was 'superadmin'
+    ```
+
+=== "pytest assert"
+
+    ```text
+    assert response == expected
+    E   Differing items:
+    E   {'user': {'name': 'Alice', 'role': 'superadmin', 'age': 30}} !=
+    E   {'user': {'name': 'Alice', 'role': 'admin', 'age': 30}}
+    ```
+
+=== "dirty-equals"
+
+    ```text
+    assert response == {"user": {"role": IsOneOf("admin", "user"), ...}}
+    E   Differing items:
+    E   {'user': {'name': 'Alice', 'role': 'superadmin', 'age': 30}} !=
+    E   {'user': {'name': IsStr, 'role': IsOneOf('admin', 'user'), 'age': IsInt}}
+    ```
+
+Only assertpy2 prints the path (`user.role`) and the exact predicate that failed. dirty-equals and the
+assertpy2 `==` form both hand rendering to pytest, which dumps the whole differing container for you to
+scan. The fluent form trades the zero-import convenience of `==` for a path-level diff.
+
 ## Style and typing
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
@@ -126,7 +161,7 @@ Only assertpy2 offers both the typed structural form and the `==` form from a si
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
 |---|:---:|:---:|:---:|:---:|:---:|
-| Latest release | built-in | 2.1.0 | 1.1 (2020) | 0.9.0 | **2.5.0** |
+| Latest release | built-in | 2.1.0 | 1.1 (2020) | 0.9.0 | **2.8.0** |
 | Runtime dependencies | none | none | none | none | **none on 3.11+** |
 | License | MIT | BSD | BSD | MIT | BSD-3 |
 

{assertpy2-2.7.0 → assertpy2-2.8.0}/docs/errors.md

@@ -25,6 +25,9 @@ except AssertionError as e:
     # DiffResult(kind='dict', entries=[DiffEntry(path='b', actual=2, expected=99)])
 ```
 
+Matcher-based assertions (`matches_structure()`, `satisfies()`, `each()`) attach a `DiffResult` with
+`kind='match'`, where each entry's `expected` holds the failed predicate's description.
+
 When the pytest plugin is active (auto-registered via the `pytest11` entry point, no configuration
 needed), this data is rendered as extra report sections. See [Rich pytest diffs](#rich-pytest-diffs)
 for supported types and configuration.
@@ -45,6 +48,7 @@ rendered by the plugin as colored diff sections.
 | Pydantic model | `model` | Field-by-field via `model_dump()`, recursive into nested models |
 | other | `scalar` | Single actual-vs-expected entry |
 | `contains` family | `contains` | Missing and extra items |
+| matcher mismatch | `match` | `matches_structure()` / `satisfies()` / `each()`: path + failed predicate |
 
 ```
 --- AssertionFailure ---
@@ -61,6 +65,20 @@ Nested structures are diffed recursively and report the exact path to the differ
 `[1].name`). Circular references are detected and shown as `<circular ref>` rather than recursing
 forever.
 
+Matcher-based assertions (`matches_structure()`, `satisfies()`, `each()`) emit a `match` diff that
+shows the path and the predicate that failed, for every field, not just the first:
+
+```text
+diff (match):
+  user.name: expected a non-empty string, but was ''
+  user.role: expected a value in <('admin', 'user')>, but was 'superadmin'
+  user.age: expected a value between <18> and <120>, but was 15
+```
+
+The rich `match`/`dict` diff comes from the fluent form. The `==` drop-in for matchers (for example
+`assert response == {"id": match.is_positive()}`) hands rendering to pytest instead, which prints its
+own dict comparison without the path.
+
 ### Configuration
 
 ```toml

{assertpy2-2.7.0 → assertpy2-2.8.0}/docs/getting-started.md

@@ -35,6 +35,21 @@ assert_that(5).is_greater_than(10)
 # AssertionError: Expected <5> to be greater than <10>, but was not.
 ```
 
+For dicts, dataclasses, and other structures, the pytest plugin renders a path-level diff that points
+straight at the differing field instead of dumping the whole value:
+
+```text
+assert_that(actual).is_equal_to(expected)
+--- Structured Diff ---
+diff (dict):
+  user.role:
+    - 'superadmin'
+    + 'admin'
+```
+
+The same path-level diff backs `matches_structure()`, `satisfies()`, and `each()`. See
+[Errors & Reporting](errors.md) for the full diff format and configuration.
+
 ## Collect multiple failures
 
 Use soft assertions to report every failure at once instead of stopping at the first:

{assertpy2-2.7.0 → assertpy2-2.8.0}/docs/index.md

@@ -12,7 +12,7 @@ rich structural diffs on failure.
   accurate autocomplete and type checkers catch misuse. This is the core advantage over `assertpy` and
   most alternatives.
 - **Composable matchers.** `match.greater_than(5)`, `match.is_uuid()`, combined with `&`, `|`, `~`.
-- **Structural matching.** Declarative validation of dicts and API responses.
+- **Structural matching.** Declarative validation of dicts and API responses, with the exact path to each mismatch on failure.
 - **Soft and async assertions.** Collect multiple failures; poll for eventual consistency with `eventually()`.
 - **Structured failures.** `AssertionFailure` exposes `.actual`, `.expected`, and `.diff`; the pytest plugin
   renders recursive diffs for lists, dicts, dataclasses, namedtuples, and Pydantic models.
@@ -37,5 +37,14 @@ assert_that({"id": 1, "name": "Alice"}).matches_structure(
 )
 ```
 
+When a check fails, the pytest plugin points at the exact field instead of dumping both structures:
+
+```text
+assert_that(response).matches_structure({...})
+--- Structured Diff ---
+diff (match):
+  user.role: expected a value in <('admin', 'user')>, but was 'superadmin'
+```
+
 See [Getting Started](getting-started.md) to dive in, or browse [Type Assertions](assertions.md),
 [Matchers](matchers.md), and the rest of the navigation for the full set of assertions and integrations.

{assertpy2-2.7.0 → assertpy2-2.8.0}/docs/matchers.md

@@ -80,6 +80,10 @@ assert 42 == (match.is_positive() & match.less_than(100))
     AssertionError: assert -5 == a positive value
     ```
 
+    The `==` form hands rendering to pytest, so you get pytest's own message without a path-level
+    diff. For the rich `match` diff, use the fluent form (`satisfies()`, `matches_structure()`) -
+    see [Errors & Reporting](errors.md#rich-pytest-diffs).
+
 !!! tip
     This makes matchers a drop-in addition to an existing suite: add one import, use `match.*` in any
     `==` comparison, no rewrite required.
@@ -171,6 +175,21 @@ assert_that({"id": "abc-123", "tags": ["python", "testing"]}).matches_structure(
     Keys present in the value but absent from the spec are ignored, so a structure spec validates a
     subset of fields rather than requiring an exact match.
 
+### What you see on failure
+
+When fields do not match, the pytest plugin prints the exact path and the predicate that failed - every
+mismatch, not just the first:
+
+```text
+diff (match):
+  user.name: expected a non-empty string, but was ''
+  user.role: expected a value in <('admin', 'user')>, but was 'superadmin'
+  user.age: expected a value between <18> and <120>, but was 15
+```
+
+The same `match` diff is produced by [`satisfies()`](#satisfies) and [`each()`](#each) whenever a
+matcher fails inside an assertion.
+
 ## Custom matchers
 
 `register_matcher()` adds your own matcher to the `match` namespace. Custom matchers compose with

{assertpy2-2.7.0 → assertpy2-2.8.0}/pyproject.toml

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

{assertpy2-2.7.0 → assertpy2-2.8.0}/tests/test_matchers.py

@@ -1,6 +1,6 @@
 import pytest
 
-from assertpy2 import Matcher, assert_that, match
+from assertpy2 import AssertionFailure, Matcher, assert_that, match
 from assertpy2.matchers import BaseMatcher
 
 
@@ -459,6 +459,16 @@ class TestSatisfies:
     def test_chaining(self):
         assert_that(7).satisfies(match.greater_than(5)).is_less_than(10)
 
+    def test_failure_attaches_match_diff(self):
+        try:
+            assert_that(5).satisfies(match.greater_than(10))
+        except AssertionFailure as exc:
+            assert_that(exc.diff.kind).is_equal_to("match")
+            assert_that(exc.diff.entries[0].path).is_equal_to(".")
+            assert_that(exc.diff.entries[0].actual).is_equal_to(5)
+        else:
+            raise AssertionError("expected AssertionFailure") from None
+
 
 class TestEach:
     def test_with_matcher(self):
@@ -500,6 +510,16 @@ class TestEach:
         users = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
         assert_that(users).extracting("age").each(match.between(18, 120))
 
+    def test_failure_attaches_match_diff(self):
+        try:
+            assert_that([1, 2, -3]).each(match.is_positive())
+        except AssertionFailure as exc:
+            assert_that(exc.diff.kind).is_equal_to("match")
+            assert_that(exc.diff.entries[0].path).is_equal_to("[2]")
+            assert_that(exc.diff.entries[0].actual).is_equal_to(-3)
+        else:
+            raise AssertionError("expected AssertionFailure") from None
+
 
 class TestContainsWithMatcher:
     def test_single_matcher(self):

{assertpy2-2.7.0 → assertpy2-2.8.0}/tests/test_recursive_compare_attrs.py

@@ -3,6 +3,8 @@ import pytest
 pytest.importorskip("attrs", reason="attrs not installed")
 
 import attrs
+from hypothesis import given, settings
+from hypothesis import strategies as st
 
 from assertpy2 import assert_that
 from assertpy2.helpers import HelpersMixin
@@ -51,3 +53,29 @@ class TestAttrsToComparableDict:
         product = Product(sku="A", name="W", price=10.0)
         result = HelpersMixin._to_comparable_dict(product)
         assert_that(result).is_equal_to({"sku": "A", "name": "W", "price": 10.0})
+
+
+_products = st.builds(Product, sku=st.text(max_size=5), name=st.text(max_size=5), price=st.floats(allow_nan=False))
+_orders = st.builds(Order, id=st.integers(), product=_products, quantity=st.integers())
+
+
+class TestAttrsProperties:
+    @settings(deadline=None)
+    @given(left=_orders, right=_orders)
+    def test_is_equal_to_consistent_with_eq(self, left, right):
+        if left == right:
+            assert_that(left).is_equal_to(right)
+        else:
+            with pytest.raises(AssertionError):
+                assert_that(left).is_equal_to(right)
+
+    @settings(deadline=None)
+    @given(value=_orders)
+    def test_is_equal_to_reflexive(self, value):
+        assert_that(value).is_equal_to(attrs.evolve(value))
+
+    @settings(deadline=None)
+    @given(value=_products, new_sku=st.text(max_size=5))
+    def test_ignore_removes_field_difference(self, value, new_sku):
+        other = attrs.evolve(value, sku=new_sku)
+        assert_that(value).is_equal_to(other, ignore="sku")

{assertpy2-2.7.0 → assertpy2-2.8.0}/tests/test_recursive_compare_pydantic.py

@@ -2,6 +2,8 @@ import pytest
 
 pytest.importorskip("pydantic", reason="pydantic not installed")
 
+from hypothesis import given, settings
+from hypothesis import strategies as st
 from pydantic import BaseModel
 
 from assertpy2 import assert_that
@@ -53,3 +55,29 @@ class TestPydanticListOfObjects:
         actual = [UserDto(id=1, name="Alice"), UserDto(id=2, name="Bob")]
         expected = [UserDto(id=99, name="Alice"), UserDto(id=99, name="Bob")]
         assert_that(actual).is_equal_to(expected, ignore="id")
+
+
+_addresses = st.builds(AddressDto, city=st.text(max_size=5), zip_code=st.text(max_size=5))
+_users = st.builds(UserDtoWithAddress, id=st.integers(), name=st.text(max_size=5), address=_addresses)
+
+
+class TestPydanticProperties:
+    @settings(deadline=None)
+    @given(left=_users, right=_users)
+    def test_is_equal_to_consistent_with_eq(self, left, right):
+        if left == right:
+            assert_that(left).is_equal_to(right)
+        else:
+            with pytest.raises(AssertionError):
+                assert_that(left).is_equal_to(right)
+
+    @settings(deadline=None)
+    @given(value=_users)
+    def test_is_equal_to_reflexive(self, value):
+        assert_that(value).is_equal_to(value.model_copy(deep=True))
+
+    @settings(deadline=None)
+    @given(value=st.builds(UserDto, id=st.integers(), name=st.text(max_size=5)), new_id=st.integers())
+    def test_ignore_removes_field_difference(self, value, new_id):
+        other = value.model_copy(update={"id": new_id})
+        assert_that(value).is_equal_to(other, ignore="id")

{assertpy2-2.7.0 → assertpy2-2.8.0}/tests/test_rich_diff.py

@@ -406,6 +406,36 @@ class TestPytestPluginDiffRendering:
         )
         assert_that(result.stdout).does_not_contain("Structured Diff")
 
+    def test_matches_structure_diff_in_report(self, tmp_path):
+        test_file = tmp_path / "test_sample.py"
+        test_file.write_text(
+            "from assertpy2 import assert_that, match\n"
+            "def test_structure():\n"
+            "    assert_that({'role': 'guest', 'address': {'city': 'LA'}}).matches_structure({\n"
+            "        'role': match.is_in('admin', 'user'),\n"
+            "        'address': match.structure({'city': match.equal_to('NYC')}),\n"
+            "    })\n",
+        )
+        result = subprocess.run(
+            ["uv", "run", "pytest", str(test_file), "-v", "--no-header", "--tb=short"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        assert_that(result.stdout).contains("diff (match)")
+        assert_that(result.stdout).contains("address.city")
+
+
+class TestFormatDiffMatchKind:
+    def test_renders_predicate_and_actual(self):
+        diff = DiffResult(
+            kind="match",
+            entries=[DiffEntry(path="role", actual="guest", expected="a value in <('admin', 'user')>")],
+        )
+        output = _format_diff(diff)
+        assert_that(output).contains("diff (match):")
+        assert_that(output).contains("role: expected a value in <('admin', 'user')>, but was 'guest'")
+
 
 class TestFormatDiffTruncation:
     def test_truncation_when_over_max(self):

{assertpy2-2.7.0 → assertpy2-2.8.0}/tests/test_structural.py

@@ -1,6 +1,6 @@
 import pytest
 
-from assertpy2 import assert_that, match
+from assertpy2 import AssertionFailure, assert_that, match
 from assertpy2.matchers import (
     EachMatcher,
     IgnoreMatcher,
@@ -243,6 +243,60 @@ class TestStructureMatcher:
         assert_that(matcher.matches(value)).is_true()
 
 
+class TestCollectMismatches:
+    def test_collects_all_failing_fields(self):
+        matcher = match.structure({"a": match.is_positive(), "b": match.is_positive(), "c": match.is_positive()})
+        result = matcher.collect_mismatches({"a": -1, "b": 5, "c": -3})
+        assert_that([entry[0] for entry in result]).is_equal_to(["a", "c"])
+
+    def test_empty_when_all_match(self):
+        matcher = match.structure({"a": match.is_positive(), "status": "active"})
+        assert_that(matcher.collect_mismatches({"a": 5, "status": "active"})).is_empty()
+
+    def test_nested_structure_matcher_joins_path(self):
+        matcher = match.structure({"address": match.structure({"city": match.equal_to("NYC")})})
+        result = matcher.collect_mismatches({"address": {"city": "LA"}})
+        assert_that(result[0][0]).is_equal_to("address.city")
+
+    def test_missing_key_recorded(self):
+        matcher = match.structure({"name": match.is_non_empty_string()})
+        path, actual, description = matcher.collect_mismatches({})[0]
+        assert_that(path).is_equal_to("name")
+        assert_that(repr(actual)).is_equal_to("<missing>")
+        assert_that(description).is_equal_to("a non-empty string")
+
+    def test_nested_structure_matcher_against_non_dict(self):
+        matcher = match.structure({"user": match.structure({"name": match.is_non_empty_string()})})
+        result = matcher.collect_mismatches({"user": "not a dict"})
+        assert_that(result[0][0]).is_equal_to("user")
+
+    def test_plain_nested_dict_against_non_dict(self):
+        matcher = match.structure({"user": {"name": match.is_non_empty_string()}})
+        path, _actual, description = matcher.collect_mismatches({"user": "not a dict"})[0]
+        assert_that(path).is_equal_to("user")
+        assert_that(description).is_equal_to("a dict")
+
+    def test_plain_nested_dict_recurses(self):
+        matcher = match.structure({"user": {"role": "admin"}})
+        result = matcher.collect_mismatches({"user": {"role": "guest"}})
+        assert_that(result[0][0]).is_equal_to("user.role")
+
+    def test_raw_value_mismatch(self):
+        matcher = match.structure({"status": "active"})
+        path, actual, description = matcher.collect_mismatches({"status": "inactive"})[0]
+        assert_that(path).is_equal_to("status")
+        assert_that(actual).is_equal_to("inactive")
+        assert_that(description).is_equal_to("<active>")
+
+    def test_circular_reference(self):
+        circular = {}
+        circular["self"] = circular
+        spec = {}
+        spec["self"] = spec
+        result = match.structure(spec).collect_mismatches(circular)
+        assert_that(result[0][1]).is_equal_to("<circular ref>")
+
+
 class TestMatchesStructureMethod:
     def test_basic(self):
         user = {"name": "Alice", "age": 30}
@@ -293,3 +347,17 @@ class TestMatchesStructureMethod:
     def test_error_message_contains_structure_description(self):
         with pytest.raises(AssertionError, match="to match structure"):
             assert_that({"x": 1}).matches_structure({"x": match.is_non_empty_string()})
+
+    def test_failure_attaches_structured_diff(self):
+        value = {"role": "guest", "address": {"city": "LA"}}
+        try:
+            assert_that(value).matches_structure(
+                {"role": match.is_in("admin", "user"), "address": match.structure({"city": match.equal_to("NYC")})}
+            )
+        except AssertionFailure as exc:
+            assert_that(exc.diff.kind).is_equal_to("match")
+            assert_that([entry.path for entry in exc.diff.entries]).contains("role", "address.city")
+            assert_that(exc.actual).is_equal_to(value)
+            assert_that(exc.expected).is_not_none()
+        else:
+            raise AssertionError("expected AssertionFailure") from None

{assertpy2-2.7.0 → assertpy2-2.8.0}/uv.lock

@@ -34,7 +34,7 @@ wheels = [
 
 [[package]]
 name = "assertpy2"
-version = "2.7.0"
+version = "2.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },