Tests for all_elements_must

Author: Tinche

src/cattrs/v/__init__.py

@@ -8,9 +8,17 @@
     IterableValidationError,
 )
 from ._fluent import V, customize
-from ._validators import between, greater_than, ignoring_none, is_unique, len_between
+from ._validators import (
+    all_elements_must,
+    between,
+    greater_than,
+    ignoring_none,
+    is_unique,
+    len_between,
+)
 
 __all__ = [
+    "all_elements_must",
     "between",
     "customize",
     "format_exception",

src/cattrs/v/_fluent.py

@@ -1,7 +1,7 @@
 """The fluent validation API."""
 from __future__ import annotations
 
-from typing import Any, Callable, Generic, Iterable, Literal, Sequence, TypeVar
+from typing import Any, Callable, Generic, Literal, Sequence, TypeVar
 
 try:
     from typing import assert_never
@@ -102,35 +102,6 @@ def omit(self) -> VOmitted:
         """Omit the attribute."""
         return VOmitted(self.attr)
 
-    def replace_on_structure(self, value: T) -> VOmitted:
-        """This attribute should be replaced with a value when structuring."""
-        return VOmitted(self.attr)
-
-
-def all_elements_must(
-    validator: Callable[[T], None | bool], *validators: Callable[[T], None | bool]
-) -> Callable[[Iterable[T]], None | bool]:
-    """A helper validator included with cattrs.
-
-    Run all the given validators against all members of the
-    iterable.
-    """
-
-    validators = (validator, *validators)
-
-    def assert_all_elements(val: Iterable[T]) -> None:
-        errors = []
-        for e in val:
-            for v in validators:
-                try:
-                    v(e)
-                except Exception as exc:
-                    errors.append(exc)
-        if errors:
-            raise ExceptionGroup("", errors)
-
-    return assert_all_elements
-
 
 def _is_validator_factory(
     validator: Callable[[Any], None | bool] | ValidatorFactory[T]

src/cattrs/v/_validators.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from collections.abc import Hashable
+from collections.abc import Hashable, Iterable
 from typing import Callable, Collection, Protocol, Sized, TypeVar
 
 from .._compat import ExceptionGroup
+from ..errors import IterableValidationError, IterableValidationNote
 from ._fluent import ValidatorFactory
 
 T = TypeVar("T")
@@ -94,3 +95,50 @@ def skip_none(val: T | None, _validators=validators) -> None:
         return skip_none
 
     return factory
+
+
+def all_elements_must(
+    validator: Callable[[T], None | bool], *validators: Callable[[T], None | bool]
+) -> ValidatorFactory[T]:
+    """A helper validator included with cattrs.
+
+    Run all the given validators against all members of the
+    iterable.
+    """
+
+    validators = (validator, *validators)
+
+    def factory(detailed_validation: bool) -> Callable[[T], None]:
+        if detailed_validation:
+
+            def assert_all_elements(val: Iterable[T], _validators=validators) -> None:
+                errors = []
+                ix = 0
+                for e in val:
+                    try:
+                        for v in _validators:
+                            try:
+                                v(e)
+                            except Exception as exc:
+                                exc.__notes__ = [
+                                    *getattr(exc, "__notes__", []),
+                                    IterableValidationNote(
+                                        f"Validating @ index {ix}", ix, None
+                                    ),
+                                ]
+                                errors.append(exc)
+                    finally:
+                        ix += 1
+                if errors:
+                    raise IterableValidationError("", errors, val.__class__)
+
+        else:
+
+            def assert_all_elements(val: Iterable[T], _validators=validators) -> None:
+                for e in val:
+                    for v in _validators:
+                        v(e)
+
+        return assert_all_elements
+
+    return factory

tests/v/test_validators.py

@@ -8,6 +8,7 @@
 from cattrs.errors import ClassValidationError
 from cattrs.v import (
     V,
+    all_elements_must,
     between,
     customize,
     greater_than,
@@ -167,4 +168,28 @@ def test_ignoring_none(converter: BaseConverter):
         with raises(ValueError) as exc_info:
             converter.structure({"a": 10}, WithOptional)
 
-        # assert repr(exc_info.value) == "invalid value (10 not between 0 and 5) @ $.a"
+        assert repr(exc_info.value) == "ValueError('10 not between 0 and 5')"
+
+
+def test_all_elements_must(converter: BaseConverter):
+    """`all_elements_must` works."""
+
+    hook = customize(
+        converter,
+        WithList,
+        V(f(WithList).a).ensure(all_elements_must(greater_than(5), between(5, 10))),
+    )
+
+    assert hook({"a": []}, None) == WithList([])
+    assert hook({"a": [6, 7, 8]}, None) == WithList([6, 7, 8])
+
+    if converter.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            hook({"a": [1, 2]}, None)
+
+        assert transform_error(exc_info.value) == [
+            "invalid value (1 not greater than 5) @ $.a[0]",
+            "invalid value (1 not between 5 and 10) @ $.a[0]",
+            "invalid value (2 not greater than 5) @ $.a[1]",
+            "invalid value (2 not between 5 and 10) @ $.a[1]",
+        ]