assertpy2 2.9.1__tar.gz → 2.10.0__tar.gz

{assertpy2-2.9.1 → assertpy2-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.9.1
+Version: 2.10.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
@@ -121,12 +121,16 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 assert_that(response).is_equal_to(expected)
 ```
 
-<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: user.role shown with its path, removal in red and addition in green">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with
 [`matches_structure()`](https://solganis.github.io/assertpy2/matchers/#structural-matching) instead of exact equality.
 
+The same path-level treatment for dicts, lists, sets, and matcher predicates:
+
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-gallery.png" width="640" alt="Structured diffs in the terminal: dict path, list element, set extra/missing, and structural-matcher predicate diffs, side by side">
+
 ## [Type-aware autocomplete](https://solganis.github.io/assertpy2/type-safety/)
 
 `assert_that()` uses `@overload` to return type-specific Protocols.

{assertpy2-2.9.1 → assertpy2-2.10.0}/README.md

@@ -83,12 +83,16 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 assert_that(response).is_equal_to(expected)
 ```
 
-<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: status and user.role shown with their paths, removals in red and additions in green">
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: user.role shown with its path, removal in red and addition in green">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with
 [`matches_structure()`](https://solganis.github.io/assertpy2/matchers/#structural-matching) instead of exact equality.
 
+The same path-level treatment for dicts, lists, sets, and matcher predicates:
+
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-gallery.png" width="640" alt="Structured diffs in the terminal: dict path, list element, set extra/missing, and structural-matcher predicate diffs, side by side">
+
 ## [Type-aware autocomplete](https://solganis.github.io/assertpy2/type-safety/)
 
 `assert_that()` uses `@overload` to return type-specific Protocols.

{assertpy2-2.9.1 → assertpy2-2.10.0}/assertpy2/assertpy.py

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

{assertpy2-2.9.1 → assertpy2-2.10.0}/assertpy2/base.py

@@ -187,6 +187,58 @@ class BaseMixin(_MixinBase):
                     expected=expected_item,
                 )
 
+    @staticmethod
+    def _sequence_diff_entries(actual, expected, prefix, seen) -> list[DiffEntry]:
+        """Diff two sequences element-by-element, recursing into nested containers.
+
+        ``seen`` must already include the ids of ``actual``/``expected`` so a self-referential element
+        is caught.  Shared by the top-level (:meth:`_build_equality_diff`) and nested
+        (:meth:`_sub_diff_entries`) paths so both decompose sequences identically.
+        """
+        entries: list[DiffEntry] = []
+        max_len = max(len(actual), len(expected))
+        for i in range(max_len):
+            path = f"{prefix}[{i}]" if prefix else f"[{i}]"
+            if i >= len(actual):
+                entries.append(DiffEntry(path=path, actual=None, expected=expected[i]))
+            elif i >= len(expected):
+                entries.append(DiffEntry(path=path, actual=actual[i], expected=None))
+            elif actual[i] != expected[i]:
+                sub_entries = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=seen)
+                if sub_entries:
+                    entries.extend(sub_entries)
+                else:
+                    entries.append(DiffEntry(path=path, actual=actual[i], expected=expected[i]))
+        return entries
+
+    @staticmethod
+    def _dataclass_diff_entries(actual, expected, prefix, seen) -> list[DiffEntry]:
+        """Diff two dataclasses over the sorted union of field names, both directions, recursing.
+
+        Reports fields present on only one side, and recurses into nested containers.  ``seen`` must
+        already include the ids of ``actual``/``expected``.  Shared by the top-level and nested paths
+        so both report dataclass fields identically.
+        """
+        entries: list[DiffEntry] = []
+        actual_names = {field.name for field in dataclasses.fields(actual)}
+        expected_names = {field.name for field in dataclasses.fields(expected)}
+        for field in sorted(actual_names | expected_names):
+            path = f"{prefix}.{field}"
+            if field not in expected_names:
+                entries.append(DiffEntry(path=path, actual=getattr(actual, field), expected=None))
+            elif field not in actual_names:
+                entries.append(DiffEntry(path=path, actual=None, expected=getattr(expected, field)))
+            else:
+                actual_value = getattr(actual, field)
+                expected_value = getattr(expected, field)
+                if actual_value != expected_value:
+                    sub_entries = BaseMixin._sub_diff_entries(actual_value, expected_value, path, _seen=seen)
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
+                    else:
+                        entries.append(DiffEntry(path=path, actual=actual_value, expected=expected_value))
+        return entries
+
     @staticmethod
     def _build_equality_diff(
         actual: object, expected: object, *, _prefix: str = "", _seen: set[int] | None = None
@@ -229,21 +281,10 @@ class BaseMixin(_MixinBase):
             and dataclasses.is_dataclass(expected)
             and not isinstance(expected, type)
         ):
-            entries = []
-            actual_names = {field.name for field in dataclasses.fields(actual)}
-            expected_names = {field.name for field in dataclasses.fields(expected)}
-            for field in sorted(actual_names | expected_names):
-                path = f"{_prefix}.{field}"
-                if field not in expected_names:
-                    entries.append(DiffEntry(path=path, actual=getattr(actual, field), expected=None))
-                elif field not in actual_names:
-                    entries.append(DiffEntry(path=path, actual=None, expected=getattr(expected, field)))
-                else:
-                    actual_value = getattr(actual, field)
-                    expected_value = getattr(expected, field)
-                    if actual_value != expected_value:
-                        entries.extend(_field_entries(actual_value, expected_value, path))
-            return DiffResult(kind="dataclass", entries=entries)
+            return DiffResult(
+                kind="dataclass",
+                entries=BaseMixin._dataclass_diff_entries(actual, expected, _prefix, _seen),
+            )
         if is_model_dump_object(actual) and is_model_dump_object(expected):
             actual_dict = actual.model_dump()
             expected_dict = expected.model_dump()
@@ -262,21 +303,10 @@ class BaseMixin(_MixinBase):
                         entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return DiffResult(kind="model", entries=entries)
         if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
-            entries = []
-            max_len = max(len(actual), len(expected))
-            for i in range(max_len):
-                path = f"{_prefix}[{i}]" if _prefix else f"[{i}]"
-                if i >= len(actual):
-                    entries.append(DiffEntry(path=path, actual=None, expected=expected[i]))
-                elif i >= len(expected):
-                    entries.append(DiffEntry(path=path, actual=actual[i], expected=None))
-                elif actual[i] != expected[i]:
-                    sub_entries = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=_seen)
-                    if sub_entries:
-                        entries.extend(sub_entries)
-                    else:
-                        entries.append(DiffEntry(path=path, actual=actual[i], expected=expected[i]))
-            return DiffResult(kind="sequence", entries=entries)
+            return DiffResult(
+                kind="sequence",
+                entries=BaseMixin._sequence_diff_entries(actual, expected, _prefix, _seen),
+            )
         if isinstance(actual, (set, frozenset)) and isinstance(expected, (set, frozenset)):
             entries = []
             for item in sorted(actual - expected, key=repr):
@@ -333,23 +363,7 @@ class BaseMixin(_MixinBase):
             and not isinstance(expected, type)
         ):
             child_seen = _seen | {id(actual), id(expected)}
-            entries = []
-            for field in dataclasses.fields(actual):
-                actual_value = getattr(actual, field.name)
-                expected_value = getattr(expected, field.name, _SENTINEL)
-                if expected_value is _SENTINEL:
-                    entries.append(DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=None))
-                elif actual_value != expected_value:
-                    sub_entries = BaseMixin._sub_diff_entries(
-                        actual_value, expected_value, f"{prefix}.{field.name}", _seen=child_seen
-                    )
-                    if sub_entries is not None:
-                        entries.extend(sub_entries)
-                    else:
-                        entries.append(
-                            DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=expected_value)
-                        )
-            return entries or None
+            return BaseMixin._dataclass_diff_entries(actual, expected, prefix, child_seen) or None
         if is_namedtuple(actual) and is_namedtuple(expected):
             child_seen = _seen | {id(actual), id(expected)}
             entries = []
@@ -394,6 +408,9 @@ class BaseMixin(_MixinBase):
                     else:
                         entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return entries or None
+        if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
+            child_seen = _seen | {id(actual), id(expected)}
+            return BaseMixin._sequence_diff_entries(actual, expected, prefix, child_seen) or None
         return None
 
     def satisfies(self, matcher) -> Self:
@@ -488,11 +505,12 @@ class BaseMixin(_MixinBase):
         return self
 
     def matches_structure(self, spec: dict[Any, Any]) -> Self:
-        """Asserts that val is a dict matching the given structure specification.
+        """Asserts that val matches the given structure specification.
 
-        Each key in ``spec`` maps to either a :class:`~assertpy2.matchers.Matcher`, a raw value
-        (checked via ``==``), or a nested ``dict`` for recursive matching.  Extra keys in val
-        that are absent from the spec are allowed.
+        ``val`` may be a dict or a pydantic-style model (anything exposing ``model_dump()``), which is
+        normalized to its dict before matching.  Each key in ``spec`` maps to either a
+        :class:`~assertpy2.matchers.Matcher`, a raw value (checked via ``==``), or a nested ``dict``
+        for recursive matching.  Extra keys in val that are absent from the spec are allowed.
 
         Args:
             spec: a dict where values can be Matcher instances, raw values, or nested dicts
@@ -515,7 +533,7 @@ class BaseMixin(_MixinBase):
         Raises:
             AssertionError: if val does **not** match the structure spec
         """
-        if not isinstance(self.val, dict):
+        if not isinstance(self.val, dict) and not is_model_dump_object(self.val):
             raise TypeError("val must be a dict")
         if not isinstance(spec, dict):
             raise TypeError("given arg must be a dict")

{assertpy2-2.9.1 → assertpy2-2.10.0}/assertpy2/extracting.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import collections.abc
 from typing import TYPE_CHECKING
 
-from ._introspection import is_namedtuple
+from ._introspection import is_model_dump_object, is_namedtuple
 from ._mixin_base import _MixinBase
 
 if TYPE_CHECKING:
@@ -155,7 +155,7 @@ class ExtractingMixin(_MixinBase):
                     return getattr(item, name)
                 else:  # val has no attribute <foo>
                     raise ValueError(f"item attributes {item._fields} did not contain attribute <{name}>")
-            elif isinstance(item, collections.abc.Iterable):
+            elif isinstance(item, collections.abc.Iterable) and not is_model_dump_object(item):
                 self._check_iterable(item, name="item")
                 return item[name]
             elif hasattr(item, name):

{assertpy2-2.9.1 → assertpy2-2.10.0}/assertpy2/matchers.py

@@ -5,6 +5,8 @@ import threading
 import uuid as _uuid_mod
 from typing import TYPE_CHECKING, Any, Final, NamedTuple, Protocol, runtime_checkable
 
+from ._introspection import is_model_dump_object
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -563,12 +565,20 @@ class _SpecMismatch(NamedTuple):
 
 
 class StructureMatcher(BaseMatcher):
-    """Matches dicts against a structure spec where values are matchers, raw values, or nested dicts."""
+    """Matches dicts (or pydantic-style models via ``model_dump()``) against a structure spec whose
+    values are matchers, raw values, or nested dicts."""
 
     def __init__(self, spec: dict[Any, Any]):
         self._spec = spec
 
+    @staticmethod
+    def _as_mapping(value: Any) -> Any:
+        """Normalize a pydantic-style model (anything exposing ``model_dump()``) to its dict, so a
+        model can be matched structurally just like a plain dict; pass other values through."""
+        return value.model_dump() if is_model_dump_object(value) else value
+
     def matches(self, value: Any) -> bool:
+        value = self._as_mapping(value)
         if not isinstance(value, dict):
             return False
         return not self._walk(value, self._spec, "", set())
@@ -577,6 +587,7 @@ class StructureMatcher(BaseMatcher):
         return f"a dict matching structure {_describe_spec_value(self._spec)}"
 
     def describe_mismatch(self, value: Any) -> str:
+        value = self._as_mapping(value)
         if not isinstance(value, dict):
             return f"was not a dict: <{value}>"
         mismatches = self._walk(value, self._spec, "", set())
@@ -591,12 +602,13 @@ class StructureMatcher(BaseMatcher):
             return f"at <{first.path}>: expected {first.expected_desc}, but {first.detail}"
         return f"at <{first.path}>: expected {first.expected_desc}, but was <{first.actual}>"
 
-    def collect_mismatches(self, value: dict[Any, Any]) -> list[tuple[str, object, str]]:
+    def collect_mismatches(self, value: Any) -> 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`.
         """
+        value = self._as_mapping(value)
         return [(m.path, m.actual, m.expected_desc) for m in self._walk(value, self._spec, "", set())]
 
     def _walk(

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/assertions.md

@@ -335,7 +335,7 @@ assert_that(people).extracting("name").contains("Fred Smith", "Bob Barr")
 assert_that(people).extracting("say_hello").contains("Hello, Fred!", "Hello, Bob!")  # method
 ```
 
-It also works on collections of dicts (extracting by key) and across subclasses in a mixed collection.
+It also works on collections of dicts (extracting by key), Pydantic models, and across subclasses in a mixed collection.
 
 #### Filtering
 

assertpy2-2.10.0/docs/assets/diff-equal.svg

@@ -0,0 +1,51 @@
+<svg width="250" height="120" viewBox="0 0 250 119.6" xmlns="http://www.w3.org/2000/svg">
+    <style>
+
+    .terminal-346716669-matrix {
+        font-family: Fira Code, monospace;
+        font-size: 20px;
+        line-height: 24.4px;
+        font-variant-east-asian: full-width;
+    }
+
+    .terminal-346716669-title {
+        font-size: 18px;
+        font-weight: bold;
+        font-family: arial;
+    }
+
+    .terminal-346716669-r1 { fill: #68a0b3 }
+.terminal-346716669-r2 { fill: #c5c8c6 }
+.terminal-346716669-r3 { fill: #cc555a }
+.terminal-346716669-r4 { fill: #98a84b }
+    </style>
+
+    <defs>
+    <clipPath id="terminal-346716669-clip-terminal">
+      <rect x="0" y="0" width="230.79999999999998" height="96.6" />
+    </clipPath>
+    <clipPath id="terminal-346716669-line-0">
+    <rect x="0" y="1.5" width="231.8" height="24.65"/>
+            </clipPath>
+<clipPath id="terminal-346716669-line-1">
+    <rect x="0" y="25.9" width="231.8" height="24.65"/>
+            </clipPath>
+<clipPath id="terminal-346716669-line-2">
+    <rect x="0" y="50.3" width="231.8" height="24.65"/>
+            </clipPath>
+    </defs>
+
+    <rect fill="#292929" stroke="rgba(255,255,255,0.35)" stroke-width="1" x="1" y="1" width="248" height="117.6" rx="8"/>
+            
+        
+    <g transform="translate(9, 13)" clip-path="url(#terminal-346716669-clip-terminal)">
+    
+    <g class="terminal-346716669-matrix">
+    <text class="terminal-346716669-r1" x="0" y="20" textLength="146.4" clip-path="url(#terminal-346716669-line-0)">diff&#160;(dict):</text><text class="terminal-346716669-r2" x="231.8" y="20" textLength="12.2" clip-path="url(#terminal-346716669-line-0)">
+</text><text class="terminal-346716669-r2" x="0" y="44.4" textLength="146.4" clip-path="url(#terminal-346716669-line-1)">&#160;&#160;user.role:</text><text class="terminal-346716669-r2" x="231.8" y="44.4" textLength="12.2" clip-path="url(#terminal-346716669-line-1)">
+</text><text class="terminal-346716669-r3" x="48.8" y="68.8" textLength="170.8" clip-path="url(#terminal-346716669-line-2)">-&#160;&#x27;superadmin&#x27;</text><text class="terminal-346716669-r2" x="231.8" y="68.8" textLength="12.2" clip-path="url(#terminal-346716669-line-2)">
+</text><text class="terminal-346716669-r4" x="48.8" y="93.2" textLength="109.8" clip-path="url(#terminal-346716669-line-3)">+&#160;&#x27;admin&#x27;</text><text class="terminal-346716669-r2" x="231.8" y="93.2" textLength="12.2" clip-path="url(#terminal-346716669-line-3)">
+</text>
+    </g>
+    </g>
+</svg>

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/assets/diff-match.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="933" height="120" viewBox="0 0 933 119.6" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="933" height="120" viewBox="0 0 933 119.6" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-4172749894-matrix {

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/assets/diff-sequence.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="226" height="120" viewBox="0 0 226 119.6" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="226" height="120" viewBox="0 0 226 119.6" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-4133779467-matrix {

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/assets/diff-set.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="275" height="95" viewBox="0 0 275 95.19999999999999" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="275" height="95" viewBox="0 0 275 95.19999999999999" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-3363794957-matrix {

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/comparison.md

@@ -117,6 +117,19 @@ Only assertpy2 prints the path (`user.role`) and the exact predicate that failed
 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.
 
+### With a Pydantic model
+
+When the value is a Pydantic model, `matches_structure()` accepts it directly, with no `.model_dump()`
+step, and prints a path-level diff just like the one above:
+
+```python
+assert_that(user).matches_structure({"role": match.is_in("admin", "user")})
+```
+
+dirty-equals cannot compare a model against a spec dict, because Pydantic's `__eq__` only matches another
+model. You dump it first (`assert user.model_dump() == {"role": IsOneOf("admin", "user")}`), and pytest
+again dumps the whole differing container. assertpy2 keeps a path-level diff on a model.
+
 ## Style and typing
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
@@ -161,7 +174,7 @@ scan. The fluent form trades the zero-import convenience of `==` for a path-leve
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
 |---|:---:|:---:|:---:|:---:|:---:|
-| Latest release | built-in | 2.1.0 | 1.1 (2020) | 0.9.0 | **2.9.1** |
+| Maintained | built-in | Yes | No (since 2020) | Yes | **Yes** |
 | Property-based tests | n/a | No | No | No | **Yes** |
 | Runtime dependencies | **none** | **none** | **none** | **none** | **none on 3.11+** |
 | License | MIT | BSD | BSD | MIT | BSD-3 |

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/errors.md

@@ -39,7 +39,7 @@ rendered by the plugin as colored diff sections.
 
 | Type | Diff kind | How it works |
 |---|---|---|
-| `list`, `tuple` | `sequence` | Element-by-element, recursive into nested dicts/dataclasses/models |
+| `list`, `tuple` | `sequence` | Element-by-element, recursive into nested dicts, lists, dataclasses, and models |
 | `set`, `frozenset` | `set` | Extra and missing items |
 | `str` | `string` | Line-by-line comparison |
 | `dict` | `dict` | Key-by-key, recursive into nested dicts and lists |

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/getting-started.md

@@ -43,7 +43,7 @@ straight at the differing field instead of dumping the whole value:
 assert_that(actual).is_equal_to(expected)
 ```
 
-![Colored dict diff: status and user.role shown with their paths, removals in red and additions in green](assets/diff-equal.svg)
+![Colored dict diff: user.role shown with its path, removal in red and addition in green](assets/diff-equal.svg)
 
 The same path-level diff backs `matches_structure()`, `satisfies()`, and `each()`. See
 [Errors & Reporting](errors.md) for the full diff format and configuration.

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/index.md

@@ -12,7 +12,7 @@ rich structural diffs on failure.
   ones, and a type checker rejects `assert_that("foo").is_positive()` before the test runs. The core
   advantage over `assertpy` and most alternatives - [see how it works](type-safety.md).
 - **Composable matchers.** `match.greater_than(5)`, `match.is_uuid()`, combined with `&`, `|`, `~`.
-- **Structural matching.** Declarative validation of dicts and API responses, with the exact path to each mismatch on failure.
+- **Structural matching.** Declarative validation of dicts, Pydantic models, 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.

{assertpy2-2.9.1 → assertpy2-2.10.0}/docs/matchers.md

@@ -124,7 +124,7 @@ assert 42 == (match.is_positive() & match.less_than(100))
 | `match.is_non_empty_string()` | a non-empty string |
 | `match.ignore()` | anything (placeholder for structural matching) |
 | `match.each_item(matcher)` | an iterable whose every item matches `matcher` |
-| `match.structure(spec)` | a dict matching a nested `spec` |
+| `match.structure(spec)` | a dict or model matching a nested `spec` |
 | `match.all_of(*matchers)` | a value matching all of `matchers` |
 | `match.any_of(*matchers)` | a value matching any of `matchers` |
 | `match.not_(matcher)` | a value not matching `matcher` |
@@ -153,6 +153,30 @@ assert_that(response).matches_structure({
 })
 ```
 
+The value under test can be a plain dict or a Pydantic model (anything exposing `model_dump()`); a
+model is normalized to its dict before matching, so the same spec works either way, including inside
+`satisfies()` and the `==` form:
+
+```python
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: str
+    name: str
+
+user = User(id="550e8400-e29b-41d4-a716-446655440000", name="Alice")
+
+assert_that(user).matches_structure({"id": match.is_uuid(), "name": match.equal_to("Alice")})
+assert_that(user).satisfies(match.structure({"id": match.is_uuid()}))
+assert user == match.structure({"id": match.is_uuid()})
+```
+
+!!! note
+    A model is matched in its `model_dump()` form: nested models become dicts, `@field_serializer` and
+    `@computed_field` outputs are applied, and spec keys are the model's field names (not aliases). The
+    spec is matched against this serialized shape, not the live attributes. This is a runtime structural
+    check; the spec keys and values are not type-checked against the model's schema.
+
 ### Nested structures
 
 Use `match.structure()` for nested dicts:

{assertpy2-2.9.1 → assertpy2-2.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.9.1"
+version = "2.10.0"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -57,7 +57,7 @@ dev = [
     "pytest>=9.1.1",
     "pytest-cov>=6.1",
     "ruff>=0.15.19",
-    "ty>=0.0.53",
+    "ty>=0.0.54",
     "typing_extensions>=4.0",
 ]
 docs = [

{assertpy2-2.9.1 → assertpy2-2.10.0}/tests/test_extracting.py

@@ -261,6 +261,55 @@ def test_extracting_iterable_of_lists():
     assert_that(matrix).extracting(-1, -2).extracting(0).is_equal_to([3, 6, 9])
 
 
+class _DuckModel:
+    """Duck-types a pydantic v2 model for the dependency-free path: iterable over (field, value)
+    pairs and NOT subscriptable, with fields exposed as attributes and a model_dump() method.
+
+    This is the exact shape that regressed extracting(): the object is iterable, so without the
+    model-dump guard it fell into the index branch and item[name] raised (no [] accessor).  It must
+    stay iterable and non-subscriptable to keep exercising that guard.
+    """
+
+    def __init__(self, **fields):
+        self.__dict__.update(fields)
+
+    def model_dump(self):
+        return dict(self.__dict__)
+
+    def __iter__(self):
+        return iter(self.__dict__.items())
+
+
+_duck_users = [_DuckModel(user="Fred", age=36), _DuckModel(user="Bob", age=40)]
+
+
+def test_extracting_model_dump_object_single_field():
+    assert_that(_duck_users).extracting("user").contains("Fred", "Bob")
+
+
+def test_extracting_model_dump_object_multiple_fields():
+    assert_that(_duck_users).extracting("user", "age").contains(("Fred", 36), ("Bob", 40))
+
+
+def test_extracting_model_dump_object_missing_field_failure():
+    with pytest.raises(ValueError) as exc_info:
+        assert_that(_duck_users).extracting("foo")
+    assert_that(str(exc_info.value)).is_equal_to("item does not have property or zero-arg method <foo>")
+
+
+def test_extracting_real_pydantic_model():
+    pytest.importorskip("pydantic", reason="pydantic not installed")
+    from pydantic import BaseModel
+
+    class User(BaseModel):
+        user: str
+        age: int
+
+    models = [User(user="Fred", age=36), User(user="Bob", age=40)]
+    assert_that(models).extracting("user").contains("Fred", "Bob")
+    assert_that(models).extracting("user", "age").contains(("Fred", 36), ("Bob", 40))
+
+
 def test_extracting_iterable_multi_extracting():
     matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
     assert_that(matrix).extracting(-1, 2).is_equal_to([(3, 3), (6, 6), (9, 9)])

{assertpy2-2.9.1 → assertpy2-2.10.0}/tests/test_file.py

@@ -141,6 +141,15 @@ def test_is_named_failure(tmpfile):
     assert_that(str(exc_info.value)).matches("Expected filename <.*> to be equal to <foo.txt>, but was not.")
 
 
+def test_is_named_failure_name_sorts_after_basename(tmpfile):
+    # Guards the `!=` filename check against a `>` mutant: when the expected name sorts AFTER the actual
+    # basename, `>` would wrongly report a match. Appending a char makes the expected name a strict
+    # superstring of the basename, so it is guaranteed larger and unequal regardless of the basename.
+    larger_name = os.path.basename(tmpfile.name) + "x"
+    with pytest.raises(AssertionError):
+        assert_that(tmpfile.name).is_named(larger_name)
+
+
 def test_is_named_bad_arg_type_failure(tmpfile):
     with pytest.raises(TypeError) as exc_info:
         assert_that(tmpfile.name).is_named(123)