assertpy2 2.3.6__tar.gz → 2.3.7__tar.gz

{assertpy2-2.3.6 → assertpy2-2.3.7}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.6
+Version: 2.3.7
 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
 Project-URL: Issues, https://github.com/Solganis/assertpy2/issues
 Author-email: Justin Shacklette <justin@saturnboy.com>
-Maintainer: Solganis
+Maintainer-email: Solganis <solganis.dev@gmail.com>
 License-Expression: BSD-3-Clause
 License-File: LICENSE
 Keywords: assert,assert_that,assertion,assertthat,pytest,test,testing,unittest
@@ -31,6 +31,9 @@ Provides-Extra: allure
 Requires-Dist: allure-pytest>=2.13; extra == 'allure'
 Provides-Extra: behave
 Requires-Dist: behave>=1.2.6; extra == 'behave'
+Provides-Extra: json
+Requires-Dist: jsonpath-ng>=1.8; extra == 'json'
+Requires-Dist: jsonschema>=4.0; extra == 'json'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -43,7 +46,7 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <b>Fluent assertion library for Python with composable matchers, structural matching, and full type safety.</b><br>
-  Maintained fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
+  A modern, batteries-included fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
 </p>
 
 <p align="center">
@@ -168,7 +171,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`. Group errors with `sa.group()`, or use `assert_all()` for inline checks.
+- [**JSON assertions**](docs/api.md#json-path--schema-validation): JSONPath navigation (`at_json_path`, `has_json_path`) and JSON Schema validation (`matches_json_schema`).
 - [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
 - [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
 - [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
@@ -352,6 +356,36 @@ assert_that(items).filtered_on(match.is_positive()).mapped(str).contains("1")
 
 Available methods: `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
 
+### Grouped soft assertions
+
+```py
+with soft_assertions() as sa:
+    with sa.group("Headers"):
+        assert_that(headers["Content-Type"]).is_equal_to("application/json")
+    with sa.group("Body"):
+        assert_that(body["status"]).is_equal_to("ok")
+        assert_that(body["items"]).is_not_empty()
+
+# or inline with assert_all
+assert_all(
+    lambda: assert_that(x).is_positive(),
+    lambda: assert_that(y).is_not_none(),
+)
+```
+
+### JSON path and schema validation
+
+Requires `pip install assertpy2[json]`.
+
+```py
+data = {"users": [{"name": "Alice"}, {"name": "Bob"}], "meta": {"total": 2}}
+
+assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+assert_that(data).has_json_path("$.meta.total")
+assert_that(data).does_not_have_json_path("$.error")
+assert_that(data).matches_json_schema({"type": "object", "required": ["users"]})
+```
+
 ### Dict comparison with ignore/include
 
 ```py

{assertpy2-2.3.6 → assertpy2-2.3.7}/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <b>Fluent assertion library for Python with composable matchers, structural matching, and full type safety.</b><br>
-  Maintained fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
+  A modern, batteries-included fork of <a href="https://github.com/assertpy/assertpy">assertpy</a>.
 </p>
 
 <p align="center">
@@ -133,7 +133,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`. Group errors with `sa.group()`, or use `assert_all()` for inline checks.
+- [**JSON assertions**](docs/api.md#json-path--schema-validation): JSONPath navigation (`at_json_path`, `has_json_path`) and JSON Schema validation (`matches_json_schema`).
 - [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
 - [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
 - [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
@@ -317,6 +318,36 @@ assert_that(items).filtered_on(match.is_positive()).mapped(str).contains("1")
 
 Available methods: `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
 
+### Grouped soft assertions
+
+```py
+with soft_assertions() as sa:
+    with sa.group("Headers"):
+        assert_that(headers["Content-Type"]).is_equal_to("application/json")
+    with sa.group("Body"):
+        assert_that(body["status"]).is_equal_to("ok")
+        assert_that(body["items"]).is_not_empty()
+
+# or inline with assert_all
+assert_all(
+    lambda: assert_that(x).is_positive(),
+    lambda: assert_that(y).is_not_none(),
+)
+```
+
+### JSON path and schema validation
+
+Requires `pip install assertpy2[json]`.
+
+```py
+data = {"users": [{"name": "Alice"}, {"name": "Bob"}], "meta": {"total": 2}}
+
+assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+assert_that(data).has_json_path("$.meta.total")
+assert_that(data).does_not_have_json_path("$.error")
+assert_that(data).matches_json_schema({"type": "object", "required": ["users"]})
+```
+
 ### Dict comparison with ignore/include
 
 ```py

{assertpy2-2.3.6 → assertpy2-2.3.7}/assertpy2/__init__.py

@@ -1,8 +1,10 @@
 from .assertpy import (
     NegatedBuilder,
+    SoftAssertionCollector,
     WarningLoggingAdapter,
     __version__,
     add_extension,
+    assert_all,
     assert_that,
     assert_warn,
     fail,
@@ -22,9 +24,11 @@ __all__ = [
     "DiffResult",
     "Matcher",
     "NegatedBuilder",
+    "SoftAssertionCollector",
     "WarningLoggingAdapter",
     "__version__",
     "add_extension",
+    "assert_all",
     "assert_that",
     "assert_warn",
     "clear_custom_matchers",

{assertpy2-2.3.6 → assertpy2-2.3.7}/assertpy2/_typing.py

@@ -4,7 +4,8 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from collections.abc import Callable
-    from typing import Protocol
+    from pathlib import Path
+    from typing import Any, Protocol
 
     from typing_extensions import Self
 
@@ -141,6 +142,12 @@ if TYPE_CHECKING:
         def last(self) -> Self: ...
         def element(self, index: int) -> Self: ...
         def single(self) -> Self: ...
+        # JsonMixin
+        def at_json_path(self, path: str) -> Self: ...
+        def has_json_path(self, path: str) -> Self: ...
+        def does_not_have_json_path(self, path: str) -> Self: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
 
     class _DictAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``dict`` values."""
@@ -162,6 +169,12 @@ if TYPE_CHECKING:
         def each(self, matcher: Matcher | Callable[..., bool]) -> Self: ...
         # ExtractingMixin
         def extracting(self, *names: object, **kwargs: object) -> Self: ...
+        # JsonMixin
+        def at_json_path(self, path: str) -> Self: ...
+        def has_json_path(self, path: str) -> Self: ...
+        def does_not_have_json_path(self, path: str) -> Self: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
 
     class _DateAssertion(_CoreAssertion, Protocol):
         """Assertions available for ``datetime.date`` and ``datetime.datetime`` values."""

{assertpy2-2.3.6 → assertpy2-2.3.7}/assertpy2/assertpy.py

@@ -40,11 +40,12 @@ from .exception import ExceptionMixin
 from .extracting import ExtractingMixin
 from .file import FileMixin
 from .helpers import HelpersMixin
+from .json_mixin import JsonMixin
 from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.3.6"
+__version__ = "2.3.7"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -66,6 +67,7 @@ ASSERTPY_FILES = [
         "extracting.py",
         "file.py",
         "helpers.py",
+        "json_mixin.py",
         "matchers.py",
         "numeric.py",
         "pytest_plugin.py",
@@ -76,11 +78,52 @@ ASSERTPY_FILES = [
 
 # soft assertions (contextvars for thread/async safety)
 _soft_ctx: contextvars.ContextVar[int] = contextvars.ContextVar("assertpy2_soft_ctx", default=0)
-_soft_err: contextvars.ContextVar[list[str]] = contextvars.ContextVar("assertpy2_soft_err")
+_soft_err: contextvars.ContextVar[list[tuple[str | None, str]]] = contextvars.ContextVar("assertpy2_soft_err")
+_soft_group: contextvars.ContextVar[str | None] = contextvars.ContextVar("assertpy2_soft_group", default=None)
+
+
+class SoftAssertionCollector:
+    """Collector returned by :func:`soft_assertions` for grouping errors hierarchically."""
+
+    @contextlib.contextmanager
+    def group(self, label: str) -> Iterator[None]:
+        """Group subsequent assertion failures under *label*.
+
+        Examples:
+            Usage::
+
+                with soft_assertions() as sa:
+                    with sa.group("Headers"):
+                        assert_that(headers).contains_key("Content-Type")
+                    with sa.group("Body"):
+                        assert_that(body["status"]).is_equal_to("ok")
+        """
+        token = _soft_group.set(label)
+        try:
+            yield
+        finally:
+            _soft_group.reset(token)
+
+
+def _format_soft_errors(errs: list[tuple[str | None, str]]) -> str:
+    has_groups = any(group is not None for group, _ in errs)
+    if not has_groups:
+        return "soft assertion failures:\n" + "\n".join(f"{i + 1}. {msg}" for i, (_, msg) in enumerate(errs))
+
+    lines = ["soft assertion failures:"]
+    current_group: str | None = object()  # ty: ignore[invalid-assignment]  # sentinel
+    for counter, (group, msg) in enumerate(errs, 1):
+        if group != current_group:
+            current_group = group
+            if group is not None:
+                lines.append(f"  [{group}]")
+        indent = "    " if group is not None else "  "
+        lines.append(f"{indent}{counter}. {msg}")
+    return "\n".join(lines)
 
 
 @contextlib.contextmanager
-def soft_assertions() -> Iterator[None]:
+def soft_assertions() -> Iterator[SoftAssertionCollector]:
     """Create a soft assertion context.
 
     Normally, any assertion failure will halt test execution immediately by raising an error.
@@ -112,6 +155,14 @@ def soft_assertions() -> Iterator[None]:
             4. Expected <foo> to contain only digits, but did not.
             5. Expected <123> to contain only alphabetic chars, but did not.
 
+        Group errors by section::
+
+            with soft_assertions() as sa:
+                with sa.group("Headers"):
+                    assert_that(headers["Content-Type"]).is_equal_to("application/json")
+                with sa.group("Body"):
+                    assert_that(body["status"]).is_equal_to("ok")
+
     Note:
         The soft assertion context only collects *assertion* failures, other errors such as
         ``TypeError`` or ``ValueError`` are always raised immediately.  Triggering an explicit test
@@ -125,17 +176,40 @@ def soft_assertions() -> Iterator[None]:
     _soft_ctx.set(ctx + 1)
 
     try:
-        yield
+        yield SoftAssertionCollector()
     finally:
         _soft_ctx.set(_soft_ctx.get() - 1)
 
     errs = _soft_err.get([])
     if errs and _soft_ctx.get() == 0:
-        out = "soft assertion failures:\n" + "\n".join(f"{i + 1}. {msg}" for i, msg in enumerate(errs))
+        out = _format_soft_errors(errs)
         _soft_err.set([])
         raise AssertionError(out)
 
 
+def assert_all(*callables: Callable[[], object]) -> None:
+    """Run all callables inside a soft assertion context.
+
+    A convenience wrapper around :func:`soft_assertions` for inline use.
+
+    Examples:
+        Usage::
+
+            from assertpy2 import assert_all, assert_that
+
+            assert_all(
+                lambda: assert_that(x).is_positive(),
+                lambda: assert_that(y).is_not_none(),
+            )
+
+    Raises:
+        AssertionError: if any of the callables produce assertion failures
+    """
+    with soft_assertions():
+        for fn in callables:
+            fn()
+
+
 # factory methods
 
 
@@ -303,7 +377,7 @@ def soft_fail(msg=""):
 
     """
     if _soft_ctx.get():
-        _soft_err.get().append(f"Fail: {msg}!" if msg else "Fail!")
+        _soft_err.get().append((_soft_group.get(), f"Fail: {msg}!" if msg else "Fail!"))
         return
     fail(msg)
 
@@ -449,7 +523,7 @@ class NegatedBuilder:
         if len(err_list) > before:
             del err_list[before:]
             return self._builder
-        err_list.append(self._make_msg(name))
+        err_list.append((_soft_group.get(), self._make_msg(name)))
         return self._builder
 
     def _negated_warn(
@@ -470,6 +544,7 @@ class AssertionBuilder(
     StringMixin,
     SnapshotMixin,
     NumericMixin,
+    JsonMixin,
     HelpersMixin,
     FileMixin,
     ExtractingMixin,
@@ -550,7 +625,7 @@ class AssertionBuilder(
             self.logger.warning(out)
             return self
         elif self.kind == "soft":
-            _soft_err.get().append(out)
+            _soft_err.get().append((_soft_group.get(), out))
             return self
         else:
             if expected is not None or diff is not None:

assertpy2-2.3.7/assertpy2/json_mixin.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ._mixin_base import _MixinBase
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+__tracebackhide__ = True
+
+
+def _ensure_jsonpath_ng():
+    try:
+        import jsonpath_ng.ext  # optional dependency
+    except ImportError:
+        raise ImportError(
+            "jsonpath-ng is required for JSON path assertions. Install it with: pip install assertpy2[json]"
+        ) from None
+    return jsonpath_ng.ext
+
+
+def _ensure_jsonschema():
+    try:
+        import jsonschema  # optional dependency
+    except ImportError:
+        raise ImportError(
+            "jsonschema is required for JSON schema assertions. Install it with: pip install assertpy2[json]"
+        ) from None
+    return jsonschema
+
+
+class JsonMixin(_MixinBase):
+    """JSON path navigation and schema validation mixin."""
+
+    def at_json_path(self, path: str) -> Self:
+        """Navigate to a JSON path and return a new builder with the matched value.
+
+        Uses JSONPath syntax (e.g. ``$.users[0].name``). If multiple matches are found,
+        the value is a list of all matches. If exactly one match is found, the value is
+        unwrapped from the list.
+
+        Args:
+            path: JSONPath expression.
+
+        Examples:
+            Usage::
+
+                data = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
+                assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+                assert_that(data).at_json_path("$.users[*].name").is_equal_to(["Alice", "Bob"])
+
+        Returns:
+            AssertionBuilder: a new instance with the extracted value
+
+        Raises:
+            ValueError: if no match is found at the given path
+        """
+        jsonpath_ng_ext = _ensure_jsonpath_ng()
+        expr = jsonpath_ng_ext.parse(path)
+        matches = expr.find(self.val)
+        if not matches:
+            raise ValueError(f"Expected JSON path <{path}> to exist, but it did not.")
+        if len(matches) == 1:
+            return self.builder(matches[0].value, self.description, self.kind)
+        return self.builder([m.value for m in matches], self.description, self.kind)
+
+    def has_json_path(self, path: str) -> Self:
+        """Assert that the given JSON path exists in val.
+
+        Args:
+            path: JSONPath expression.
+
+        Examples:
+            Usage::
+
+                data = {"meta": {"total": 5}}
+                assert_that(data).has_json_path("$.meta.total")
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if the path does not exist
+        """
+        jsonpath_ng_ext = _ensure_jsonpath_ng()
+        expr = jsonpath_ng_ext.parse(path)
+        matches = expr.find(self.val)
+        if not matches:
+            return self.error(f"Expected JSON path <{path}> to exist, but it did not.")
+        return self
+
+    def does_not_have_json_path(self, path: str) -> Self:
+        """Assert that the given JSON path does not exist in val.
+
+        Args:
+            path: JSONPath expression.
+
+        Examples:
+            Usage::
+
+                data = {"status": "ok"}
+                assert_that(data).does_not_have_json_path("$.error")
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if the path exists
+        """
+        jsonpath_ng_ext = _ensure_jsonpath_ng()
+        expr = jsonpath_ng_ext.parse(path)
+        matches = expr.find(self.val)
+        if matches:
+            return self.error(f"Expected JSON path <{path}> to not exist, but it did.")
+        return self
+
+    def matches_json_schema(self, schema: dict[str, Any]) -> Self:
+        """Assert that val conforms to the given JSON Schema.
+
+        Args:
+            schema: a JSON Schema as a dict.
+
+        Examples:
+            Usage::
+
+                schema = {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
+                assert_that({"name": "Alice"}).matches_json_schema(schema)
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does not conform to the schema
+        """
+        jsonschema_mod = _ensure_jsonschema()
+        try:
+            jsonschema_mod.validate(self.val, schema)
+        except jsonschema_mod.ValidationError as exc:
+            return self.error(f"Expected val to match JSON schema, but validation failed: {exc.message}")
+        return self
+
+    def matches_json_schema_from_file(self, path: str | Path) -> Self:
+        """Assert that val conforms to a JSON Schema loaded from a file.
+
+        Args:
+            path: path to a JSON file containing the schema.
+
+        Examples:
+            Usage::
+
+                assert_that(data).matches_json_schema_from_file("schemas/order.json")
+
+        Returns:
+            AssertionBuilder: returns this instance to chain to the next assertion
+
+        Raises:
+            AssertionError: if val does not conform to the schema
+        """
+        schema = json.loads(Path(path).read_text(encoding="utf-8"))
+        return self.matches_json_schema(schema)

{assertpy2-2.3.6 → assertpy2-2.3.7}/docs/api.md

@@ -33,6 +33,8 @@ Full API reference for assertpy2. For a quick overview, see the [README](../READ
 - [Regex Group Extraction](#regex-group-extraction)
 - [Universal Negation](#universal-negation)
 - [Collection Pipeline](#collection-pipeline)
+- [Grouped Soft Assertions](#grouped-soft-assertions)
+- [JSON Path / Schema Validation](#json-path--schema-validation)
 - [Extension System](#extension-system---adding-custom-assertions)
 - [Chaining](#chaining)
 
@@ -1648,6 +1650,116 @@ assert_that(items).filtered_on(match.is_positive()).not_.is_empty()
 
 [Back to top](#table-of-contents)
 
+## Grouped Soft Assertions
+
+Use `soft_assertions() as sa` to get a collector, then `sa.group(label)` to group errors by section:
+
+```py
+from assertpy2 import assert_that, soft_assertions
+
+with soft_assertions() as sa:
+    with sa.group("Headers"):
+        assert_that(headers["Content-Type"]).is_equal_to("application/json")
+        assert_that(headers["Accept"]).contains("json")
+    with sa.group("Body"):
+        assert_that(body["status"]).is_equal_to("ok")
+        assert_that(body["items"]).is_not_empty()
+```
+
+Output with groups:
+
+```
+soft assertion failures:
+  [Headers]
+    1. Expected <text/html> to be equal to <application/json>, but was not.
+  [Body]
+    2. Expected <error> to be equal to <ok>, but was not.
+```
+
+Without `as sa` or without calling `sa.group()`, the behavior is unchanged (flat error list).
+
+### assert_all
+
+`assert_all()` is a convenience wrapper for inline soft assertions:
+
+```py
+from assertpy2 import assert_all, assert_that
+
+assert_all(
+    lambda: assert_that(x).is_positive(),
+    lambda: assert_that(y).is_not_none(),
+    lambda: assert_that(z).is_length(3),
+)
+```
+
+Equivalent to wrapping all calls in `with soft_assertions():`.
+
+[Back to top](#table-of-contents)
+
+## JSON Path / Schema Validation
+
+Navigate JSON structures with JSONPath and validate against JSON Schema.
+
+Requires optional dependencies:
+
+```bash
+pip install assertpy2[json]
+```
+
+### at_json_path
+
+Navigate to a JSONPath and continue asserting on the extracted value:
+
+```py
+data = {"users": [{"name": "Alice"}, {"name": "Bob"}], "meta": {"total": 2}}
+
+assert_that(data).at_json_path("$.meta.total").is_equal_to(2)
+assert_that(data).at_json_path("$.users[0].name").is_equal_to("Alice")
+assert_that(data).at_json_path("$.users[*].name").is_equal_to(["Alice", "Bob"])
+```
+
+Raises `ValueError` if the path does not exist.
+
+### has_json_path / does_not_have_json_path
+
+Assert that a JSONPath exists or does not exist:
+
+```py
+assert_that(data).has_json_path("$.meta.total")
+assert_that(data).does_not_have_json_path("$.error")
+```
+
+### matches_json_schema
+
+Validate against a JSON Schema dict:
+
+```py
+schema = {
+    "type": "object",
+    "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
+    "required": ["name"],
+}
+
+assert_that({"name": "Alice", "age": 30}).matches_json_schema(schema)
+```
+
+### matches_json_schema_from_file
+
+Load the schema from a JSON file:
+
+```py
+assert_that(data).matches_json_schema_from_file("schemas/user.json")
+```
+
+All JSON assertions work with soft assertions and chaining:
+
+```py
+with soft_assertions():
+    assert_that(response).has_json_path("$.data").at_json_path("$.data.id").is_positive()
+```
+
+[Back to top](#table-of-contents)
+
 ## Extension System - adding custom assertions
 
 Sometimes you want to add your own custom assertions to `assertpy2`.  This can be done using the `add_extension()` helper.

{assertpy2-2.3.6 → assertpy2-2.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.3.6"
+version = "2.3.7"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -9,7 +9,7 @@ authors = [
     { name = "Justin Shacklette", email = "justin@saturnboy.com" },
 ]
 maintainers = [
-    { name = "Solganis" },
+    { name = "Solganis", email = "solganis.dev@gmail.com" },
 ]
 keywords = ["test", "testing", "assert", "assertion", "assertthat", "assert_that", "pytest", "unittest"]
 classifiers = [
@@ -45,6 +45,7 @@ assertpy2 = "assertpy2.pytest_plugin"
 [project.optional-dependencies]
 allure = ["allure-pytest>=2.13"]
 behave = ["behave>=1.2.6"]
+json = ["jsonpath-ng>=1.8", "jsonschema>=4.0"]
 
 [build-system]
 requires = ["hatchling"]
@@ -52,7 +53,7 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
-    "pytest>=9.0.3",
+    "pytest>=9.1",
     "pytest-cov>=6.1",
     "ruff>=0.15.17",
     "ty>=0.0.49",