Rename, more tests

Author: Tinche

src/cattrs/v/__init__.py

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

src/cattrs/v/_validators.py

@@ -97,9 +97,9 @@ def skip_none(val: T | None, _validators=validators) -> None:
     return factory
 
 
-def all_elements_must(
+def for_all(
     validator: Callable[[T], None | bool], *validators: Callable[[T], None | bool]
-) -> ValidatorFactory[T]:
+) -> ValidatorFactory[Iterable[T]]:
     """A helper validator included with cattrs.
 
     Run all the given validators against all members of the

tests/v/test_typing_validators.yml

@@ -88,4 +88,57 @@
     c = Converter()
 
     v.customize(c, A, v.V(fields(A).a).ensure(v.greater_than(5)))  # E: Argument 1 to "ensure" of "V" has incompatible type "Callable[[int], None]"; expected "Callable[[int | None], bool | None] | Callable[[bool], Callable[[int | None], None]]"  [arg-type]
-    v.customize(c, A, v.V(fields(A).a).ensure(v.ignoring_none(v.len_between(0, 5))))  # E: Argument 1 to "ignoring_none" has incompatible type "Callable[[Sized], None]"; expected "Callable[[int], None]"  [arg-type]
+    v.customize(c, A, v.V(fields(A).a).ensure(v.ignoring_none(v.len_between(0, 5))))  # E: Argument 1 to "ignoring_none" has incompatible type "Callable[[Sized], None]"; expected "Callable[[int], None]"  [arg-type]
+
+- case: for_all
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: list[int]
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.for_all(v.greater_than(5))))
+
+- case: for_all_dict
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: dict[str, int]
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.for_all(v.len_between(0, 5))))
+
+- case: for_all_error
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+    from cattrs.v import for_all as fa
+
+    @define
+    class A:
+      a: list[int]
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(fa(fa(v.greater_than(5)))))  # E: Argument 1 to "for_all" has incompatible type "Callable[[bool], Callable[[Iterable[int]], None]]"; expected "Callable[[int], bool | None]"  [arg-type]
+
+- case: for_all_dict_error
+  main: |
+    from attrs import define, fields
+    from cattrs import v, Converter
+
+    @define
+    class A:
+      a: dict[str, int]
+
+    c = Converter()
+
+    v.customize(c, A, v.V(fields(A).a).ensure(v.for_all(v.greater_than(5))))  # E: Argument 1 to "greater_than" has incompatible type "int"; expected "str"  [arg-type]

tests/v/test_validators.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Dict, List, Optional, Tuple
 
 from attrs import define
 from attrs import fields as f
@@ -8,9 +8,9 @@
 from cattrs.errors import ClassValidationError
 from cattrs.v import (
     V,
-    all_elements_must,
     between,
     customize,
+    for_all,
     greater_than,
     ignoring_none,
     is_unique,
@@ -29,6 +29,11 @@ class WithList:
     a: List[int]
 
 
+@define
+class WithDict:
+    a: Dict[str, int]
+
+
 @define
 class WithOptional:
     a: Optional[int]
@@ -171,13 +176,13 @@ def test_ignoring_none(converter: BaseConverter):
         assert repr(exc_info.value) == "ValueError('10 not between 0 and 5')"
 
 
-def test_all_elements_must(converter: BaseConverter):
-    """`all_elements_must` works."""
+def test_for_all_lists(converter: BaseConverter):
+    """`for_all` works on lists."""
 
     hook = customize(
         converter,
         WithList,
-        V(f(WithList).a).ensure(all_elements_must(greater_than(5), between(5, 10))),
+        V(f(WithList).a).ensure(for_all(greater_than(5), between(5, 10))),
     )
 
     assert hook({"a": []}, None) == WithList([])
@@ -193,3 +198,32 @@ def test_all_elements_must(converter: BaseConverter):
             "invalid value (2 not greater than 5) @ $.a[1]",
             "invalid value (2 not between 5 and 10) @ $.a[1]",
         ]
+    else:
+        with raises(ValueError) as exc_info:
+            hook({"a": [1, 2]}, None)
+
+        assert repr(exc_info.value) == "ValueError('1 not greater than 5')"
+
+
+def test_for_all_dicts(converter: BaseConverter):
+    """`for_all` works on dicts."""
+
+    hook = customize(
+        converter, WithDict, V(f(WithDict).a).ensure(for_all(len_between(0, 2)))
+    )
+
+    assert hook({"a": {}}, None) == WithDict({})
+    assert hook({"a": {"a": 1, "b": 2}}, None) == WithDict({"a": 1, "b": 2})
+
+    if converter.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            hook({"a": {"aaa": 1}}, None)
+
+        assert transform_error(exc_info.value) == [
+            "invalid value (length (3) not between 0 and 2) @ $.a[0]"
+        ]
+    else:
+        with raises(ValueError) as exc_info:
+            hook({"a": {"aaa": 1}}, None)
+
+        assert repr(exc_info.value) == "ValueError('length (3) not between 0 and 2')"