assertpy2 2.6.0__tar.gz → 2.7.0__tar.gz

{assertpy2-2.6.0 → assertpy2-2.7.0}/.gitignore

@@ -10,6 +10,7 @@ __pycache__
 cover
 .coverage
 htmlcov
+.hypothesis
 __snapshots
 mycustompath
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.6.0
+Version: 2.7.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.6.0 → assertpy2-2.7.0}/assertpy2/_mixin_base.py

@@ -17,6 +17,7 @@ class _MixinBase:
         logger: logging.LoggerAdapter
         _not_expected: bool
         _expected_warning: type[Warning] | None
+        _return_value: object
 
         def error(
             self,
@@ -32,7 +33,7 @@ class _MixinBase:
             val: object,
             description: str = ...,
             kind: str | None = ...,
-            expected: BaseException | None = ...,
+            expected: type[BaseException] | None = ...,
             logger: logging.LoggerAdapter | None = ...,
         ) -> Self: ...
 

{assertpy2-2.6.0 → assertpy2-2.7.0}/assertpy2/_typing.py

@@ -215,6 +215,17 @@ if TYPE_CHECKING:
         def is_hex_equal_to(self, expected_hex: str) -> Self: ...
         def decoded_as(self, encoding: str = ...) -> _StringAssertion: ...
 
+    class _InvokedAssertion(_StringAssertion, Protocol):
+        """Assertions available after ``when_called_with()`` captured an exception/warning message.
+
+        The captured message is a ``str`` (hence the string assertions); :meth:`returned` pivots to
+        the value the callable returned.  Its static type is unknown, so ``returned()`` exposes the
+        type-agnostic core assertions (``is_equal_to``, ``is_instance_of``, ``satisfies``, ...) -
+        type-safe by construction, never advertising methods that may not apply.
+        """
+
+        def returned(self) -> _CoreAssertion: ...
+
     class _CallableAssertion(_CoreAssertion, Protocol):
         """Assertions available for callable values."""
 
@@ -222,5 +233,6 @@ if TYPE_CHECKING:
         def does_not_raise(self, ex: type) -> Self: ...
         def warns(self, warning: type[Warning] = ...) -> Self: ...
         def does_not_warn(self, warning: type[Warning] = ...) -> Self: ...
-        def when_called_with(self, *some_args: object, **some_kwargs: object) -> Self: ...
+        # captured value (exception or warning message) is a str; returned() pivots to the call result
+        def when_called_with(self, *some_args: object, **some_kwargs: object) -> _InvokedAssertion: ...
         def eventually(self, *, timeout: float = ..., interval: float = ...) -> AsyncAssertionBuilder: ...

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

@@ -37,7 +37,7 @@ from .date import DateMixin
 from .dict import DictMixin
 from .dynamic import DynamicMixin
 from .errors import AssertionFailure
-from .exception import ExceptionMixin
+from .exception import _UNSET, ExceptionMixin
 from .extracting import ExtractingMixin
 from .file import FileMixin
 from .helpers import HelpersMixin
@@ -47,7 +47,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -589,6 +589,7 @@ class AssertionBuilder(
         self.logger = logger if logger else _default_logger
         self._not_expected = False
         self._expected_warning = None
+        self._return_value = _UNSET
 
     @property
     def not_(self) -> NegatedBuilder:

{assertpy2-2.6.0 → assertpy2-2.7.0}/assertpy2/exception.py

@@ -9,6 +9,8 @@ if TYPE_CHECKING:
 
 __tracebackhide__ = True
 
+_UNSET = object()  # sentinel: no return value captured yet
+
 
 class _InertBuilder:
     """No-op builder returned after a failed raises/when_called_with in soft mode.
@@ -105,10 +107,34 @@ class ExceptionMixin(_MixinBase):
         )
         return cast("Self", _InertBuilder())
 
+    def returned(self) -> Self:
+        """Pivots the chain to the value ``val()`` returned during :meth:`when_called_with`.
+
+        Use after a call that completed normally (:meth:`~assertpy2.warning.WarningMixin.warns`,
+        :meth:`~assertpy2.warning.WarningMixin.does_not_warn`, or :meth:`does_not_raise`) to assert
+        on the return value in the same chain.
+
+        Examples:
+            Usage::
+
+                assert_that(make_client).warns(DeprecationWarning).when_called_with().returned().is_instance_of(Client)
+                assert_that(adder).does_not_raise(TypeError).when_called_with(1, 2).returned().is_equal_to(3)
+
+        Returns:
+            AssertionBuilder: a new instance wrapping the captured return value
+
+        Raises:
+            TypeError: if no return value was captured (the call raised, or :meth:`when_called_with`
+                was not invoked first)
+        """
+        if self._return_value is _UNSET:
+            raise TypeError("no return value captured; returned() is only valid after a call that completed normally")
+        return self.builder(self._return_value, self.description, self.kind, logger=self.logger)
+
     def _when_called_with_not_expected(self, *some_args, **some_kwargs) -> Self:
         assert self.expected is not None
         try:
-            self.val(*some_args, **some_kwargs)
+            result = self.val(*some_args, **some_kwargs)
         except BaseException as e:
             if issubclass(type(e), self.expected):
                 self.error(
@@ -117,6 +143,8 @@ class ExceptionMixin(_MixinBase):
                     f" but did raise <{type(e).__name__}>."
                 )
                 return cast("Self", _InertBuilder())
+            return self
+        self._return_value = result
         return self
 
     def does_not_raise(self, ex) -> Self:

{assertpy2-2.6.0 → assertpy2-2.7.0}/assertpy2/warning.py

@@ -89,10 +89,12 @@ class WarningMixin(_MixinBase):
     def _when_called_with_warning(self, expected: type[Warning], *some_args, **some_kwargs) -> Self:
         with warnings.catch_warnings(record=True) as caught:
             warnings.simplefilter("always")  # bypass __warningregistry__ "show once" dedup and filterwarnings=error
-            self.val(*some_args, **some_kwargs)
+            result = self.val(*some_args, **some_kwargs)
         matched = [w for w in caught if issubclass(w.category, expected)]
         if matched:
-            return self.builder(str(matched[0].message), self.description, self.kind, logger=self.logger)
+            captured = self.builder(str(matched[0].message), self.description, self.kind, logger=self.logger)
+            captured._return_value = result
+            return captured
         if caught:
             seen = ", ".join(sorted({w.category.__name__ for w in caught}))
             self.error(
@@ -110,7 +112,7 @@ class WarningMixin(_MixinBase):
     def _when_called_with_not_warning(self, expected: type[Warning], *some_args, **some_kwargs) -> Self:
         with warnings.catch_warnings(record=True) as caught:
             warnings.simplefilter("always")  # bypass __warningregistry__ "show once" dedup and filterwarnings=error
-            self.val(*some_args, **some_kwargs)
+            result = self.val(*some_args, **some_kwargs)
         matched = [w for w in caught if issubclass(w.category, expected)]
         if matched:
             seen = ", ".join(sorted({w.category.__name__ for w in matched}))
@@ -120,4 +122,5 @@ class WarningMixin(_MixinBase):
                 f" but did warn <{seen}>."
             )
             return cast("Self", _InertBuilder())
+        self._return_value = result
         return self

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

@@ -119,6 +119,17 @@ The category defaults to `Warning` (matches any warning) and matches subclasses.
 assert_that(safe_func).does_not_warn(DeprecationWarning).when_called_with("foo")
 ```
 
+To also assert on the value the call returned (alongside the warning, or after `does_not_warn` /
+`does_not_raise`), pivot with `returned()`:
+
+```python
+assert_that(make_client).warns(DeprecationWarning).when_called_with().returned().is_instance_of(Client)
+assert_that(adder).does_not_raise(TypeError).when_called_with(1, 2).returned().is_equal_to(3)
+```
+
+`returned()` exposes the type-agnostic core assertions (`is_equal_to`, `is_instance_of`, `satisfies`,
+...); it raises `TypeError` if the call raised (there is no return value to inspect).
+
 !!! warning "Not thread-safe"
     `warns()` / `does_not_warn()` rely on `warnings.catch_warnings()`, which mutates process-global
     state. They are safe within a single thread (including multiple `asyncio` tasks on one event

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

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.6.0"
+version = "2.7.0"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -53,6 +53,7 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
+    "hypothesis>=6.155.6",
     "pytest>=9.1.1",
     "pytest-cov>=6.1",
     "ruff>=0.15.18",

{assertpy2-2.6.0 → assertpy2-2.7.0}/tests/test_expected_exception.py

@@ -161,3 +161,17 @@ def test_expected_exception_warn_wrong_type_preserves_logger():
 class Foo:
     def bar(self):
         raise RuntimeError("method err")
+
+
+def safe_add(value):
+    return value + 1
+
+
+def test_does_not_raise_returned_pivots_to_return_value():
+    assert_that(safe_add).does_not_raise(ValueError).when_called_with(41).returned().is_equal_to(42)
+
+
+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")

{assertpy2-2.6.0 → assertpy2-2.7.0}/tests/test_expected_warning.py

@@ -175,3 +175,29 @@ def test_does_not_warn_failure_in_warn_mode_logs():
     assert_that(out).contains(
         "Expected <warn_user> to not warn <UserWarning> when called with (), but did warn <UserWarning>."
     )
+
+
+# returned() pivot to the callable's return value
+
+
+def warn_and_return_list(*args, **kwargs):
+    warnings.warn("dep since 2.7", DeprecationWarning, stacklevel=2)
+    return [1, 2, 3]
+
+
+def quiet_return_ok(*args, **kwargs):
+    return "ok"
+
+
+def test_warns_returned_pivots_to_return_value():
+    assert_that(warn_and_return_list).warns(DeprecationWarning).when_called_with().returned().is_equal_to([1, 2, 3])
+
+
+def test_warns_returned_after_message_assertion():
+    assert_that(warn_and_return_list).warns(DeprecationWarning).when_called_with().matches(
+        "since 2.7"
+    ).returned().is_equal_to([1, 2, 3])
+
+
+def test_does_not_warn_returned_pivots_to_return_value():
+    assert_that(quiet_return_ok).does_not_warn(DeprecationWarning).when_called_with().returned().is_equal_to("ok")

assertpy2-2.7.0/tests/test_property_based.py

@@ -0,0 +1,333 @@
+"""Property-based tests (Hypothesis) for the riskiest pure-logic surfaces.
+
+These complement the example-based suite: 100% line coverage does not exercise the *space* of
+values, which is where recursive equality, ignore/include filtering, and matcher algebra hide bugs.
+Each test states an invariant and lets Hypothesis attack it with generated data; on failure the
+shrunk counterexample plus assertpy2's structured ``AssertionFailure`` pinpoint the mismatch.
+"""
+
+import copy
+from collections import namedtuple
+from dataclasses import dataclass, replace
+
+import pytest
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
+from assertpy2 import assert_that, match
+
+# JSON-like values: atoms plus nested lists/dicts. NaN is excluded so equality stays reflexive.
+_atoms = st.none() | st.booleans() | st.integers() | st.floats(allow_nan=False) | st.text()
+_values = st.recursive(
+    _atoms,
+    lambda children: st.lists(children) | st.dictionaries(st.text(), children),
+    max_leaves=20,
+)
+_keys = st.text(min_size=1, max_size=5)
+
+
+# --- is_equal_to / is_not_equal_to mirror Python equality ---
+
+
+@settings(deadline=None)
+@given(value=_values)
+def test_is_equal_to_is_reflexive(value):
+    assert_that(value).is_equal_to(copy.deepcopy(value))
+
+
+@settings(deadline=None)
+@given(left=_values, right=_values)
+def test_is_equal_to_consistent_with_eq(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(left=_values, right=_values)
+def test_is_not_equal_to_is_the_inverse(left, right):
+    if left != right:
+        assert_that(left).is_not_equal_to(right)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(left).is_not_equal_to(right)
+
+
+@given(left=st.sets(st.integers()), right=st.sets(st.integers()))
+def test_is_equal_to_consistent_with_eq_for_sets(left, right):
+    if left == right:
+        assert_that(left).is_equal_to(right)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(left).is_equal_to(right)
+
+
+# --- ignore / include selective comparison ---
+
+
+@settings(deadline=None)
+@given(base=st.dictionaries(_keys, _atoms, max_size=6), perturbations=st.dictionaries(_keys, _atoms, max_size=4))
+def test_ignore_removes_differences(base, perturbations):
+    # left keeps base values; right overlays perturbations. Ignoring exactly the perturbed keys
+    # leaves both dicts identical on the remaining (base) keys, so they compare equal.
+    left = dict(base)
+    right = {**base, **perturbations}
+    assert_that(left).is_equal_to(right, ignore=list(perturbations))
+
+
+@settings(deadline=None)
+@given(
+    common=st.dictionaries(_keys, _atoms, min_size=1, max_size=4),
+    left_extra=st.dictionaries(_keys, _atoms, max_size=3),
+    right_extra=st.dictionaries(_keys, _atoms, max_size=3),
+)
+def test_include_compares_only_listed_keys(common, left_extra, right_extra):
+    # both dicts agree on every common key; extras (outside the common set) differ but are excluded.
+    included = list(common)
+    left = {**{k: v for k, v in left_extra.items() if k not in common}, **common}
+    right = {**{k: v for k, v in right_extra.items() if k not in common}, **common}
+    assert_that(left).is_equal_to(right, include=included)
+
+
+# --- matcher predicates mirror their Python semantics ---
+
+
+@given(value=st.integers(), low=st.integers(), high=st.integers())
+def test_between_matcher_matches_python_semantics(value, low, high):
+    assert match.between(low, high).matches(value) == (low <= value <= high)
+
+
+@given(value=st.integers(), boundary=st.integers())
+def test_greater_than_matcher_matches_python_semantics(value, boundary):
+    assert match.greater_than(boundary).matches(value) == (value > boundary)
+
+
+@given(value=st.integers(), low=st.integers(), high=st.integers())
+def test_satisfies_between_consistent_with_semantics(value, low, high):
+    if low <= value <= high:
+        assert_that(value).satisfies(match.between(low, high))
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(value).satisfies(match.between(low, high))
+
+
+# --- matcher boolean algebra (& | ~) ---
+
+
+@given(value=st.integers(), boundary_low=st.integers(), boundary_high=st.integers())
+def test_matcher_combinators_follow_boolean_logic(value, boundary_low, boundary_high):
+    matcher_a = match.greater_than(boundary_low)
+    matcher_b = match.less_than(boundary_high)
+    result_a = matcher_a.matches(value)
+    result_b = matcher_b.matches(value)
+
+    assert (matcher_a & matcher_b).matches(value) == (result_a and result_b)
+    assert (matcher_a | matcher_b).matches(value) == (result_a or result_b)
+    assert (~matcher_a).matches(value) == (not result_a)
+    # de Morgan: ~(a & b) == (~a | ~b)
+    assert (~(matcher_a & matcher_b)).matches(value) == ((~matcher_a) | (~matcher_b)).matches(value)
+
+
+# --- collection roundtrips ---
+
+
+@given(items=st.lists(st.integers()))
+def test_is_length_matches_len(items):
+    assert_that(items).is_length(len(items))
+
+
+@given(items=st.lists(st.integers(), min_size=1))
+def test_contains_every_element(items):
+    assert_that(items).contains(*items)
+
+
+@given(items=st.lists(st.integers()), candidate=st.integers())
+def test_contains_present_iff_member(items, candidate):
+    if candidate in items:
+        assert_that(items).contains(candidate)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(items).contains(candidate)
+
+
+# === Point 1: recursive comparison over dataclasses / namedtuples ===
+# Exercises the riskiest code: _build_equality_diff / _sub_diff_entries (nesting, models, lists).
+
+
+@dataclass
+class _Inner:
+    a: int
+    b: str
+
+
+@dataclass
+class _Outer:
+    inner: _Inner
+    items: list[int]
+    name: str
+
+
+_Pair = namedtuple("_Pair", ["first", "second"])
+
+_inners = st.builds(_Inner, a=st.integers(), b=st.text(max_size=5))
+_outers = st.builds(_Outer, inner=_inners, items=st.lists(st.integers(), max_size=4), name=st.text(max_size=5))
+_pairs = st.builds(_Pair, first=st.integers(), second=st.text(max_size=5))
+
+
+@settings(deadline=None)
+@given(left=_outers, right=_outers)
+def test_dataclass_is_equal_to_consistent_with_eq(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=_outers)
+def test_dataclass_is_equal_to_reflexive(value):
+    assert_that(value).is_equal_to(copy.deepcopy(value))
+
+
+@settings(deadline=None)
+@given(value=_outers, new_name=st.text(max_size=5))
+def test_dataclass_ignore_removes_field_difference(value, new_name):
+    other = replace(value, name=new_name)
+    assert_that(value).is_equal_to(other, ignore="name")
+
+
+@given(left=_pairs, right=_pairs)
+def test_namedtuple_is_equal_to_consistent_with_eq(left, right):
+    if left == right:
+        assert_that(left).is_equal_to(right)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(left).is_equal_to(right)
+
+
+@given(value=_pairs)
+def test_namedtuple_is_equal_to_reflexive(value):
+    assert_that(value).is_equal_to(copy.deepcopy(value))
+
+
+# === Point 2: multiset / ordering semantics of collection assertions ===
+
+
+def _is_subsequence(sub, seq):
+    # shared iterator advances across the any() calls - the classic subsequence check
+    iterator = iter(seq)
+    return all(any(candidate == element for candidate in iterator) for element in sub)
+
+
+@given(val=st.lists(st.integers(), max_size=6), expected=st.lists(st.integers(), min_size=1, max_size=6))
+def test_contains_exactly_matches_list_equality(val, expected):
+    if val == expected:
+        assert_that(val).contains_exactly(*expected)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(val).contains_exactly(*expected)
+
+
+@given(val=st.lists(st.integers(), max_size=6), items=st.lists(st.integers(), min_size=1, max_size=6))
+def test_contains_only_matches_set_equality(val, items):
+    if set(val) == set(items):
+        assert_that(val).contains_only(*items)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(val).contains_only(*items)
+
+
+@given(val=st.lists(st.integers(), max_size=8), items=st.lists(st.integers(), min_size=1, max_size=4))
+def test_contains_sequence_matches_contiguous_slice(val, items):
+    window = len(items)
+    is_contiguous = any(val[index : index + window] == items for index in range(len(val) - window + 1))
+    if is_contiguous:
+        assert_that(val).contains_sequence(*items)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(val).contains_sequence(*items)
+
+
+@given(val=st.lists(st.integers(), max_size=8), items=st.lists(st.integers(), min_size=1, max_size=4))
+def test_contains_in_order_matches_subsequence(val, items):
+    if _is_subsequence(items, val):
+        assert_that(val).contains_in_order(*items)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(val).contains_in_order(*items)
+
+
+@given(items=st.lists(st.integers(), max_size=10))
+def test_does_not_contain_duplicates_iff_unique(items):
+    if len(items) == len(set(items)):
+        assert_that(items).does_not_contain_duplicates()
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(items).does_not_contain_duplicates()
+
+
+@given(items=st.lists(st.integers(), max_size=10))
+def test_is_sorted_matches_python_sorted(items):
+    if items == sorted(items):
+        assert_that(items).is_sorted()
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(items).is_sorted()
+
+
+@given(items=st.lists(st.integers(), max_size=10))
+def test_is_sorted_reverse_matches_python_sorted(items):
+    if items == sorted(items, reverse=True):
+        assert_that(items).is_sorted(reverse=True)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(items).is_sorted(reverse=True)
+
+
+@given(items=st.lists(st.integers(), max_size=8), superset=st.lists(st.integers(), max_size=10))
+def test_is_subset_of_matches_set_subset(items, superset):
+    if set(items) <= set(superset):
+        assert_that(items).is_subset_of(superset)
+    else:
+        with pytest.raises(AssertionError):
+            assert_that(items).is_subset_of(superset)
+
+
+# === Point 3: nested ignore via tuple key-paths (recursion in _dict_not_equal) ===
+
+_two_level = st.dictionaries(
+    st.text(min_size=1, max_size=3),
+    st.dictionaries(st.text(min_size=1, max_size=3), st.integers(), max_size=3),
+    max_size=3,
+)
+
+
+@settings(deadline=None)
+@given(base=_two_level, data=st.data())
+def test_nested_ignore_removes_leaf_differences(base, data):
+    paths = [(outer, leaf) for outer, inner in base.items() for leaf in inner]
+    perturbed = data.draw(st.lists(st.sampled_from(paths), unique=True)) if paths else []
+    right = {outer: dict(inner) for outer, inner in base.items()}
+    for outer, leaf in perturbed:
+        right[outer][leaf] += 1000  # ints, so always a real difference
+    # ignoring exactly the perturbed leaf-paths leaves both dicts identical elsewhere
+    assert_that(base).is_equal_to(right, ignore=list(perturbed))
+
+
+@settings(deadline=None)
+@given(base=_two_level, data=st.data())
+def test_nested_include_compares_only_listed_leaves(base, data):
+    paths = [(outer, leaf) for outer, inner in base.items() for leaf in inner]
+    if not paths:
+        return  # include needs at least one referenced path; nothing to compare on an empty dict
+    included = data.draw(st.lists(st.sampled_from(paths), unique=True, min_size=1))
+    included_set = set(included)
+    right = {outer: dict(inner) for outer, inner in base.items()}
+    for outer, leaf in paths:
+        if (outer, leaf) not in included_set:
+            right[outer][leaf] += 1000  # perturb only NON-included leaves (keys untouched)
+    # comparing only the included leaf-paths -> equal, since those leaves are left intact
+    assert_that(base).is_equal_to(right, include=list(included))

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

@@ -34,7 +34,7 @@ wheels = [
 
 [[package]]
 name = "assertpy2"
-version = "2.6.0"
+version = "2.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
@@ -54,6 +54,7 @@ json = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "hypothesis" },
     { name = "pytest" },
     { name = "pytest-cov" },
     { name = "ruff" },
@@ -76,6 +77,7 @@ provides-extras = ["allure", "behave", "json"]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "hypothesis", specifier = ">=6.155.6" },
     { name = "pytest", specifier = ">=9.1.1" },
     { name = "pytest-cov", specifier = ">=6.1" },
     { name = "ruff", specifier = ">=0.15.18" },
@@ -428,6 +430,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
 ]
 
+[[package]]
+name = "hypothesis"
+version = "6.155.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/10/aa/9a91a4addf285702a98713da44b3581799539426436617bfb8914478c166/hypothesis-6.155.6.tar.gz", hash = "sha256:7569e1897690336c85d49d8391b49ec6ab83d951009515bfc29faebbac286cf5", size = 478038, upload-time = "2026-06-19T13:21:23.379Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/a9/4c17e962c2e9cbc314bb579ed2e2b2da45d7b6b942aab6948d14d85abfea/hypothesis-6.155.6-py3-none-any.whl", hash = "sha256:a96d9a29f6bbc8ccac39dd84e140892da76765464929f401a4181b90c20c9ad1", size = 544521, upload-time = "2026-06-19T13:21:20.934Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.18"
@@ -1205,6 +1220,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
 ]
 
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
 [[package]]
 name = "tomli"
 version = "2.4.1"