assertpy2 2.9.0__tar.gz → 2.9.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.9.0
+Version: 2.9.1
 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
@@ -62,6 +62,8 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json" alt="ty"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://api.scorecard.dev/projects/github.com/Solganis/assertpy2/badge" alt="OpenSSF Scorecard"></a>
   <a href="https://www.bestpractices.dev/projects/12990"><img src="https://www.bestpractices.dev/projects/12990/badge" alt="OpenSSF Best Practices"></a>
+  <br>
+  <a href="https://solganis.github.io/assertpy2/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
 </p>
 
 ---

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

@@ -24,6 +24,8 @@
   <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json" alt="ty"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://api.scorecard.dev/projects/github.com/Solganis/assertpy2/badge" alt="OpenSSF Scorecard"></a>
   <a href="https://www.bestpractices.dev/projects/12990"><img src="https://www.bestpractices.dev/projects/12990/badge" alt="OpenSSF Best Practices"></a>
+  <br>
+  <a href="https://solganis.github.io/assertpy2/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
 </p>
 
 ---

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

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

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

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 import threading
 import uuid as _uuid_mod
-from typing import TYPE_CHECKING, Any, Final, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Final, NamedTuple, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -548,6 +548,20 @@ def _describe_spec_value(value: object) -> str:
     return f"<{value}>"
 
 
+class _SpecMismatch(NamedTuple):
+    """One structural mismatch produced by a single spec walk.
+
+    ``expected_desc`` is the public "expected" half (as exposed by ``collect_mismatches``); ``detail``
+    carries a matcher's ``describe_mismatch(actual)`` so fail-fast failure text keeps its per-value
+    detail without a second traversal.
+    """
+
+    path: str
+    actual: object
+    expected_desc: str
+    detail: str | None
+
+
 class StructureMatcher(BaseMatcher):
     """Matches dicts against a structure spec where values are matchers, raw values, or nested dicts."""
 
@@ -557,7 +571,7 @@ class StructureMatcher(BaseMatcher):
     def matches(self, value: Any) -> bool:
         if not isinstance(value, dict):
             return False
-        return self._match_recursive(value, self._spec, "", set()) is None
+        return not self._walk(value, self._spec, "", set())
 
     def describe(self) -> str:
         return f"a dict matching structure {_describe_spec_value(self._spec)}"
@@ -565,43 +579,17 @@ class StructureMatcher(BaseMatcher):
     def describe_mismatch(self, value: Any) -> str:
         if not isinstance(value, dict):
             return f"was not a dict: <{value}>"
-        error = self._match_recursive(value, self._spec, "", set())
-        if error:
-            return error
-        return f"was <{value}>"
-
-    def _match_recursive(
-        self, value: dict[Any, Any], spec: dict[Any, Any], path: str, seen: set[tuple[int, int]]
-    ) -> str | None:
-        pair_id = (id(value), id(spec))
-        if pair_id in seen:
-            return f"circular reference detected at <{path or 'root'}>"
-        seen.add(pair_id)
-        for key, expected in spec.items():
-            current_path = f"{path}.{key}" if path else str(key)
-            if key not in value:
-                return f"missing key <{current_path}>"
-            actual = value[key]
-            if isinstance(expected, StructureMatcher):
-                if not isinstance(actual, dict):
-                    return f"at <{current_path}>: expected a dict, but was <{actual}>"
-                error = self._match_recursive(actual, expected._spec, current_path, seen)
-                if error:
-                    return error
-            elif isinstance(expected, Matcher):
-                if not expected.matches(actual):
-                    return (
-                        f"at <{current_path}>: expected {expected.describe()}, but {expected.describe_mismatch(actual)}"
-                    )
-            elif isinstance(expected, dict):
-                if not isinstance(actual, dict):
-                    return f"at <{current_path}>: expected a dict, but was <{actual}>"
-                error = self._match_recursive(actual, expected, current_path, seen)
-                if error:
-                    return error
-            elif actual != expected:
-                return f"at <{current_path}>: expected <{expected}>, but was <{actual}>"
-        return None
+        mismatches = self._walk(value, self._spec, "", set())
+        if not mismatches:
+            return f"was <{value}>"
+        first = mismatches[0]
+        if first.actual is _MISSING:
+            return f"missing key <{first.path}>"
+        if first.expected_desc == "<circular ref>":  # cycle sentinel emitted by _walk
+            return f"circular reference detected at <{first.path}>"
+        if first.detail is not None:
+            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]]:
         """Collect every structural mismatch as ``(path, actual, expected_description)``.
@@ -609,34 +597,36 @@ class StructureMatcher(BaseMatcher):
         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())
+        return [(m.path, m.actual, m.expected_desc) for m in self._walk(value, self._spec, "", set())]
 
-    def _collect(
+    def _walk(
         self, value: dict[Any, Any], spec: dict[Any, Any], path: str, seen: set[tuple[int, int]]
-    ) -> list[tuple[str, object, str]]:
+    ) -> list[_SpecMismatch]:
         pair_id = (id(value), id(spec))
         if pair_id in seen:
-            return [(path or "root", "<circular ref>", "<circular ref>")]
+            return [_SpecMismatch(path or "root", "<circular ref>", "<circular ref>", None)]
         seen = seen | {pair_id}
-        mismatches: list[tuple[str, object, str]] = []
+        mismatches: list[_SpecMismatch] = []
         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)))
+                mismatches.append(_SpecMismatch(current_path, _MISSING, _describe_spec_value(expected), None))
                 continue
             actual = value[key]
             if isinstance(expected, StructureMatcher) and isinstance(actual, dict):
-                mismatches.extend(self._collect(actual, expected._spec, current_path, seen))
+                mismatches.extend(self._walk(actual, expected._spec, current_path, seen))
             elif isinstance(expected, Matcher):
                 if not expected.matches(actual):
-                    mismatches.append((current_path, actual, expected.describe()))
+                    mismatches.append(
+                        _SpecMismatch(current_path, actual, expected.describe(), expected.describe_mismatch(actual))
+                    )
             elif isinstance(expected, dict):
                 if isinstance(actual, dict):
-                    mismatches.extend(self._collect(actual, expected, current_path, seen))
+                    mismatches.extend(self._walk(actual, expected, current_path, seen))
                 else:
-                    mismatches.append((current_path, actual, "a dict"))
+                    mismatches.append(_SpecMismatch(current_path, actual, "a dict", None))
             elif actual != expected:
-                mismatches.append((current_path, actual, f"<{expected}>"))
+                mismatches.append(_SpecMismatch(current_path, actual, f"<{expected}>", None))
         return mismatches
 
 

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

@@ -161,7 +161,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.0** |
+| Latest release | built-in | 2.1.0 | 1.1 (2020) | 0.9.0 | **2.9.1** |
 | 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.0 → assertpy2-2.9.1}/docs/type-safety.md

@@ -42,9 +42,14 @@ assert_that("foo").is_positive()        # type error: is_positive is not a strin
 assert_that(42).is_instance_of("int")   # type error: expected `type`, got `str`
 ```
 
-[ty](https://github.com/astral-sh/ty), [Pyright](https://github.com/microsoft/pyright), and
-[Mypy](https://github.com/python/mypy) all report these in the editor and in CI, turning a class of test
-bugs into errors you see while typing.
+[ty](https://github.com/astral-sh/ty), [mypy `--strict`](https://github.com/python/mypy), and
+[Pyright](https://github.com/microsoft/pyright) all report these in the editor and in CI, turning a class
+of test bugs into errors you see while typing.
+
+Every public `assert_that` overload is pinned by an `assert_type` check in
+[`tests/test_typing.py`](https://github.com/Solganis/assertpy2/blob/main/tests/test_typing.py); CI runs all
+three checkers against that file on every push, with **zero suppressions**, so a regression that broadens or
+changes a return type fails the build. `ty` additionally type-checks the whole package.
 
 !!! note "Callables and captured values stay typed too"
     `assert_that(func).raises(...).when_called_with(...)` exposes string assertions on the captured

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

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

assertpy2-2.9.1/tests/test_callable.py

@@ -0,0 +1,48 @@
+import pytest
+
+from assertpy2 import assert_that
+
+
+class TestIsCallable:
+    def test_callable_lambda(self):
+        assert_that(lambda: None).is_callable()
+
+    def test_callable_function(self):
+        assert_that(print).is_callable()
+
+    def test_callable_class(self):
+        assert_that(int).is_callable()
+
+    def test_callable_method(self):
+        assert_that("foo".upper).is_callable()
+
+    def test_callable_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(42).is_callable()
+        assert_that(str(exc_info.value)).is_equal_to("Expected <42> to be callable, but was not.")
+
+    def test_callable_string_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that("foo").is_callable()
+        assert_that(str(exc_info.value)).is_equal_to("Expected <foo> to be callable, but was not.")
+
+
+class TestIsNotCallable:
+    def test_not_callable_int(self):
+        assert_that(42).is_not_callable()
+
+    def test_not_callable_string(self):
+        assert_that("foo").is_not_callable()
+
+    def test_not_callable_none(self):
+        assert_that(None).is_not_callable()
+
+    def test_not_callable_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(print).is_not_callable()
+        assert_that(str(exc_info.value)).contains("to not be callable, but was.")
+
+    def test_not_callable_lambda_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(lambda: None).is_not_callable()
+        assert_that(str(exc_info.value)).contains("to not be callable, but was.")

assertpy2-2.9.1/tests/test_chaining.py

@@ -0,0 +1,22 @@
+import datetime
+
+from assertpy2 import assert_that
+
+
+class TestChaining:
+    def test_callable_chain(self):
+        assert_that(print).is_callable().is_not_none()
+
+    def test_satisfy_chain(self):
+        assert_that([1, 2, 3]).any_satisfy(lambda x: x > 2).none_satisfy(lambda x: x < 0)
+
+    def test_contains_exactly_chain(self):
+        assert_that([1, 2, 3]).contains_exactly(1, 2, 3).is_length(3)
+
+    def test_contains_in_order_chain(self):
+        assert_that([1, 2, 3]).contains_in_order(1, 3).is_not_empty()
+
+    def test_datetime_chain(self):
+        d1 = datetime.datetime(2020, 1, 1)
+        d2 = datetime.datetime(2020, 12, 31)
+        assert_that(d1).is_before_or_equal_to(d2).is_after_or_equal_to(d1)

{assertpy2-2.9.0 → assertpy2-2.9.1}/tests/test_datetime.py

@@ -506,3 +506,74 @@ def test_is_equal_to_ignoring_seconds_each_component_mismatch():
     ):
         with pytest.raises(AssertionError):
             assert_that(base).is_equal_to_ignoring_seconds(other)
+
+
+class TestIsBeforeOrEqualTo:
+    def test_before(self):
+        d1 = datetime.datetime(2020, 1, 1)
+        d2 = datetime.datetime(2020, 1, 2)
+        assert_that(d1).is_before_or_equal_to(d2)
+
+    def test_equal(self):
+        d1 = datetime.datetime(2020, 1, 1, 12, 0, 0)
+        assert_that(d1).is_before_or_equal_to(d1)
+
+    def test_failure(self):
+        d1 = datetime.datetime(2020, 1, 2)
+        d2 = datetime.datetime(2020, 1, 1)
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(d1).is_before_or_equal_to(d2)
+        assert_that(str(exc_info.value)).contains("to be before or equal to")
+
+    def test_bad_val_type(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that("foo").is_before_or_equal_to(datetime.datetime.now())
+        assert_that(str(exc_info.value)).contains("val must be datetime")
+
+    def test_bad_arg_type(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(datetime.datetime.now()).is_before_or_equal_to("foo")
+        assert_that(str(exc_info.value)).contains("given arg must be datetime")
+
+    def test_date_not_datetime_val(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(datetime.date(2020, 1, 1)).is_before_or_equal_to(datetime.datetime.now())
+        assert_that(str(exc_info.value)).contains("val must be datetime")
+
+    def test_date_not_datetime_arg(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(datetime.datetime.now()).is_before_or_equal_to(datetime.date(2020, 1, 1))
+        assert_that(str(exc_info.value)).contains("given arg must be datetime")
+
+
+class TestIsAfterOrEqualTo:
+    def test_after(self):
+        d1 = datetime.datetime(2020, 1, 2)
+        d2 = datetime.datetime(2020, 1, 1)
+        assert_that(d1).is_after_or_equal_to(d2)
+
+    def test_equal(self):
+        d1 = datetime.datetime(2020, 1, 1, 12, 0, 0)
+        assert_that(d1).is_after_or_equal_to(d1)
+
+    def test_failure(self):
+        d1 = datetime.datetime(2020, 1, 1)
+        d2 = datetime.datetime(2020, 1, 2)
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(d1).is_after_or_equal_to(d2)
+        assert_that(str(exc_info.value)).contains("to be after or equal to")
+
+    def test_bad_val_type(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that("foo").is_after_or_equal_to(datetime.datetime.now())
+        assert_that(str(exc_info.value)).contains("val must be datetime")
+
+    def test_bad_arg_type(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(datetime.datetime.now()).is_after_or_equal_to("foo")
+        assert_that(str(exc_info.value)).contains("given arg must be datetime")
+
+    def test_date_not_datetime_val(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(datetime.date(2020, 1, 1)).is_after_or_equal_to(datetime.datetime.now())
+        assert_that(str(exc_info.value)).contains("val must be datetime")

{assertpy2-2.9.0 → assertpy2-2.9.1}/tests/test_expected_exception.py

@@ -3,7 +3,7 @@ from io import StringIO
 
 import pytest
 
-from assertpy2 import WarningLoggingAdapter, assert_that, assert_warn
+from assertpy2 import WarningLoggingAdapter, assert_that, assert_warn, soft_assertions
 
 
 def test_expected_exception():
@@ -177,3 +177,52 @@ def test_returned_without_return_value_fails():
     with pytest.raises(TypeError) as exc_info:
         assert_that(func_no_arg).raises(RuntimeError).when_called_with().returned()
     assert_that(str(exc_info.value)).contains("no return value captured")
+
+
+class TestDoesNotRaise:
+    def test_no_exception(self):
+        def safe_func(x):
+            return x + 1
+
+        assert_that(safe_func).does_not_raise(ValueError).when_called_with(1)
+
+    def test_different_exception(self):
+        def raises_type_error():
+            raise TypeError("oops")
+
+        assert_that(raises_type_error).does_not_raise(ValueError).when_called_with()
+
+    def test_raises_expected_failure(self):
+        def raises_value_error():
+            raise ValueError("bad value")
+
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(raises_value_error).does_not_raise(ValueError).when_called_with()
+        assert_that(str(exc_info.value)).contains("to not raise <ValueError>")
+        assert_that(str(exc_info.value)).contains("but did raise")
+
+    def test_raises_subclass_failure(self):
+        def raises_file_not_found():
+            raise FileNotFoundError("missing")
+
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that(raises_file_not_found).does_not_raise(OSError).when_called_with()
+        assert_that(str(exc_info.value)).contains("to not raise <OSError>")
+
+    def test_not_callable_failure(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(42).does_not_raise(ValueError)
+        assert_that(str(exc_info.value)).is_equal_to("val must be callable")
+
+    def test_not_exception_failure(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(lambda: None).does_not_raise(str)
+        assert_that(str(exc_info.value)).is_equal_to("given arg must be exception")
+
+    def test_raises_expected_soft_mode(self):
+        def raises_value_error():
+            raise ValueError("bad value")
+
+        with pytest.raises(AssertionError) as exc_info, soft_assertions():
+            assert_that(raises_value_error).does_not_raise(ValueError).when_called_with()
+        assert_that(str(exc_info.value)).contains("to not raise <ValueError>")

{assertpy2-2.9.0 → assertpy2-2.9.1}/tests/test_list.py

@@ -412,3 +412,73 @@ def test_list_of_dicts():
 class Person:
     def __init__(self, name):
         self.name = name
+
+
+class TestContainsExactly:
+    def test_list(self):
+        assert_that([1, 2, 3]).contains_exactly(1, 2, 3)
+
+    def test_tuple(self):
+        assert_that((1, 2, 3)).contains_exactly(1, 2, 3)
+
+    def test_string_chars(self):
+        assert_that("abc").contains_exactly("a", "b", "c")
+
+    def test_wrong_order_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that([1, 2, 3]).contains_exactly(1, 3, 2)
+        assert_that(str(exc_info.value)).contains("to contain exactly")
+
+    def test_missing_items_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that([1, 2, 3]).contains_exactly(1, 2)
+        assert_that(str(exc_info.value)).contains("to contain exactly")
+
+    def test_extra_items_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that([1, 2]).contains_exactly(1, 2, 3)
+        assert_that(str(exc_info.value)).contains("to contain exactly")
+
+    def test_empty_args_failure(self):
+        with pytest.raises(ValueError) as exc_info:
+            assert_that([1]).contains_exactly()
+        assert_that(str(exc_info.value)).is_equal_to("one or more args must be given")
+
+    def test_not_iterable_failure(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(42).contains_exactly(1)
+        assert_that(str(exc_info.value)).is_equal_to("val is not iterable")
+
+
+class TestContainsInOrder:
+    def test_all_present(self):
+        assert_that([1, 5, 2, 8, 3]).contains_in_order(1, 2, 3)
+
+    def test_contiguous(self):
+        assert_that([1, 2, 3]).contains_in_order(1, 2, 3)
+
+    def test_strings(self):
+        assert_that(["a", "x", "b", "y", "c"]).contains_in_order("a", "b", "c")
+
+    def test_single_item(self):
+        assert_that([1, 2, 3]).contains_in_order(2)
+
+    def test_wrong_order_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that([1, 2, 3]).contains_in_order(3, 1)
+        assert_that(str(exc_info.value)).contains("in order, but did not")
+
+    def test_missing_item_failure(self):
+        with pytest.raises(AssertionError) as exc_info:
+            assert_that([1, 2, 3]).contains_in_order(1, 4)
+        assert_that(str(exc_info.value)).contains("in order, but did not")
+
+    def test_empty_args_failure(self):
+        with pytest.raises(ValueError) as exc_info:
+            assert_that([1]).contains_in_order()
+        assert_that(str(exc_info.value)).is_equal_to("one or more args must be given")
+
+    def test_not_iterable_failure(self):
+        with pytest.raises(TypeError) as exc_info:
+            assert_that(42).contains_in_order(1)
+        assert_that(str(exc_info.value)).is_equal_to("val is not iterable")