assertpy2 2.21.0__tar.gz → 2.22.0__tar.gz

assertpy2-2.22.0/CONTRIBUTING.md

@@ -0,0 +1,83 @@
+# Contributing
+
+Contributions of docs, tests, or code are welcome.
+
+## Workflow
+
+1. For a new assertion or matcher, open an issue first. The API grows from demand, and a working
+   implementation on its own is not enough to land one
+2. Fork the repo
+3. Clone your fork (`git clone <your_fork_url>`)
+4. Create a branch (`git checkout -b my_branch`)
+5. Install dependencies with the [one sync command](#verification-pipeline) below, not a bare `uv sync`
+6. Make your changes
+7. Run the [verification pipeline](#verification-pipeline) and fix any issues
+8. Commit using [Conventional Commits](#commit-style)
+9. Push your branch (`git push origin my_branch`)
+10. Open a [Pull Request](http://github.com/Solganis/assertpy2/pulls)
+
+Read more about how pulls work on GitHub's [About pull requests](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests) page.
+
+## Requirements
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) as the package manager
+
+## Verification pipeline
+
+Run all checks before submitting a PR. Every step must pass.
+
+Install exactly this set. A bare `uv sync` leaves out the optional libraries several tests import, and
+those tests fail rather than skip:
+
+```bash
+uv sync --extra json --extra data --extra inline --group integrations --group docs-examples
+```
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check assertpy2/ tests/test_typing.py
+uv run pytest --cov=assertpy2 --cov-fail-under=100 --ignore=tests/test_docs_examples.py tests
+uv run pytest tests/test_docs_examples.py tests/test_typing_claims.py
+uv run --group docs mkdocs build --strict
+```
+
+The public typing surface is checked by three checkers. Run them after the block above, not before:
+`uv run --group typecheck` adds the checkers to the same `.venv` and leaves them there, and a coverage
+run with them installed collects a different set:
+
+```bash
+uv run --group typecheck mypy --strict --follow-imports=silent tests/test_typing.py
+uv run --group typecheck pyright tests/test_typing.py
+uv run --group typecheck pytest tests/test_pyright_baseline.py
+```
+
+Three details that cost time if you meet them the hard way:
+
+- `ty check` is scoped on purpose. Run over the whole tree it reports hundreds of diagnostics from
+  `tests/`, which is full of deliberate negative typing cases: calls that must not type-check.
+- `--all-extras` is not a shortcut for the sync line. Installing `allure` or `behave` makes 100%
+  coverage unreachable by construction, because the `except ImportError` branch guarding them stops
+  being executed. CI never installs them for the coverage job either.
+- `tests/test_docs_examples.py` is run separately because it executes the snippets in `docs/`, which
+  needs the `docs-examples` group and a different collection.
+
+CI requires 100% code coverage.
+
+## Commit style
+
+Use [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`, etc.
+
+## Tests
+
+Write tests for every new feature or bug fix. Use `assertpy2` assertions in tests.
+
+## Documentation examples
+
+Guide code blocks are executed and type-checked in CI, so an example you add has to run. A block that
+cannot (pseudo-context, a deliberate failure, a rejected counter-example) is marked with an HTML comment
+above the fence: `tests/test_docs_examples.py` lists the markers and what each one exempts.
+
+Setup a page assumes (a domain class, a repository, an HTTP response) goes in
+`tests/docs_fixtures.py`, not into an extra block on the page.

{assertpy2-2.21.0 → assertpy2-2.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.21.0
+Version: 2.22.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

{assertpy2-2.21.0 → assertpy2-2.22.0}/assertpy2/_engine/_typing.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
     from typing_extensions import TypeIs
 
     from .._engine._introspection import MappingLike
-    from ..assertpy import AssertionBuilder, CheckBuilder, NegatedBuilder
+    from ..assertpy import AssertionBuilder, CheckBuilder
     from ..async_assertions import AsyncAssertionBuilder, SyncAssertionBuilder
     from ..matchers import Matcher
     from ._compat import Self
@@ -251,9 +251,11 @@ if TYPE_CHECKING:
             comparators: dict[object, Callable[[Any, Any], object]] | None = ...,
             placeholders: dict[Hashable, Matcher[Any] | Callable[[Any], object]] | None = ...,
         ) -> Self: ...
-        # NegatedBuilder
+        # NegatedBuilder, which a checker sees as this very protocol: the proxy accepts what the
+        # value accepts and hands the chain back, so describing it any other way is what let
+        # `assert_that(1).not_.starts_with("x")` type-check
         @property
-        def not_(self) -> NegatedBuilder[Self]: ...
+        def not_(self) -> Self: ...
         # CheckBuilder - run the next assertion for its verdict instead of for its failure
         def check(self) -> CheckBuilder: ...
         # AssertionBuilder - typed extract-and-continue

{assertpy2-2.21.0 → assertpy2-2.22.0}/assertpy2/assertpy.py

@@ -62,7 +62,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.21.0"
+__version__ = "2.22.0"
 
 # the tracked value type of the generic AssertionBuilder fallback (_U appears only in narrowing stubs)
 _T = TypeVar("_T")
@@ -956,37 +956,65 @@ class NegatedBuilder(Generic[_S]):
         # unbound TypeVar has no attributes, so the code above could not read `kind` off it.
         return _negated  # ty: ignore[invalid-return-type]  # see above
 
-    def _make_msg(self, name: str) -> str:
+    def _make_msg(self, name: str, *args: object, **kwargs: object) -> str:
+        """The negated failure, naming the call that held when it should not have.
+
+        The arguments are in it because without them the message says which relation was asked for and
+        not what it was asked about, which is the one thing the reader needs.
+
+        Rendered here rather than by `HelpersMixin._fmt_args_kwargs()`, which spells a keyword as
+        ``'key': value``: that is the shape `when_called_with()` has printed since assertpy and its
+        messages are pinned to it, but this line reads as a call and ``key=value`` is what a call looks
+        like.  Keyword order is the caller's, which Python preserves, so it is stable without sorting.
+        """
         desc = f"[{self._builder.description}] " if self._builder.description else ""
-        return f"{desc}Expected <{self._builder.val}> to NOT satisfy: {name}()"
+        rendered = ", ".join(
+            [_safe_repr(arg) for arg in args] + [f"{key}={_safe_repr(value)}" for key, value in kwargs.items()]
+        )
+        return f"{desc}Expected <{self._builder.val}> to NOT satisfy: {name}({rendered})"
+
+    def _verdict(self, attr: Callable[..., object], *args: object, **kwargs: object) -> AssertionOutcome | None:
+        """What the underlying assertion decided, or ``None`` when it held.
+
+        Run in check mode, the one mode that hands a verdict back instead of delivering it.  That is
+        what separates a verdict from an accident: anything still raised by the call came out of the
+        value or out of an assertion nested inside it, and inverting *that* turns a break into a pass.
+
+        Catching an exception class cannot make the distinction, whatever class is chosen.  A comparator
+        that asserts with this library raises this library's own failure, and it is still not the
+        verdict of the assertion being negated.  `_negated_check()` has always read the sink instead;
+        the other three modes now do the same.
+        """
+        builder = self._builder
+        kind, sink = builder.kind, builder._check_sink
+        builder.kind = "check"
+        builder._check_sink = None
+        try:
+            attr(*args, **kwargs)
+            return builder._check_sink
+        finally:
+            builder.kind, builder._check_sink = kind, sink
 
     def _negated_strict(
         self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
     ) -> AssertionBuilder:
-        try:
-            attr(*args, **kwargs)
-        except (AssertionError, AssertionFailure):
+        if self._verdict(attr, *args, **kwargs) is not None:
             return self._builder
         # the message is composed here rather than by `error()`, which would prefix the description a
         # second time, but the exception is the builder's own: a negated failure is a failure
-        raise AssertionBuilder._failure(AssertionOutcome(message=self._make_msg(name), actual=self._builder.val))
+        raise AssertionBuilder._failure(
+            AssertionOutcome(message=self._make_msg(name, *args, **kwargs), actual=self._builder.val)
+        )
 
     def _negated_soft(
         self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
     ) -> AssertionBuilder:
+        if self._verdict(attr, *args, **kwargs) is not None:
+            return self._builder  # the assertion failed, so the negation held
         block = _collecting()
         err_list = block.failures if block is not None else []
-        before = len(err_list)
-        taint_before = self._builder._value_taint_reason
-        attr(*args, **kwargs)
-        if len(err_list) > before:
-            # underlying assertion failed, so the negation passed: roll back the collected soft
-            # error and the taint that failure set, keeping any pre-existing taint
-            del err_list[before:]
-            self._builder._value_taint_reason = taint_before
-            return self._builder
         # underlying assertion passed, so the negation failed: collect it and taint .value
-        msg = self._make_msg(name)
+        msg = self._make_msg(name, *args, **kwargs)
         if self._builder._value_taint_reason is None:
             self._builder._value_taint_reason = msg
         err_list.append(
@@ -1002,28 +1030,21 @@ class NegatedBuilder(Generic[_S]):
     def _negated_check(
         self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
     ) -> AssertionBuilder:
-        # the underlying assertion is in verdict mode too, so it lands in the sink rather than raising,
-        # and reading the sink is how this tells which way it went
-        self._builder._check_sink = None
-        attr(*args, **kwargs)
-        if self._builder._check_sink is not None:
+        if self._verdict(attr, *args, **kwargs) is not None:
             self._builder._check_sink = None  # it failed, so the negation held
             return self._builder
-        self._builder._check_sink = AssertionOutcome(message=self._make_msg(name), actual=self._builder.val)
+        self._builder._check_sink = AssertionOutcome(
+            message=self._make_msg(name, *args, **kwargs), actual=self._builder.val
+        )
         return self._builder
 
     def _negated_warn(
         self, name: str, attr: Callable[..., object], *args: object, **kwargs: object
     ) -> AssertionBuilder:
-        self._builder.kind = None
-        try:
-            attr(*args, **kwargs)
-        except (AssertionError, AssertionFailure):
-            return self._builder
-        finally:
-            self._builder.kind = "warn"
+        if self._verdict(attr, *args, **kwargs) is not None:
+            return self._builder  # the assertion failed, so the negation held
         # underlying assertion passed, so the negation failed: taint .value like error() does
-        msg = self._make_msg(name)
+        msg = self._make_msg(name, *args, **kwargs)
         if self._builder._value_taint_reason is None:
             self._builder._value_taint_reason = msg
         self._builder.logger.warning(msg)
@@ -1273,8 +1294,10 @@ class AssertionBuilder(
         If an error description is set by [`described_as()`][assertpy2.base.BaseMixin.described_as], then that
         description is prepended to the error message.
 
-        When structured data (``actual``, ``expected``, or ``diff``) is provided, raises
-        [`AssertionFailure`][assertpy2.errors.AssertionFailure] instead of plain ``AssertionError``.
+        Always raises [`AssertionFailure`][assertpy2.errors.AssertionFailure], which is an
+        ``AssertionError``.  Structured data (``actual``, ``expected``, ``diff``) is carried on it when
+        given, and the class is the same either way, which is why nothing reads the class to learn who
+        raised it: `NegatedBuilder._verdict()` asks in check mode instead.
 
         Args:
             msg: the error message
@@ -1288,11 +1311,12 @@ class AssertionBuilder(
                 it alone when the caught exception is the caller's, which is context they want.
 
         Raises:
-            AssertionError: always raised unless ``kind`` is ``warn`` or ``soft``.
+            AssertionFailure: unless ``kind`` is ``warn``, ``soft`` or ``check``, which log it, collect
+                it and record it respectively.
 
         Returns:
-            AssertionBuilder: returns this instance to chain to the next assertion, but only when
-                ``AssertionError`` is not raised, as is the case when ``kind`` is ``warn`` or ``soft``.
+            AssertionBuilder: this instance, to chain the next assertion, whenever the failure was
+                delivered some other way than by raising.
         """
         failure = self._deliver(self._compose(msg, actual=actual, expected=expected, diff=diff, trace=trace))
         if failure is None:

{assertpy2-2.21.0 → assertpy2-2.22.0}/docs/getting-started/comparison.md

@@ -154,8 +154,8 @@ whole differing container. assertpy2 keeps a path-level diff on either.
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
 |---|:---:|:---:|:---:|:---:|:---:|
 | Paradigm | rewritten `assert` | matchers | fluent chain | `==` objects | **[fluent + matchers + `==`](#all-three-styles-one-import)** |
-| Mix styles in one suite | No | No | No | No | **[Yes](#all-three-styles-one-import)** |
-| Static typing (`py.typed`, overloads) | n/a | `py.typed` only | No | **Typed** | **[Yes](../concepts/type-safety.md)** |
+| All three styles from one import | No | No | No | No | **[Yes](#all-three-styles-one-import)** |
+| Static typing | n/a | **generic matchers** | No | **Typed** | **[Typed + per-type overloads](../concepts/type-safety.md)** |
 | Autocomplete filtered by value type | No | No | No | No | **[Yes](../concepts/type-safety.md#type-aware-autocomplete)** |
 | Typed narrowing (the assertion returns the value, narrowed) | No | No | No | No | **[Yes](../concepts/type-safety.md#typed-narrowing-with-value)** |
 | Contract testing (validate a payload and narrow to the model) | No | No | No | No | **[Yes](../concepts/type-safety.md#contract-narrowing-with-assert_conforms)** |

{assertpy2-2.21.0 → assertpy2-2.22.0}/docs/guides/assertions.md

@@ -486,16 +486,15 @@ both sides is matched by identity and not walked again, exactly as Python does i
 a config object placed in two expected blocks stays cheap and a container holding the same `NaN` on
 both sides keeps comparing equal.
 
-Two limits.
-
-Anything matched **by hash** is outside it, which means dictionary keys and set elements. `1`, `1.0`
-and `True` hash alike and compare equal, so the pair is found before anything looks at its type and
-the walk never sees it. `{True: "a"}` against `{1: "a"}` and `{1}` against `{1.0}` both pass a strict
-comparison. Values, list elements and object fields are all covered normally.
-
-Strictness also turns off the fast path: a container's own `==` says nothing about the types inside
-it, so every comparison walks the whole structure in Python. On a list of 20 000 dicts that is about
-0.3 ms against 29 ms, which matters only if you are comparing large dumps in a loop.
+Anything matched **by hash** is covered too, which means dictionary keys and set members. `1`, `1.0`
+and `True` hash alike and compare equal, so a mapping finds the pair before anything looks at its
+type, and reaching it takes a second pass keyed on the type. `{True: "a"}` against `{1: "a"}` and
+`{1}` against `{1.0}` both fail a strict comparison.
+
+The one limit is cost. Strictness turns off the fast path: a container's own `==` says nothing about
+the types inside it, so every comparison walks the whole structure in Python. On a list of 20 000
+dicts that is about 0.3 ms against 41 ms, which matters only if you are comparing large dumps in a
+loop.
 
 Inside a [structural spec](matchers.md#structural-matching) the same relation is spelled
 `match.equal_to(value, strict_types=True)`, one matcher covering value and type together:

{assertpy2-2.21.0 → assertpy2-2.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.21.0"
+version = "2.22.0"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -85,7 +85,7 @@ dev = [
     # real worker processes instead of a fake node
     "pytest-xdist>=3.8.0",
     "ruff>=0.16.1",
-    "ty>=0.0.71",
+    "ty>=0.0.73",
     "typing_extensions>=4.0",
 ]
 docs = [

{assertpy2-2.21.0 → assertpy2-2.22.0}/tests/test_not.py

@@ -3,7 +3,16 @@ from io import StringIO
 
 import pytest
 
-from assertpy2 import WarningLoggingAdapter, assert_that, assert_warn, match, soft_assertions
+from assertpy2 import (
+    AssertionFailure,
+    WarningLoggingAdapter,
+    add_extension,
+    assert_that,
+    assert_warn,
+    match,
+    remove_extension,
+    soft_assertions,
+)
 
 
 class TestNotBasic:
@@ -170,6 +179,182 @@ class TestNotWarnMode:
         assert_that(out).is_empty()
 
 
+class TestNotNamesWhatItWasAskedAbout:
+    """A negated failure carries the arguments, or it names the relation and not the subject.
+
+    ``starts_with()`` says which relation held; ``starts_with('a')`` says what held.  The direct
+    spellings have always named the operand, and the proxy is the one place that did not.
+    """
+
+    def test_a_positional_argument(self):
+        with pytest.raises(AssertionError) as caught:
+            assert_that("abc").not_.starts_with("a")
+        assert_that(str(caught.value)).is_equal_to("Expected <abc> to NOT satisfy: starts_with('a')")
+
+    def test_several_arguments(self):
+        with pytest.raises(AssertionError) as caught:
+            assert_that(3).not_.is_between(1, 5)
+        assert_that(str(caught.value)).is_equal_to("Expected <3> to NOT satisfy: is_between(1, 5)")
+
+    def test_a_keyword_argument(self):
+        with pytest.raises(AssertionError) as caught:
+            assert_that({"n": 1}).not_.is_equal_to({"n": 1}, strict_types=True)
+        assert_that(str(caught.value)).is_equal_to(
+            "Expected <{'n': 1}> to NOT satisfy: is_equal_to({'n': 1}, strict_types=True)"
+        )
+
+    def test_an_assertion_that_takes_none_reads_as_before(self):
+        with pytest.raises(AssertionError) as caught:
+            assert_that(5).not_.is_positive()
+        assert_that(str(caught.value)).is_equal_to("Expected <5> to NOT satisfy: is_positive()")
+
+    def test_the_soft_block_collects_the_same_sentence(self):
+        with pytest.raises(AssertionFailure) as caught, soft_assertions():
+            assert_that("abc").not_.starts_with("a")
+        assert_that(str(caught.value)).contains("starts_with('a')")
+
+    def test_check_mode_records_the_same_sentence(self):
+        outcome = assert_that("abc").check().not_.starts_with("a")
+        assert_that(outcome.message).is_equal_to("Expected <abc> to NOT satisfy: starts_with('a')")
+
+
+class TestNotDoesNotInvertAnErrorFromTheValue:
+    """Negation inverts this library's verdict, and an ``AssertionError`` from your code is not one.
+
+    The proxy used to catch every ``AssertionError``, so a comparison that broke while being negated
+    read as "the assertion failed, so the negation held" and the test went green over the break.  The
+    four sources below are the four places user code runs inside an assertion.
+    """
+
+    @staticmethod
+    def _foreign(caught):
+        """The error travelled out as it was raised, rather than being read as a verdict."""
+        # spelled without `not_`, which is the thing under test here
+        assert_that(isinstance(caught.value, AssertionFailure)).is_false()
+        return assert_that(str(caught.value))
+
+    def test_an_equality_that_raises(self):
+        class Broken:
+            __hash__ = None
+
+            def __eq__(self, other):
+                raise AssertionError("comparison implementation broke")
+
+        with pytest.raises(AssertionError) as caught:
+            assert_that(Broken()).not_.is_equal_to(1)
+        self._foreign(caught).is_equal_to("comparison implementation broke")
+
+    def test_a_comparator_that_raises(self):
+        def broken(left, right):
+            raise AssertionError("comparator broke")
+
+        with pytest.raises(AssertionError) as caught:
+            assert_that({"n": 1}).not_.is_equal_to({"n": 2}, comparators={int: broken})
+        self._foreign(caught).is_equal_to("comparator broke")
+
+    def test_a_property_that_raises(self):
+        # this one never reached the catch even before it was narrowed: a dynamic `has_*` reads the
+        # property while the proxy is resolving the attribute, which is before there is anything to
+        # invert. Pinned so a refactor that moves resolution inside the try does not lose it silently
+        class Record:
+            @property
+            def name(self):
+                raise AssertionError("property broke")
+
+        with pytest.raises(AssertionError) as caught:
+            assert_that(Record()).not_.has_name("ada")
+        self._foreign(caught).is_equal_to("property broke")
+
+    def test_an_extension_that_raises_on_its_own(self, _broken_extension):
+        with pytest.raises(AssertionError) as caught:
+            assert_that(1).not_.breaks_outright()
+        self._foreign(caught).is_equal_to("extension broke")
+
+    def test_warn_mode_does_not_invert_it_either(self):
+        class Broken:
+            __hash__ = None
+
+            def __eq__(self, other):
+                raise AssertionError("comparison implementation broke")
+
+        with pytest.raises(AssertionError) as caught:
+            assert_warn(Broken()).not_.is_equal_to(1)
+        self._foreign(caught).is_equal_to("comparison implementation broke")
+
+    def test_a_nested_assertion_inside_a_comparator(self):
+        # the class of the exception cannot answer this one: a comparator that asserts with this
+        # library raises this library's own failure, and it is still not the verdict being negated
+        def asserts_inside(left, right):
+            assert_that(left).is_equal_to(right)
+            return True
+
+        with pytest.raises(AssertionFailure) as caught:
+            assert_that({"n": 1}).not_.is_equal_to({"n": 2}, comparators={int: asserts_inside})
+        assert_that(str(caught.value)).starts_with("Expected <1> to be equal to <2>")
+
+    def test_a_nested_assertion_inside_a_comparator_in_warn_mode(self):
+        def asserts_inside(left, right):
+            assert_that(left).is_equal_to(right)
+            return True
+
+        with pytest.raises(AssertionFailure) as caught:
+            assert_warn({"n": 1}).not_.is_equal_to({"n": 2}, comparators={int: asserts_inside})
+        assert_that(str(caught.value)).starts_with("Expected <1> to be equal to <2>")
+
+    def test_a_nested_assertion_in_a_soft_block_is_collected_rather_than_lost(self):
+        # soft collects rather than raises, so the honest outcome here is both failures, not silence
+        def asserts_inside(left, right):
+            assert_that(left).is_equal_to(right)
+            return True
+
+        with pytest.raises(AssertionFailure) as caught, soft_assertions():
+            assert_that({"n": 1}).not_.is_equal_to({"n": 2}, comparators={int: asserts_inside})
+        collected = [outcome.message.splitlines()[0] for outcome in caught.value.failures]
+        assert_that(collected).is_length(2)
+        assert_that(collected[0]).is_equal_to("Expected <1> to be equal to <2>, but was not.")
+
+    def test_the_library_own_failure_still_inverts(self):
+        # the other half of the same rule: a real verdict is what negation is for
+        assert_that(5).not_.is_equal_to(6)
+        assert_warn(5).not_.is_equal_to(6)
+
+    def test_an_extension_reporting_a_verdict_still_inverts(self, _five_extension):
+        # the documented way an extension fails is `self.error(...)`, and that is a verdict
+        assert_that(6).not_.is_five()
+        with pytest.raises(AssertionFailure, match=r"to NOT satisfy: is_five\(\)"):
+            assert_that(5).not_.is_five()
+
+
+@pytest.fixture
+def _five_extension():
+    """The extension from the guide, which reports its verdict with `self.error(...)`."""
+
+    def is_five(self):
+        if self.val != 5:
+            return self.error(f"{self.val} is NOT 5!")
+        return self
+
+    add_extension(is_five)
+    try:
+        yield
+    finally:
+        remove_extension(is_five)
+
+
+@pytest.fixture
+def _broken_extension():
+    """An extension that raises rather than reporting a verdict, taken back off the global registry."""
+
+    def breaks_outright(self):
+        raise AssertionError("extension broke")
+
+    add_extension(breaks_outright)
+    try:
+        yield
+    finally:
+        remove_extension(breaks_outright)
+
+
 class TestNotAttributes:
     def test_non_callable_attr_passthrough(self):
         builder = assert_that(5).described_as("test")
@@ -207,7 +392,7 @@ def test_not_rejects_described_as_with_clear_error():
 
 
 def test_described_as_before_not_keeps_working():
-    with pytest.raises(AssertionError, match=r"\[desc\] Expected <1> to NOT satisfy: is_equal_to\(\)"):
+    with pytest.raises(AssertionError, match=r"\[desc\] Expected <1> to NOT satisfy: is_equal_to\(1\)"):
         assert_that(1).described_as("desc").not_.is_equal_to(1)
 
 

{assertpy2-2.21.0 → assertpy2-2.22.0}/tests/typing_cases.py

@@ -153,10 +153,17 @@ def _chaining_must_not_widen_what_the_value_offers() -> None:
     """
     assert_that(1 + 2j).is_not_zero().is_positive()  # case: complex-widened-by-chaining
     assert_that(True).is_greater_than(0).is_even()  # case: bool-widened-by-chaining
-    # `.not_` is the exception, and it is a known one: the proxy resolves any name through
-    # `__getattr__`, so the negated branch accepts what the protocol does not. Closing it means a
-    # second protocol per type, which is a doubling of the typed surface for one inverted call
+    # `.not_` used to be the exception: the proxy resolves any name through `__getattr__`, so the
+    # negated branch accepted what the protocol does not. It is declared as the protocol it was
+    # reached from instead, which costs nothing and refuses the same calls the un-negated chain does
     assert_that(1 + 2j).not_.is_greater_than(0)  # case: negation-widens-the-protocol
+    # what that declaration does allow and the runtime refuses: the fourteen names that transform or
+    # configure rather than assert. The runtime says so by name, which is the tolerable direction
+    assert_that(1).not_.described_as("x")  # case: negation-allows-a-non-negatable-name
+    # an ordering matcher takes and judges anything its `<` accepts, and neither half is typed. A
+    # boundary of the wrong type is accepted, and so is a matcher built for another subject entirely
+    assert_that(1).satisfies(match.greater_than("x"))  # case: ordering-matcher-takes-any-boundary
+    assert_that("x").satisfies(match.greater_than(0))  # case: ordering-matcher-judges-any-subject
 
 
 def _takes_repeats_of_derived(assertion: _RepeatableAssertion[_Derived]) -> None:

{assertpy2-2.21.0 → assertpy2-2.22.0}/tests/typing_negative_baseline.py

@@ -15,9 +15,13 @@ and the argument is missing.  `ty` sometimes answers `no-matching-overload` wher
 argument: same family, different route through an overload set.
 
 **What stays uncaught, and why.** `assert_that(Person()).is_positive()` type-checks, because a value
-with no protocol of its own gets the generic builder, which carries every method there is.  `.not_`
-returns a proxy resolving any name, so the negated branch accepts what the protocol refuses.  Closing
-the second means a second protocol per type, doubling the typed surface for one inverted call.
+with no protocol of its own gets the generic builder, which carries every method there is.  The
+ordering matchers take and judge anything, and the entries below say why every spelling that closes
+that trades a correct call for an incorrect one.
+
+`.not_` used to belong here for the same reason as the first: it returns a proxy resolving any name.
+It is declared as the protocol it was reached from instead, which costs nothing, and what remains is
+the other direction: the fourteen names the proxy refuses at runtime are still spelled as available.
 
 **The trap this file exists to catch.** A numeric comparison is bound to `SupportsFloat` rather than to
 a list of types: the first attempt named `float | Decimal | Fraction` and rejected `numpy.int64`, a
@@ -136,10 +140,22 @@ CAUGHT: dict[str, dict[str, frozenset[str]]] = {
     # --- a step hands back `Self`, so the narrowing holds for the whole chain ----------------------
     "complex-widened-by-chaining": _MISSING,
     "bool-widened-by-chaining": _MISSING,
-    # --- still open, both for the same reason: a surface reached through `__getattr__` -------------
-    # the generic builder carries every method there is, and `.not_` resolves any name through a proxy
+    # `.not_` is declared as the protocol it was reached from, so the proxy accepts what the value
+    # accepts.  What it still allows and the runtime refuses is the handful of non-negatable names
+    "negation-widens-the-protocol": _MISSING,
+    # --- still open: the generic builder carries every method there is ------------------------------
     "numeric-assertion-on-an-object": {},
-    "negation-widens-the-protocol": {},
+    # and the negation proxy, which is declared as the protocol and so cannot describe the fourteen
+    # names it refuses at runtime
+    "negation-allows-a-non-negatable-name": {},
+    # the ordering matchers, deliberately.  `Matcher` is contravariant and `satisfies()` already refuses
+    # `match.starts_with("a")` over an `int`, so the shape works; what cannot be spelled is the ordering
+    # relation itself.  Typing the boundary as a number refuses `match.greater_than("a")`, which orders
+    # strings at runtime, and typing it as a plain TypeVar refuses `match.greater_than(0)` over a
+    # `float`, since contravariance then asks for `float` to be a subtype of `int`.  Both trade a
+    # correct call for an incorrect one, so the boundary stays `object` and the gap stays recorded
+    "ordering-matcher-takes-any-boundary": {},
+    "ordering-matcher-judges-any-subject": {},
     # --- and the third: `SupportsFloat` is wider than the runtime's `numbers.Number` ----------------
     # both are refused at runtime by name, which is the tolerable direction for an approximation to err
     "convertible-but-not-a-number": {},