assertpy2 2.3.2__tar.gz → 2.3.3__tar.gz

{assertpy2-2.3.2 → assertpy2-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.2
+Version: 2.3.3
 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
@@ -52,9 +52,11 @@ Description-Content-Type: text/markdown
   <a href="https://pepy.tech/projects/assertpy2"><img src="https://static.pepy.tech/badge/assertpy2/month" alt="Downloads"></a>
   <a href="https://pypi.org/project/assertpy2/"><img src="https://img.shields.io/pypi/pyversions/assertpy2" alt="Python"></a>
   <a href="https://codecov.io/gh/Solganis/assertpy2"><img src="https://codecov.io/gh/Solganis/assertpy2/graph/badge.svg" alt="Coverage"></a>
+  <br>
+  <a href="https://github.com/Solganis/assertpy2/blob/main/docs/api.md"><img src="https://img.shields.io/badge/Docs-Read%20The%20Docs-black" alt="Documentation"></a>
   <a href="https://docs.astral.sh/ruff/"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff"></a>
   <a href="https://github.com/astral-sh/uv"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json" alt="uv"></a>
-  <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/badge/type--checker-ty-blue" alt="ty"></a>
+  <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>
 </p>
@@ -173,6 +175,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
 - **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
 - **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
 - **Extensions**: add custom assertions via `add_extension()`.
 - Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
 
@@ -348,6 +352,51 @@ assert_that(fred).has_shoe_size(12)
 assert_that({"a": 1, "b": 2, "c": 3}).snapshot()
 ```
 
+### Custom matchers
+
+Register domain-specific matchers on the `match` namespace with `register_matcher()`:
+
+```py
+from assertpy2 import assert_that, match, register_matcher
+
+@register_matcher("is_valid_email")
+def is_valid_email():
+    return match.matches_regex(r"^[\w.-]+@[\w.-]+\.\w+$")
+
+# parametrised matchers
+@register_matcher("has_status")
+def has_status(expected: str):
+    return match.has_property("status", match.equal_to(expected))
+
+# use everywhere matchers are accepted
+assert_that("alice@example.com").satisfies(match.is_valid_email())
+assert_that(users).extracting("email").each(match.is_valid_email())
+assert_that(data).matches_structure({"email": match.is_valid_email()})
+
+# composition works automatically
+assert_that(email).satisfies(match.is_valid_email() & match.contains_string("@company.com"))
+```
+
+Remove with `unregister_matcher("is_valid_email")`.
+
+### Regex group extraction
+
+Extract regex groups and continue the fluent chain:
+
+```py
+log = "2024-01-15 ERROR status=500 path=/api/users"
+
+# extract a positional group
+assert_that(log).extracting_group(r"status=(\d+)", 1).is_equal_to("500")
+
+# extract a named group
+assert_that(log).extracting_group(r"(?P<level>\w+) status", "level").is_equal_to("ERROR")
+
+# get all groups as a tuple or dict (named groups)
+assert_that("key=value").matches_with_groups(r"(?P<k>\w+)=(?P<v>\w+)") \
+    .contains_entry({"k": "key"}).contains_entry({"v": "value"})
+```
+
 ### Extensions
 
 ```py

{assertpy2-2.3.2 → assertpy2-2.3.3}/README.md

@@ -17,9 +17,11 @@
   <a href="https://pepy.tech/projects/assertpy2"><img src="https://static.pepy.tech/badge/assertpy2/month" alt="Downloads"></a>
   <a href="https://pypi.org/project/assertpy2/"><img src="https://img.shields.io/pypi/pyversions/assertpy2" alt="Python"></a>
   <a href="https://codecov.io/gh/Solganis/assertpy2"><img src="https://codecov.io/gh/Solganis/assertpy2/graph/badge.svg" alt="Coverage"></a>
+  <br>
+  <a href="https://github.com/Solganis/assertpy2/blob/main/docs/api.md"><img src="https://img.shields.io/badge/Docs-Read%20The%20Docs-black" alt="Documentation"></a>
   <a href="https://docs.astral.sh/ruff/"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff"></a>
   <a href="https://github.com/astral-sh/uv"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json" alt="uv"></a>
-  <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/badge/type--checker-ty-blue" alt="ty"></a>
+  <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>
 </p>
@@ -138,6 +140,8 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 - **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
 - **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
 - **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
 - **Extensions**: add custom assertions via `add_extension()`.
 - Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
 
@@ -313,6 +317,51 @@ assert_that(fred).has_shoe_size(12)
 assert_that({"a": 1, "b": 2, "c": 3}).snapshot()
 ```
 
+### Custom matchers
+
+Register domain-specific matchers on the `match` namespace with `register_matcher()`:
+
+```py
+from assertpy2 import assert_that, match, register_matcher
+
+@register_matcher("is_valid_email")
+def is_valid_email():
+    return match.matches_regex(r"^[\w.-]+@[\w.-]+\.\w+$")
+
+# parametrised matchers
+@register_matcher("has_status")
+def has_status(expected: str):
+    return match.has_property("status", match.equal_to(expected))
+
+# use everywhere matchers are accepted
+assert_that("alice@example.com").satisfies(match.is_valid_email())
+assert_that(users).extracting("email").each(match.is_valid_email())
+assert_that(data).matches_structure({"email": match.is_valid_email()})
+
+# composition works automatically
+assert_that(email).satisfies(match.is_valid_email() & match.contains_string("@company.com"))
+```
+
+Remove with `unregister_matcher("is_valid_email")`.
+
+### Regex group extraction
+
+Extract regex groups and continue the fluent chain:
+
+```py
+log = "2024-01-15 ERROR status=500 path=/api/users"
+
+# extract a positional group
+assert_that(log).extracting_group(r"status=(\d+)", 1).is_equal_to("500")
+
+# extract a named group
+assert_that(log).extracting_group(r"(?P<level>\w+) status", "level").is_equal_to("ERROR")
+
+# get all groups as a tuple or dict (named groups)
+assert_that("key=value").matches_with_groups(r"(?P<k>\w+)=(?P<v>\w+)") \
+    .contains_entry({"k": "key"}).contains_entry({"v": "value"})
+```
+
 ### Extensions
 
 ```py

{assertpy2-2.3.2 → assertpy2-2.3.3}/assertpy2/__init__.py

@@ -12,7 +12,7 @@ from .assertpy import (
 from .async_assertions import AsyncAssertionBuilder
 from .errors import AssertionFailure, DiffEntry, DiffResult
 from .file import contents_of
-from .matchers import Matcher, match
+from .matchers import Matcher, match, register_matcher, unregister_matcher
 
 __all__ = [
     "AssertionFailure",
@@ -28,7 +28,9 @@ __all__ = [
     "contents_of",
     "fail",
     "match",
+    "register_matcher",
     "remove_extension",
     "soft_assertions",
     "soft_fail",
+    "unregister_matcher",
 ]

{assertpy2-2.3.2 → assertpy2-2.3.3}/assertpy2/assertpy.py

@@ -73,7 +73,7 @@ from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.3.2"
+__version__ = "2.3.3"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch

{assertpy2-2.3.2 → assertpy2-2.3.3}/assertpy2/matchers.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 import uuid as _uuid_mod
+from collections.abc import Callable
 from typing import Any, Protocol, runtime_checkable
 
 
@@ -547,6 +548,65 @@ class StructureMatcher(BaseMatcher):
         return f"{{{', '.join(parts)}}}"
 
 
+# --- Custom matcher registry ---
+
+_custom_matchers: dict[str, Callable[..., BaseMatcher]] = {}
+
+
+def register_matcher(name: str) -> Callable[[Callable[..., BaseMatcher]], Callable[..., BaseMatcher]]:
+    """Register a custom matcher factory on the ``match`` namespace.
+
+    Args:
+        name: the name to register on ``match`` (e.g. ``"is_valid_email"``)
+
+    Returns:
+        A decorator that registers the wrapped function and returns it unchanged.
+
+    Examples:
+        Register a simple matcher::
+
+            @register_matcher("is_valid_email")
+            def is_valid_email():
+                return match.matches_regex(r"^[\\w.-]+@[\\w.-]+\\.\\w+$")
+
+            assert_that(email).satisfies(match.is_valid_email())
+
+        Register a parametrised matcher::
+
+            @register_matcher("has_status")
+            def has_status(expected: str):
+                return match.has_property("status", match.equal_to(expected))
+
+            assert_that(order).satisfies(match.has_status("active"))
+    """
+    if not isinstance(name, str):
+        raise TypeError("name must be a string")
+    if not name.isidentifier():
+        raise ValueError(f"name must be a valid Python identifier, got {name!r}")
+
+    def decorator(func: Callable[..., BaseMatcher]) -> Callable[..., BaseMatcher]:
+        if not callable(func):
+            raise TypeError("func must be callable")
+        _custom_matchers[name] = func
+        return func
+
+    return decorator
+
+
+def unregister_matcher(name: str) -> None:
+    """Remove a previously registered custom matcher.
+
+    Args:
+        name: the matcher name to remove
+
+    Raises:
+        KeyError: if the name is not registered
+    """
+    if name not in _custom_matchers:
+        raise KeyError(f"no custom matcher registered with name {name!r}")
+    del _custom_matchers[name]
+
+
 # --- Namespace ---
 
 
@@ -705,5 +765,12 @@ class _MatchNamespace:
     def structure(spec: dict) -> StructureMatcher:
         return StructureMatcher(spec)
 
+    def __getattr__(self, name: str) -> Callable[..., BaseMatcher]:
+        try:
+            factory = _custom_matchers[name]
+        except KeyError:
+            raise AttributeError(f"match has no matcher {name!r}") from None
+        return factory
+
 
 match = _MatchNamespace()

{assertpy2-2.3.2 → assertpy2-2.3.3}/assertpy2/string.py

@@ -519,3 +519,93 @@ class StringMixin(_MixinBase):
         if not isinstance(self.val, str):
             return self.error(f"Expected <{self.val}> to be unicode, but was <{type(self.val).__name__}>.")
         return self
+
+    def extracting_group(self, pattern: str, group: int | str = 0) -> Self:
+        """Search val for ``pattern`` and return a new builder whose val is the captured group.
+
+        Args:
+            pattern: the regular expression pattern (must contain at least one group)
+            group: the group index (int) or name (str) to extract. Defaults to ``0``
+                (the entire match).
+
+        Examples:
+            Usage with positional groups::
+
+                assert_that("status=200 path=/api").extracting_group(r"status=(\\d+)", 1).is_equal_to("200")
+
+            Usage with named groups::
+
+                assert_that("2024-01-15 ERROR").extracting_group(
+                    r"(?P<level>\\w+)$", "level"
+                ).is_equal_to("ERROR")
+
+        Returns:
+            AssertionBuilder: a **new** builder whose val is the extracted group string
+
+        Raises:
+            TypeError: if val is not a string or pattern is not a string
+            ValueError: if pattern is empty
+            AssertionError: if the pattern does not match val or the group does not exist
+        """
+        if not isinstance(self.val, str):
+            raise TypeError("val is not a string")
+        if not isinstance(pattern, str):
+            raise TypeError("given pattern arg must be a string")
+        if len(pattern) == 0:
+            raise ValueError("given pattern arg must not be empty")
+        m = re.search(pattern, self.val)
+        if m is None:
+            return self.error(f"Expected <{self.val}> to match pattern <{pattern}>, but did not.")
+        try:
+            extracted = m.group(group)
+        except IndexError:
+            return self.error(f"Expected pattern <{pattern}> to have group <{group}>, but it does not.")
+        if extracted is None:
+            return self.error(
+                f"Expected group <{group}> of pattern <{pattern}> to be matched in <{self.val}>, but it was not."
+            )
+        return self.builder(extracted, self.description, self.kind)
+
+    def matches_with_groups(self, pattern: str) -> Self:
+        """Search val for ``pattern`` and return a new builder whose val is the tuple of all groups.
+
+        If the pattern contains **named** groups, the builder val is a ``dict``
+        of ``{name: value}`` for all named groups.  Otherwise it is the
+        ``tuple`` returned by ``Match.groups()``.
+
+        Args:
+            pattern: the regular expression pattern with one or more groups
+
+        Examples:
+            Positional groups::
+
+                assert_that("2024-01-15 ERROR").matches_with_groups(
+                    r"(\\d{4}-\\d{2}-\\d{2}) (\\w+)"
+                ).is_length(2)
+
+            Named groups::
+
+                assert_that("status=200").matches_with_groups(
+                    r"(?P<key>\\w+)=(?P<val>\\w+)"
+                ).contains_key("key").contains_key("val")
+
+        Returns:
+            AssertionBuilder: a **new** builder whose val is the groups tuple or groupdict
+
+        Raises:
+            TypeError: if val is not a string or pattern is not a string
+            ValueError: if pattern is empty
+            AssertionError: if the pattern does not match val
+        """
+        if not isinstance(self.val, str):
+            raise TypeError("val is not a string")
+        if not isinstance(pattern, str):
+            raise TypeError("given pattern arg must be a string")
+        if len(pattern) == 0:
+            raise ValueError("given pattern arg must not be empty")
+        m = re.search(pattern, self.val)
+        if m is None:
+            return self.error(f"Expected <{self.val}> to match pattern <{pattern}>, but did not.")
+        groupdict = m.groupdict()
+        result = groupdict if groupdict else m.groups()
+        return self.builder(result, self.description, self.kind)

{assertpy2-2.3.2 → assertpy2-2.3.3}/docs/api.md

@@ -29,6 +29,8 @@ Full API reference for assertpy2. For a quick overview, see the [README](../READ
 - [Snapshot Testing](#snapshot-testing)
 - [Allure Integration](#allure-integration)
 - [Behave Step Matchers](#behave-step-matchers)
+- [Custom Matchers](#custom-matchers---registering-domain-matchers)
+- [Regex Group Extraction](#regex-group-extraction)
 - [Extension System](#extension-system---adding-custom-assertions)
 - [Chaining](#chaining)
 
@@ -1387,6 +1389,106 @@ value = parse_int("42")  # 42
 ```
 
 
+[Back to top](#table-of-contents)
+
+## Custom Matchers - registering domain matchers
+
+The `register_matcher()` decorator lets you add custom matchers to the `match` namespace. Custom matchers support full composition with `&`, `|`, `~` and work everywhere matchers are accepted: `satisfies()`, `each()`, `matches_structure()`, `contains()`.
+
+### Simple (no-argument) matchers
+
+```py
+from assertpy2 import assert_that, match, register_matcher
+
+@register_matcher("is_valid_email")
+def is_valid_email():
+    return match.matches_regex(r"^[\w.-]+@[\w.-]+\.\w+$")
+
+assert_that("alice@example.com").satisfies(match.is_valid_email())
+assert_that(users).extracting("email").each(match.is_valid_email())
+```
+
+### Parametrised matchers
+
+```py
+@register_matcher("has_status")
+def has_status(expected: str):
+    return match.has_property("status", match.equal_to(expected))
+
+assert_that(order).satisfies(match.has_status("active"))
+```
+
+### Composition
+
+Custom matchers compose with built-in matchers using `&`, `|`, `~`:
+
+```py
+assert_that(email).satisfies(
+    match.is_valid_email() & match.contains_string("@company.com")
+)
+assert_that(value).satisfies(~match.is_valid_email())
+```
+
+### In structural matching
+
+```py
+assert_that(response).matches_structure({
+    "email": match.is_valid_email(),
+    "status": match.has_status("active"),
+    "name": match.is_non_empty_string(),
+})
+```
+
+### Removing a custom matcher
+
+```py
+from assertpy2 import unregister_matcher
+
+unregister_matcher("is_valid_email")
+```
+
+[Back to top](#table-of-contents)
+
+## Regex Group Extraction
+
+Extract regex capture groups from strings and continue asserting on the extracted value.
+
+### extracting_group()
+
+Search val for a regex pattern and return a new builder whose val is the captured group:
+
+```py
+log = "2024-01-15 ERROR status=500 path=/api/users"
+
+# extract by positional group index
+assert_that(log).extracting_group(r"status=(\d+)", 1).is_equal_to("500")
+
+# extract by named group
+assert_that(log).extracting_group(r"(?P<level>\w+) status", "level").is_equal_to("ERROR")
+
+# default group=0 extracts the entire match
+assert_that("abc123").extracting_group(r"\d+").is_equal_to("123")
+
+# chain further assertions on the extracted value
+assert_that("count=42").extracting_group(r"count=(\d+)", 1).is_digit().is_length(2)
+```
+
+### matches_with_groups()
+
+Search val for a pattern and return a new builder whose val is the tuple of all groups (or a dict for named groups):
+
+```py
+# positional groups return a tuple
+assert_that("2024-01-15 ERROR").matches_with_groups(
+    r"(\d{4}-\d{2}-\d{2}) (\w+)"
+).is_equal_to(("2024-01-15", "ERROR"))
+
+# named groups return a dict
+assert_that("key=value").matches_with_groups(
+    r"(?P<key>\w+)=(?P<val>\w+)"
+).contains_entry({"key": "key"}).contains_entry({"val": "value"})
+```
+
 [Back to top](#table-of-contents)
 
 ## Extension System - adding custom assertions

{assertpy2-2.3.2 → assertpy2-2.3.3}/pyproject.toml

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

assertpy2-2.3.3/tests/test_matcher_registry.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import pytest
+
+from assertpy2 import assert_that, match, register_matcher, unregister_matcher
+from assertpy2.matchers import _custom_matchers
+
+
+class TestRegisterMatcher:
+    def teardown_method(self):
+        _custom_matchers.clear()
+
+    def test_simple_matcher(self):
+        @register_matcher("is_short")
+        def is_short():
+            return match.has_length(3)
+
+        assert_that("foo").satisfies(match.is_short())
+
+    def test_parametrised_matcher(self):
+        @register_matcher("has_status")
+        def has_status(expected: str):
+            return match.equal_to(expected)
+
+        assert_that("active").satisfies(match.has_status("active"))
+
+    def test_parametrised_matcher_failure(self):
+        @register_matcher("has_status")
+        def has_status(expected: str):
+            return match.equal_to(expected)
+
+        with pytest.raises(AssertionError):
+            assert_that("active").satisfies(match.has_status("inactive"))
+
+    def test_composition_with_builtin(self):
+        @register_matcher("is_valid_email")
+        def is_valid_email():
+            return match.matches_regex(r"^[\w.-]+@[\w.-]+\.\w+$")
+
+        combined = match.is_valid_email() & match.contains_string("@company.com")
+        assert_that("alice@company.com").satisfies(combined)
+
+    def test_composition_failure(self):
+        @register_matcher("is_valid_email")
+        def is_valid_email():
+            return match.matches_regex(r"^[\w.-]+@[\w.-]+\.\w+$")
+
+        combined = match.is_valid_email() & match.contains_string("@company.com")
+        with pytest.raises(AssertionError):
+            assert_that("alice@other.com").satisfies(combined)
+
+    def test_with_each(self):
+        @register_matcher("is_short")
+        def is_short():
+            return match.has_length(3)
+
+        assert_that(["foo", "bar", "baz"]).each(match.is_short())
+
+    def test_with_matches_structure(self):
+        @register_matcher("is_valid_name")
+        def is_valid_name():
+            return match.is_non_empty_string()
+
+        data = {"name": "Alice", "age": 30}
+        assert_that(data).matches_structure(
+            {
+                "name": match.is_valid_name(),
+                "age": match.between(0, 200),
+            }
+        )
+
+    def test_invert_custom_matcher(self):
+        @register_matcher("is_short")
+        def is_short():
+            return match.has_length(3)
+
+        inverted = ~match.is_short()
+        assert_that("hello").satisfies(inverted)
+
+    def test_or_custom_matchers(self):
+        @register_matcher("is_three")
+        def is_three():
+            return match.has_length(3)
+
+        @register_matcher("is_five")
+        def is_five():
+            return match.has_length(5)
+
+        combined = match.is_three() | match.is_five()
+        assert_that("hello").satisfies(combined)
+        assert_that("foo").satisfies(combined)
+
+    def test_overwrite_registration(self):
+        @register_matcher("custom")
+        def custom_v1():
+            return match.equal_to(1)
+
+        @register_matcher("custom")
+        def custom_v2():
+            return match.equal_to(2)
+
+        assert_that(2).satisfies(match.custom())
+
+    def test_returns_decorated_function(self):
+        @register_matcher("my_matcher")
+        def my_matcher():
+            return match.is_positive()
+
+        assert callable(my_matcher)
+        result = my_matcher()
+        assert result.matches(5)
+
+
+class TestRegisterMatcherErrors:
+    def teardown_method(self):
+        _custom_matchers.clear()
+
+    def test_name_not_string(self):
+        with pytest.raises(TypeError, match="name must be a string"):
+            register_matcher(123)
+
+    def test_name_not_identifier(self):
+        with pytest.raises(ValueError, match="must be a valid Python identifier"):
+            register_matcher("not-valid")
+
+    def test_name_not_identifier_spaces(self):
+        with pytest.raises(ValueError, match="must be a valid Python identifier"):
+            register_matcher("has spaces")
+
+    def test_func_not_callable(self):
+        with pytest.raises(TypeError, match="func must be callable"):
+            register_matcher("test")(42)
+
+    def test_unregistered_name_attribute_error(self):
+        with pytest.raises(AttributeError, match="match has no matcher"):
+            match.nonexistent_matcher()
+
+
+class TestUnregisterMatcher:
+    def teardown_method(self):
+        _custom_matchers.clear()
+
+    def test_unregister(self):
+        @register_matcher("temp")
+        def temp():
+            return match.is_positive()
+
+        assert_that(5).satisfies(match.temp())
+        unregister_matcher("temp")
+        with pytest.raises(AttributeError):
+            match.temp()
+
+    def test_unregister_unknown_name(self):
+        with pytest.raises(KeyError, match="no custom matcher registered"):
+            unregister_matcher("nonexistent")

assertpy2-2.3.3/tests/test_regex_groups.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import pytest
+
+from assertpy2 import assert_that
+
+
+class TestExtractingGroup:
+    def test_positional_group(self):
+        assert_that("status=200 path=/api").extracting_group(r"status=(\d+)", 1).is_equal_to("200")
+
+    def test_named_group(self):
+        assert_that("2024-01-15 ERROR msg").extracting_group(r"(?P<level>\w+) msg$", "level").is_equal_to("ERROR")
+
+    def test_group_zero_entire_match(self):
+        assert_that("hello world").extracting_group(r"hello (\w+)", 0).is_equal_to("hello world")
+
+    def test_default_group_zero(self):
+        assert_that("abc123").extracting_group(r"\d+").is_equal_to("123")
+
+    def test_chaining_after_extraction(self):
+        assert_that("count=42").extracting_group(r"count=(\d+)", 1).is_digit().is_length(2)
+
+    def test_extracts_to_new_builder(self):
+        assert_that("code=404 msg=not_found").extracting_group(r"code=(\d+)", 1).starts_with("4").ends_with("4")
+
+    def test_preserves_description(self):
+        with pytest.raises(AssertionError, match=r"\[API check\]"):
+            assert_that("status=200").described_as("API check").extracting_group(r"status=(\d+)", 1).is_equal_to("500")
+
+    def test_no_match_fails(self):
+        with pytest.raises(AssertionError, match="to match pattern"):
+            assert_that("no numbers here").extracting_group(r"(\d+)", 1)
+
+    def test_invalid_group_index(self):
+        with pytest.raises(AssertionError, match="to have group"):
+            assert_that("abc123").extracting_group(r"(\d+)", 5)
+
+    def test_unmatched_optional_group(self):
+        with pytest.raises(AssertionError, match="to be matched"):
+            assert_that("hello").extracting_group(r"hello(?:(\d+))?", 1)
+
+    def test_val_not_string(self):
+        with pytest.raises(TypeError, match="val is not a string"):
+            assert_that(123).extracting_group(r"\d+", 0)
+
+    def test_pattern_not_string(self):
+        with pytest.raises(TypeError, match="given pattern arg must be a string"):
+            assert_that("hello").extracting_group(123, 0)
+
+    def test_pattern_empty(self):
+        with pytest.raises(ValueError, match="given pattern arg must not be empty"):
+            assert_that("hello").extracting_group("", 0)
+
+    def test_multiple_groups(self):
+        assert_that("2024-01-15").extracting_group(r"(\d{4})-(\d{2})-(\d{2})", 1).is_equal_to("2024")
+        assert_that("2024-01-15").extracting_group(r"(\d{4})-(\d{2})-(\d{2})", 2).is_equal_to("01")
+        assert_that("2024-01-15").extracting_group(r"(\d{4})-(\d{2})-(\d{2})", 3).is_equal_to("15")
+
+    def test_soft_assertions_mode(self):
+        from assertpy2 import soft_assertions
+
+        with pytest.raises(AssertionError, match="soft assertion failures"), soft_assertions():
+            assert_that("status=200").extracting_group(r"status=(\d+)", 1).is_equal_to("500")
+            assert_that("code=404").extracting_group(r"code=(\d+)", 1).is_equal_to("200")
+
+
+class TestMatchesWithGroups:
+    def test_positional_groups_tuple(self):
+        assert_that("2024-01-15 ERROR").matches_with_groups(r"(\d{4}-\d{2}-\d{2}) (\w+)").is_length(2)
+
+    def test_positional_groups_values(self):
+        assert_that("2024-01-15 ERROR").matches_with_groups(r"(\d{4}-\d{2}-\d{2}) (\w+)").is_equal_to(
+            ("2024-01-15", "ERROR")
+        )
+
+    def test_named_groups_dict(self):
+        assert_that("key=value").matches_with_groups(r"(?P<key>\w+)=(?P<val>\w+)").contains_key("key").contains_key(
+            "val"
+        )
+
+    def test_named_groups_values(self):
+        result = {"key": "status", "val": "200"}
+        assert_that("status=200").matches_with_groups(r"(?P<key>\w+)=(?P<val>\w+)").is_equal_to(result)
+
+    def test_chaining_on_dict(self):
+        assert_that("name=Alice").matches_with_groups(r"(?P<key>\w+)=(?P<val>\w+)").contains_entry(
+            {"key": "name"}
+        ).contains_entry({"val": "Alice"})
+
+    def test_no_match_fails(self):
+        with pytest.raises(AssertionError, match="to match pattern"):
+            assert_that("no match").matches_with_groups(r"(\d+)")
+
+    def test_preserves_description(self):
+        with pytest.raises(AssertionError, match=r"\[log parsing\]"):
+            assert_that("no match").described_as("log parsing").matches_with_groups(r"(\d+)")
+
+    def test_val_not_string(self):
+        with pytest.raises(TypeError, match="val is not a string"):
+            assert_that(42).matches_with_groups(r"(\d+)")
+
+    def test_pattern_not_string(self):
+        with pytest.raises(TypeError, match="given pattern arg must be a string"):
+            assert_that("hello").matches_with_groups(42)
+
+    def test_pattern_empty(self):
+        with pytest.raises(ValueError, match="given pattern arg must not be empty"):
+            assert_that("hello").matches_with_groups("")
+
+    def test_single_group(self):
+        assert_that("hello123").matches_with_groups(r"(\d+)").is_equal_to(("123",))
+
+    def test_soft_assertions_mode(self):
+        from assertpy2 import soft_assertions
+
+        with pytest.raises(AssertionError, match="soft assertion failures"), soft_assertions():
+            assert_that("a=1").matches_with_groups(r"(?P<k>\w+)=(?P<v>\w+)").contains_entry({"k": "x"})