assertpy2 2.16.0__tar.gz → 2.17.0__tar.gz

{assertpy2-2.16.0 → assertpy2-2.17.0}/.github/workflows/publish.yml

@@ -46,15 +46,24 @@ jobs:
         with:
           subject-path: dist/*.tar.gz
 
-      - name: Prepare provenance bundles
+      - name: Collect provenance (sigstore bundles + in-toto)
         run: |
           mkdir -p provenance
           cp "$WHEEL_BUNDLE" "provenance/$(basename dist/*.whl).sigstore.json"
           cp "$SDIST_BUNDLE" "provenance/$(basename dist/*.tar.gz).sigstore.json"
+          jq -c '.dsseEnvelope' "$WHEEL_BUNDLE" > provenance/provenance.intoto.jsonl
+          jq -c '.dsseEnvelope' "$SDIST_BUNDLE" >> provenance/provenance.intoto.jsonl
+          test -s provenance/provenance.intoto.jsonl
         env:
           WHEEL_BUNDLE: ${{ steps.attest-wheel.outputs.bundle-path }}
           SDIST_BUNDLE: ${{ steps.attest-sdist.outputs.bundle-path }}
 
+      - name: Install syft
+        uses: anchore/sbom-action/download-syft@e22c389904149dbc22b58101806040fa8d37a610 # v0.24.0
+
+      - name: Generate SBOM (CycloneDX)
+        run: syft scan dir:dist -o "cyclonedx-json=provenance/assertpy2.sbom.cdx.json"
+
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.16.0
+Version: 2.17.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
@@ -203,7 +203,7 @@ data = assert_conforms(response.json(), OrderModel).value  # data: OrderModel
 - [**Structured errors**](https://solganis.github.io/assertpy2/guides/errors/#structured-errors): `AssertionFailure` carries `.actual`, `.expected`, `.diff`, and the diff renders into the message itself, so it shows off pytest too.
 - [**Rich pytest diffs**](https://solganis.github.io/assertpy2/guides/errors/#rich-pytest-diffs): recursive structural diffs across containers, dataclasses, attrs, and Pydantic models, with intra-line carets for strings and circular-reference protection.
 - [**Snapshot testing**](https://solganis.github.io/assertpy2/guides/testing/#snapshot-testing): three modes under one typed API, all updated with `--assertpy2-snapshot-update`: `snapshot()` (external JSON file), [`matches_inline()`](https://solganis.github.io/assertpy2/guides/testing/#inline-snapshots) (recorded into the test source), and [`matches_contract_snapshot()`](https://solganis.github.io/assertpy2/guides/testing/#contract-snapshots) (value-tolerant structural regressions).
-- [**OpenAPI response contracts**](https://solganis.github.io/assertpy2/reference/json/#assertpy2.json_mixin.JsonMixin.conforms_to_openapi): `conforms_to_openapi(spec, path, method)` validates a JSON response body against an operation's response schema (OpenAPI 3.0/3.1), reporting every violation with its JSON path.
+- [**OpenAPI response contracts**](https://solganis.github.io/assertpy2/reference/json/#assertpy2.json_mixin.JsonMixin.conforms_to_openapi): `conforms_to_openapi(spec, path, method)` validates a JSON response body against an operation's response schema (OpenAPI 3.0/3.1 and Swagger 2.0), reporting every violation with its JSON path.
 
 **Extensibility**
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/README.md

@@ -151,7 +151,7 @@ data = assert_conforms(response.json(), OrderModel).value  # data: OrderModel
 - [**Structured errors**](https://solganis.github.io/assertpy2/guides/errors/#structured-errors): `AssertionFailure` carries `.actual`, `.expected`, `.diff`, and the diff renders into the message itself, so it shows off pytest too.
 - [**Rich pytest diffs**](https://solganis.github.io/assertpy2/guides/errors/#rich-pytest-diffs): recursive structural diffs across containers, dataclasses, attrs, and Pydantic models, with intra-line carets for strings and circular-reference protection.
 - [**Snapshot testing**](https://solganis.github.io/assertpy2/guides/testing/#snapshot-testing): three modes under one typed API, all updated with `--assertpy2-snapshot-update`: `snapshot()` (external JSON file), [`matches_inline()`](https://solganis.github.io/assertpy2/guides/testing/#inline-snapshots) (recorded into the test source), and [`matches_contract_snapshot()`](https://solganis.github.io/assertpy2/guides/testing/#contract-snapshots) (value-tolerant structural regressions).
-- [**OpenAPI response contracts**](https://solganis.github.io/assertpy2/reference/json/#assertpy2.json_mixin.JsonMixin.conforms_to_openapi): `conforms_to_openapi(spec, path, method)` validates a JSON response body against an operation's response schema (OpenAPI 3.0/3.1), reporting every violation with its JSON path.
+- [**OpenAPI response contracts**](https://solganis.github.io/assertpy2/reference/json/#assertpy2.json_mixin.JsonMixin.conforms_to_openapi): `conforms_to_openapi(spec, path, method)` validates a JSON response body against an operation's response schema (OpenAPI 3.0/3.1 and Swagger 2.0), reporting every violation with its JSON path.
 
 **Extensibility**
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/_engine/_compare.py

@@ -89,11 +89,13 @@ def _ambiguous_array_operand(value: object, other: object) -> object | None:
 
 def _array_equality_error(method: str, operand: object) -> TypeError:
     """Build the actionable error raised when ``method`` is given an element-wise array/frame-like."""
+    # point at the assertion that delegates to the library's own comparison: it reports the differing
+    # column or index, where wrapping `.equals()` in is_true() would report a bare False
+    dedicated = "is_frame_equal(expected)" if hasattr(operand, "equals") else "is_array_equal(expected)"
     return TypeError(
         f"{method}() cannot directly compare <{type(operand).__name__}>: its '==' is element-wise and has"
-        " no single truth value. Compare the value's own equality (e.g."
-        " assert_that(actual.equals(expected)).is_true()), assert on extracted scalars (columns, shape,"
-        " length), or use satisfies(...) with an explicit predicate."
+        f" no single truth value. Use {dedicated}, assert on extracted scalars (columns, shape, length),"
+        " or use satisfies(...) with an explicit predicate."
     )
 
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/_engine/_diff.py

@@ -183,7 +183,11 @@ def _build_equality_diff(
         for item in sorted(expected - actual, key=_safe_repr):
             entries.append(DiffEntry(path="missing", actual=None, expected=item))
         return DiffResult(kind="set", entries=entries)
-    if isinstance(actual, str) and isinstance(expected, str):
+    # bytes render as their b'...' literal, which difflib can point into exactly like text, and both
+    # kinds expose splitlines(), so one branch serves them
+    both_text = isinstance(actual, str) and isinstance(expected, str)
+    both_bytes = isinstance(actual, (bytes, bytearray)) and isinstance(expected, (bytes, bytearray))
+    if both_text or both_bytes:
         entries = []
         actual_lines = actual.splitlines()
         expected_lines = expected.splitlines()

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/assertpy.py

@@ -53,7 +53,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.16.0"
+__version__ = "2.17.0"
 
 # the tracked value type of the generic AssertionBuilder fallback (_U appears only in narrowing stubs)
 _T = TypeVar("_T")

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/async_assertions.py

@@ -84,6 +84,14 @@ def _summarize(samples, total_polls, elapsed, fail_polls, error_polls) -> str:
         return f"probe recovered after {error_polls} raising {poll_word}; {trend}"
     if not changes:
         return f"value unchanged across {total_polls} polls"
+    distinct: list[object] = []
+    for sample in fails:
+        if not any(sample.value == seen for seen in distinct):
+            distinct.append(sample.value)
+    # a simple path through k values takes k-1 changes, so any surplus means the probe came back to a
+    # value it already reported: a cycle, which reads nothing like steady progress that ran out of time
+    if len(changes) >= len(distinct):
+        return f"value cycles between {len(distinct)} states across {total_polls} polls"
     last_change = elapsed - changes[-1].elapsed
     return f"value changed {len(changes)} {change_word}; last change {last_change:.1f}s before the deadline"
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/base.py

@@ -14,6 +14,7 @@ from ._engine._diff import _build_equality_diff
 from ._engine._introspection import is_namedtuple
 from ._satisfies import SatisfiesMixin
 from .errors import _disambiguated, _truncated
+from .helpers import _both_list_like, _elided_seq_repr, _elided_text_repr
 
 if TYPE_CHECKING:
     from ._engine._compat import Self
@@ -172,7 +173,11 @@ class BaseMixin(SatisfiesMixin):
             if type(self.val) in _EQ_ATOMIC and type(other) in _EQ_ATOMIC:
                 # atomic scalars: no array/dict-likeness, == yields a real bool - skip config/guards entirely
                 if self.val != other:
-                    actual_repr, expected_repr = _disambiguated(self.val, other)
+                    if isinstance(self.val, str) and isinstance(other, str):
+                        actual_repr = _truncated(_elided_text_repr(self.val, other))
+                        expected_repr = _truncated(_elided_text_repr(other, self.val))
+                    else:
+                        actual_repr, expected_repr = _disambiguated(self.val, other)
                     return self.error(
                         f"Expected <{actual_repr}> to be equal to <{expected_repr}>, but was not.",
                         actual=self.val,
@@ -218,7 +223,11 @@ class BaseMixin(SatisfiesMixin):
                 )
         else:
             if _guarded_not_equal(self.val, other):
-                actual_repr, expected_repr = _disambiguated(self.val, other)
+                if _both_list_like(self.val, other):
+                    actual_repr = _truncated(_elided_seq_repr(self.val, other))
+                    expected_repr = _truncated(_elided_seq_repr(other, self.val))
+                else:
+                    actual_repr, expected_repr = _disambiguated(self.val, other)
                 diff = _build_equality_diff(self.val, other)
                 return self.error(
                     f"Expected <{actual_repr}> to be equal to <{expected_repr}>, but was not.",

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/contains.py

@@ -236,20 +236,23 @@ class ContainsMixin(_MixinBase):
         """
         if len(items) == 0:
             raise ValueError("one or more args must be given")
-        else:
-            extra = [item for item in self.val if item not in items]
+        extra = [item for item in self.val if item not in items]
+        missing = [item for item in items if item not in self.val]
+        if extra or missing:
+            # both halves at once: reporting only the extras sends the reader to fix one problem and
+            # rerun into the other, and the message wording of each half alone is unchanged
+            faults = []
+            entries = []
             if extra:
-                return self.error(
-                    f"Expected <{self.val}> to contain only {self._fmt_items(items)},"
-                    f" but did contain {self._fmt_items(extra)}."
-                )
-
-            missing = [item for item in items if item not in self.val]
+                faults.append(f"did contain {self._fmt_items(extra)}")
+                entries += [DiffEntry(path="extra", actual=item, expected=None) for item in extra]
             if missing:
-                return self.error(
-                    f"Expected <{self.val}> to contain only {self._fmt_items(items)},"
-                    f" but did not contain {self._fmt_items(missing)}."
-                )
+                faults.append(f"did not contain {self._fmt_items(missing)}")
+                entries += [DiffEntry(path="missing", actual=None, expected=item) for item in missing]
+            return self.error(
+                f"Expected <{self.val}> to contain only {self._fmt_items(items)}, but {' and '.join(faults)}.",
+                diff=DiffResult(kind="contains", entries=entries),
+            )
         return self
 
     def contains_sequence(self, *items: object) -> Self:
@@ -425,13 +428,23 @@ class ContainsMixin(_MixinBase):
             val_list = list(self.val)
         except TypeError:
             raise TypeError("val is not iterable") from None
-        if val_list != list(items):
-            entries = _multiset_diff_entries(val_list, list(items))
-            diff = DiffResult(kind="contains", entries=entries) if entries else None
-            return self.error(
-                f"Expected <{self.val}> to contain exactly {self._fmt_items(items)}, but did not.",
-                diff=diff,
-            )
+        expected_list = list(items)
+        if val_list != expected_list:
+            message = f"Expected <{self.val}> to contain exactly {self._fmt_items(items)}, but did not."
+            entries = _multiset_diff_entries(val_list, expected_list)
+            if entries:
+                diff = DiffResult(kind="contains", entries=entries)
+            else:
+                # equal multisets, so only the order differs: name the first position that disagrees,
+                # which is the one the reader has to look at anyway
+                pairs = enumerate(zip(val_list, expected_list, strict=True))  # equal multisets, equal lengths
+                index = next(i for i, (found, wanted) in pairs if found != wanted)
+                message += f" Same items, but the order differs at index {index}."
+                diff = DiffResult(
+                    kind="sequence",
+                    entries=[DiffEntry(path=f"[{index}]", actual=val_list[index], expected=expected_list[index])],
+                )
+            return self.error(message, diff=diff)
         return self
 
     def contains_exactly_in_any_order(self, *items: object) -> Self:

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/errors.py

@@ -138,7 +138,7 @@ def _append_string_entry(lines: list[str], entry: DiffEntry, *, red: str, green:
         return
     actual_line, expected_line = _safe_str(entry.actual), _safe_str(entry.expected)
     lines.append(f"  {entry.path}:")
-    # ndiff is O(len_a * len_b); on long lines skip the carets and show a plain pair instead
+    # ndiff costs ~175x a plain pair even at the cutoff; on long lines skip the carets instead
     if len(actual_line) <= 200 and len(expected_line) <= 200:
         for guide in difflib.ndiff([actual_line], [expected_line]):
             text = guide.rstrip("\n")

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/extracting.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import collections.abc
+import difflib
 import inspect
 from typing import TYPE_CHECKING
 
@@ -13,6 +14,21 @@ if TYPE_CHECKING:
 __tracebackhide__ = True
 
 
+_OURS = "_assertpy2_extracting"
+
+
+def _extraction_error(message: str) -> ValueError:
+    """A ``ValueError`` tagged as this module's own.
+
+    The localization wrapper re-raises only tagged errors, so a ``ValueError`` raised by user code (a
+    property that fails, say) keeps its own traceback instead of being swallowed. The visible type
+    stays ``ValueError``, exactly as before.
+    """
+    error = ValueError(message)
+    setattr(error, _OURS, True)
+    return error
+
+
 class ExtractingMixin(_MixinBase):
     """Collection flattening mixin.
 
@@ -152,7 +168,7 @@ class ExtractingMixin(_MixinBase):
             try:
                 inspect.signature(attr).bind()
             except TypeError:  # the callable needs arguments, so it is not a zero-arg method
-                raise ValueError(f"item method <{name}()> exists, but is not zero-arg method") from None
+                raise _extraction_error(f"item method <{name}()> exists, but is not zero-arg method") from None
             except ValueError:  # some builtins expose no introspectable signature; fall back to calling
                 pass
             return attr()  # a TypeError from here comes from the method body, not an arity mismatch
@@ -161,19 +177,34 @@ class ExtractingMixin(_MixinBase):
             if self._is_dict_like(item, check_values=False):
                 if name in item:
                     return item[name]
-                raise ValueError(f"item keys {list(item.keys())} did not contain key <{name}>")
+                raise _extraction_error(f"item keys {list(item.keys())} did not contain key <{name}>")
             if is_namedtuple(item) and type(name) is str:
                 if name in item._fields:
                     return getattr(item, name)
                 if hasattr(item, name):  # a property or zero-arg method on the NamedTuple subclass
                     return _attr_value(item, name)
-                raise ValueError(f"item attributes {item._fields} did not contain attribute <{name}>")
+                raise _extraction_error(f"item attributes {item._fields} did not contain attribute <{name}>")
             if isinstance(item, collections.abc.Iterable) and not is_model_dump_object(item):
                 self._check_iterable(item, name="item")
                 return item[name]
-            if hasattr(item, name):
+            try:
                 return _attr_value(item, name)
-            raise ValueError(f"item does not have property or zero-arg method <{name}>")
+            except AttributeError as exc:
+                # hasattr() reports a raising accessor as a missing one, so telling the two apart is the
+                # difference between "you typed the wrong name" and "your property is broken"
+                if hasattr(type(item), name):
+                    raise _extraction_error(
+                        f"item has property or zero-arg method <{name}>, but reading it raised AttributeError: {exc}"
+                    ) from exc
+                try:
+                    available = sorted(attr for attr in dir(item) if not attr.startswith("_"))
+                except Exception:  # a broken __dir__ must not replace the real diagnostic with its own
+                    available = []
+                # one suggestion, not a list: measured typos score ~0.9 while wrong neighbours sit at
+                # ~0.65, so extra candidates are noise that costs the hint its credibility
+                close = difflib.get_close_matches(str(name), available, n=1)
+                hint = f"; did you mean {close[0]!r}?" if close else ""
+                raise _extraction_error(f"item does not have property or zero-arg method <{name}>{hint}") from None
 
         def _filter(item):
             if "filter" in kwargs:
@@ -208,9 +239,15 @@ class ExtractingMixin(_MixinBase):
         # only pay the sort when a sort key was actually requested; otherwise iteration order is unchanged
         source = sorted(self.val, key=_sort) if "sort" in kwargs else self.val
         extracted = []
-        for item in source:
+        for index, item in enumerate(source):
             if _filter(item):
-                extracted_values = [_extract(item, name) for name in names]
+                try:
+                    extracted_values = [_extract(item, name) for name in names]
+                except ValueError as exc:
+                    if not getattr(exc, _OURS, False):
+                        raise
+                    localized = f"{exc} (at index {index}, item is <{type(item).__name__}>)"
+                    raise _extraction_error(localized) from exc.__cause__
                 extracted.append(tuple(extracted_values) if len(extracted_values) > 1 else extracted_values[0])
 
         # chain on with _extracted_ list (don't chain to self!)

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/helpers.py

@@ -20,6 +20,96 @@ from ._engine._mixin_base import _MixinBase
 __tracebackhide__ = True
 
 
+def _values_not_equal(value: object, other_value: object, config: _CompareConfig | None) -> bool:
+    """Whether two non-mapping values differ, delegating to the shared structural walker.
+
+    Asking `_sub_diff_entries` keeps the equality *decision* and the rendered *diff* in agreement: every
+    shape it can decompose (dataclass, attrs, namedtuple, model, sequence) is then compared under the
+    compare config, instead of falling back to plain equality and silently dropping that config.
+    Without a config there is nothing to honour, so the plain check is kept exactly as it was.
+    """
+    if value is other_value:
+        return False  # identity first, the way Python's own container comparison short-circuits
+    if config is None:
+        return _guarded_not_equal(value, other_value)
+    entries = _sub_diff_entries(value, other_value, "", config=config)
+    if entries is None:  # a leaf the walker does not decompose
+        return _guarded_not_equal(value, other_value)
+    return bool(entries)
+
+
+def _both_list_like(left: object, right: object) -> bool:
+    """Whether both values are plain sequences, so they compare element-by-element.
+
+    Namedtuples are excluded on purpose: they carry field names and are compared field-wise.
+    """
+    return (
+        isinstance(left, (list, tuple))
+        and isinstance(right, (list, tuple))
+        and not is_namedtuple(left)
+        and not is_namedtuple(right)
+    )
+
+
+def _joined_parts(parts: list[str], *, elided: bool, opener: str = "", closer: str = "") -> str:
+    """Assemble a collapsed repr, capping how many differing parts are spelled out.
+
+    Collapsing only removes what matched, so a value where nearly everything differs still prints in
+    full. The cap is what keeps that case from becoming a wall of text on one line.
+    """
+    hidden = len(parts) - 5
+    if hidden > 0:
+        parts = [*parts[:5], f"... and {hidden} more"]
+    prefix = ".." if elided and not parts else ".., " if elided else ""
+    return f"{opener}{prefix}{', '.join(parts)}{closer}"
+
+
+def _elided_text_repr(text: str, counterpart: str) -> str:
+    """Collapse lines equal to their counterpart into ``..`` so only the changed ones are printed.
+
+    Mirrors `_elided_seq_repr` for multi-line values: a one-line change in a long block should not put
+    the whole block into the message twice.
+    """
+    # the cost of a multi-line value is vertical: every line takes a terminal row, and the message
+    # prints the value twice. Character budgets miss that, so this one counts rows.
+    if len(text.splitlines()) <= 3:
+        return text
+    other_lines = counterpart.splitlines()
+    parts = []
+    elided = False
+    for index, line in enumerate(text.splitlines()):
+        if index < len(other_lines) and line == other_lines[index]:
+            elided = True
+            continue
+        parts.append(f"line {index + 1}: {line}")
+    return _joined_parts(parts, elided=elided)
+
+
+def _elided_seq_repr(seq, counterpart) -> str:
+    """Collapse elements equal to their counterpart into ``..`` so only the differing ones are printed.
+
+    A one-element change in a forty-element list reads as ``[.., 999]`` instead of dumping the list
+    twice into a message the reader then has to diff by eye.
+    """
+    # past 20 elements the rendering is over budget by construction (one char each plus separators), so
+    # the value is never rendered just to be measured: on the failure path that render is the whole value
+    if len(seq) <= 20:
+        rendered = _safe_repr(seq)
+        if len(rendered) <= 60:
+            # short enough to read whole: collapsing it would hide context to save a few characters, and
+            # on a two-element list the ".." form is actually the longer of the two
+            return rendered
+    parts = []
+    elided = False
+    for index, value in enumerate(seq):
+        if index < len(counterpart) and not _guarded_not_equal(value, counterpart[index]):
+            elided = True
+            continue
+        parts.append(_safe_repr(value))
+    opener, closer = ("(", ")") if isinstance(seq, tuple) else ("[", "]")
+    return _joined_parts(parts, elided=elided, opener=opener, closer=closer)
+
+
 class HelpersMixin(_MixinBase):
     """Helpers mixin.  For internal use only."""
 
@@ -201,24 +291,20 @@ class HelpersMixin(_MixinBase):
                     continue
                 if decision == "leaf":
                     return True
+            nested_ignore = (
+                [entry[1:] for entry in ignores if type(entry) is tuple and entry[0] == key] if ignore else None
+            )
+            nested_include = (
+                [entry[1:] for entry in self._dict_ignore(include) if type(entry) is tuple and entry[0] == key]
+                if include
+                else None
+            )
             if self._is_dict_like(val[key], check_values=False) and self._is_dict_like(other[key], check_values=False):
-                subdicts_not_equal = self._dict_not_equal(
-                    val[key],
-                    other[key],
-                    ignore=[entry[1:] for entry in ignores if type(entry) is tuple and entry[0] == key]
-                    if ignore
-                    else None,
-                    include=[
-                        entry[1:] for entry in self._dict_ignore(include) if type(entry) is tuple and entry[0] == key
-                    ]
-                    if include
-                    else None,
-                    config=config,
-                    _seen=_seen,
-                )
-                if subdicts_not_equal:
+                if self._dict_not_equal(
+                    val[key], other[key], ignore=nested_ignore, include=nested_include, config=config, _seen=_seen
+                ):
                     return True
-            elif _guarded_not_equal(val[key], other[key]):
+            elif _values_not_equal(val[key], other[key], config):
                 return True
         return False
 
@@ -301,17 +387,7 @@ class HelpersMixin(_MixinBase):
                         else:
                             value_repr = _safe_repr(value)
                         parts.append(f"{_safe_repr(key)}: {value_repr}")
-            out = ", ".join(parts)
-            ellip_prefix = ".." if ellip and not parts else ".., " if ellip else ""
-            return f"{{{ellip_prefix}{out}}}"
-
-        def _both_list_like(left, right):
-            return (
-                isinstance(left, (list, tuple))
-                and isinstance(right, (list, tuple))
-                and not is_namedtuple(left)
-                and not is_namedtuple(right)
-            )
+            return _joined_parts(parts, elided=ellip, opener="{", closer="}")
 
         def _list_repr(seq, counterpart, _seen):
             """List counterpart of ``_dict_repr``: collapse equal elements to ``..`` and drill only into
@@ -342,8 +418,7 @@ class HelpersMixin(_MixinBase):
                 else:
                     parts.append(_safe_repr(value))
             opener, closer = ("(", ")") if isinstance(seq, tuple) else ("[", "]")  # keep tuples looking like tuples
-            ellip_prefix = ".." if ellip and not parts else ".., " if ellip else ""
-            return f"{opener}{ellip_prefix}{', '.join(parts)}{closer}"
+            return _joined_parts(parts, elided=ellip, opener=opener, closer=closer)
 
         ignore_err = include_err = ""
         if ignore:

{assertpy2-2.16.0 → assertpy2-2.17.0}/assertpy2/json_mixin.py

@@ -33,21 +33,22 @@ def _ensure_jsonschema():
     return jsonschema
 
 
-def _openapi_nullable_to_null(node: Any) -> Any:
+def _openapi_nullable_to_null(node: Any, keyword: str = "nullable") -> Any:
     """Rewrite OpenAPI 3.0 ``nullable: true`` into standard JSON Schema (jsonschema ignores it).
 
     For the common scalar-typed field, ``"null"`` is added to ``type`` (and to ``enum`` if present),
     which keeps per-keyword error paths precise - a bad ``format``/``type`` on a nullable field still
     reports ``format``/``type``, not a vague union. Only a nullable schema with no scalar ``type``
-    (nullable beside ``$ref``/``oneOf``) falls back to an ``anyOf`` null union.
+    (nullable beside ``$ref``/``oneOf``) falls back to an ``anyOf`` null union. Swagger 2.0 spells the
+    same idea ``x-nullable``, so it is handled by passing ``keyword="x-nullable"``.
     """
     if isinstance(node, dict):
-        rewritten = {key: _openapi_nullable_to_null(value) for key, value in node.items()}
-        nullable = rewritten.get("nullable")
+        rewritten = {key: _openapi_nullable_to_null(value, keyword) for key, value in node.items()}
+        nullable = rewritten.get(keyword)
         if not isinstance(nullable, bool):
-            # a non-boolean "nullable" is a property literally named "nullable", not the OpenAPI keyword
+            # a non-boolean value is a property literally named that, not the OpenAPI nullable keyword
             return rewritten
-        del rewritten["nullable"]
+        del rewritten[keyword]
         if not nullable:  # nullable: false - drop the keyword, add no null
             return rewritten
         node_type = rewritten.get("type")
@@ -59,7 +60,7 @@ def _openapi_nullable_to_null(node: Any) -> Any:
             return rewritten
         return {"anyOf": [rewritten, {"type": "null"}]}
     if isinstance(node, list):
-        return [_openapi_nullable_to_null(item) for item in node]
+        return [_openapi_nullable_to_null(item, keyword) for item in node]
     return node
 
 
@@ -98,7 +99,8 @@ def _openapi_resolve(spec: dict[str, Any], path: str, method: str, status: str |
     """
     method_key = method.lower()
     try:
-        responses = spec["paths"][path][method_key]["responses"]
+        operation = spec["paths"][path][method_key]
+        responses = operation["responses"]
     except (KeyError, TypeError):
         raise ValueError(f"OpenAPI spec has no operation <{method.upper()} {path}>.") from None
     if status is not None:
@@ -116,10 +118,25 @@ def _openapi_resolve(spec: dict[str, Any], path: str, method: str, status: str |
         response, response_segments = _resolve_local_ref(spec, response["$ref"])
         if response is None:
             raise ValueError(f"Response <{status_key}> of <{method.upper()} {path}> has an unresolvable $ref.")
-    content = response.get("content", {}) if isinstance(response, dict) else {}
-    if content_type not in content or "schema" not in content[content_type]:
-        raise ValueError(f"Response <{status_key}> of <{method.upper()} {path}> declares no <{content_type}> schema.")
-    segments = [*response_segments, "content", content_type, "schema"]
+    if str(spec.get("swagger", "")).startswith("2"):
+        # Swagger 2.0 puts the response-body schema directly under the response, with no content-type
+        # layer, and lists the media types in `produces` instead. Check that list so a content_type the
+        # operation does not produce is rejected here, exactly as the 3.x content lookup rejects it.
+        produces = operation.get("produces") or spec.get("produces")
+        if produces and content_type not in produces:
+            raise ValueError(
+                f"Response <{status_key}> of <{method.upper()} {path}> declares no <{content_type}> schema."
+            )
+        if not (isinstance(response, dict) and "schema" in response):
+            raise ValueError(f"Response <{status_key}> of <{method.upper()} {path}> declares no schema.")
+        segments = [*response_segments, "schema"]
+    else:
+        content = response.get("content", {}) if isinstance(response, dict) else {}
+        if content_type not in content or "schema" not in content[content_type]:
+            raise ValueError(
+                f"Response <{status_key}> of <{method.upper()} {path}> declares no <{content_type}> schema."
+            )
+        segments = [*response_segments, "content", content_type, "schema"]
     pointer = "#/" + "/".join(segment.replace("~", "~0").replace("/", "~1") for segment in segments)
     return status_key, pointer
 
@@ -287,7 +304,8 @@ class JsonMixin(_MixinBase):
         ``method``/``path`` operation in ``spec``. This checks only the response body of that one
         operation - not request bodies, parameters, headers, or the spec as a whole.
 
-        Both OpenAPI 3.0 (its ``nullable`` keyword is honoured) and 3.1 are supported. ``$ref``,
+        OpenAPI 3.0 (its ``nullable`` keyword is honoured), 3.1, and Swagger 2.0 (schema declared directly
+        on the response, its ``x-nullable`` extension honoured) are all supported. ``$ref``,
         ``oneOf``/``allOf``/``anyOf``, ``enum``, and ``format`` all validate with full JSON-Schema
         semantics, and every violation is reported with its JSON path.
 
@@ -297,7 +315,9 @@ class JsonMixin(_MixinBase):
             method: the HTTP method, e.g. ``"get"`` (case-insensitive).
             status: response status to validate against; defaults to ``200``, then ``201``, then
                 ``default``.
-            content_type: response content type; defaults to ``"application/json"``.
+            content_type: response content type; defaults to ``"application/json"``. Swagger 2.0 has no
+                content-type layer, so it is checked against the operation's ``produces`` list instead
+                (and skipped when the spec declares none).
 
         Examples:
             Usage:
@@ -318,8 +338,12 @@ class JsonMixin(_MixinBase):
 
         spec = _stringify_keys(spec)  # YAML may parse numeric-looking keys (e.g. status 200) as ints
         is_openapi_31 = str(spec.get("openapi", "")).startswith("3.1")
+        is_swagger_2 = str(spec.get("swagger", "")).startswith("2")
         status_key, pointer = _openapi_resolve(spec, path, method, status, content_type)
-        document = spec if is_openapi_31 else _openapi_nullable_to_null(spec)
+        if is_openapi_31:
+            document = spec  # 3.1 is JSON Schema 2020-12 already, no nullable rewrite
+        else:
+            document = _openapi_nullable_to_null(spec, "x-nullable" if is_swagger_2 else "nullable")
         specification = DRAFT202012 if is_openapi_31 else DRAFT4
         validator_cls = jsonschema_mod.Draft202012Validator if is_openapi_31 else jsonschema_mod.Draft4Validator
 

{assertpy2-2.16.0 → assertpy2-2.17.0}/benchmarks/test_perf.py

@@ -80,3 +80,44 @@ def test_contains_exactly_large(benchmark):
     # the contains engine: exact membership over a sizeable list
     items = list(range(300))
     benchmark(lambda: assert_that(items).contains_exactly(*items))
+
+
+def test_string_diff_with_carets(benchmark):
+    # difflib.ndiff costs ~175x a plain pair of prints, and is guarded by a length cutoff. Rendering is
+    # lazy, so str() has to be called or the carets never run and the benchmark guards nothing.
+    left = "the quick brown fox jumps over the lazy dog " * 3
+    right = left.replace("brown", "brawn", 1)
+
+    def run():
+        try:
+            assert_that(left).is_equal_to(right)
+        except AssertionFailure as failure:
+            return str(failure)
+        return None
+
+    benchmark(run)
+
+
+def test_wide_dict_diff(benchmark):
+    # _dict_repr over a wide mapping where nearly every key differs, so there is little to collapse and
+    # every entry is rendered. (The cap on how many are named is free at runtime, so nothing guards it.)
+    left = {f"k{i}": i for i in range(200)}
+    right = {f"k{i}": -i for i in range(200)}
+
+    def run():
+        with contextlib.suppress(AssertionFailure):
+            assert_that(left).is_equal_to(right)
+
+    benchmark(run)
+
+
+def test_extracting_large(benchmark):
+    # the success path of the collection pipeline, the common shape of an API assertion
+    records = _records(300)
+    benchmark(lambda: assert_that(records).extracting("id", "name").is_not_empty())
+
+
+def test_contains_only_large(benchmark):
+    # membership both ways over a sizeable list, the multiset engine rather than the ordered one
+    items = list(range(300))
+    benchmark(lambda: assert_that(items).contains_only(*items))