Test with no detailed validation

Author: Tinche

src/cattrs/v/__init__.py

@@ -8,8 +8,16 @@
     IterableValidationError,
 )
 from ._fluent import V, customize
+from ._validators import between, greater_than
 
-__all__ = ["customize", "format_exception", "transform_error", "V"]
+__all__ = [
+    "customize",
+    "format_exception",
+    "transform_error",
+    "V",
+    "between",
+    "greater_than",
+]
 
 
 def format_exception(exc: BaseException, type: Union[type, None]) -> str:

src/cattrs/v/_fluent.py

@@ -8,7 +8,6 @@
     Generic,
     Iterable,
     Literal,
-    Protocol,
     Sequence,
     Sized,
     TypeVar,
@@ -130,27 +129,6 @@ def assert_len_between(val: Sized, _min: int = min, _max: int = max) -> None:
     return assert_len_between
 
 
-class Comparable(Protocol):
-    def __lt__(self: T, other: T) -> bool:
-        ...
-
-    def __le__(self: T, other: T) -> bool:
-        ...
-
-
-C = TypeVar("C", bound=Comparable)
-
-
-def between(min: C, max: C) -> Callable[[C], None]:
-    """Ensure the value of the attribute is between min (inclusive) and max (exclusive)."""
-
-    def assert_between(val: C, _min: C = min, _max: C = max) -> None:
-        if not (_min <= val) and not (_max < val):
-            raise ValueError(f"Value not between {_min} and {_max}")
-
-    return assert_between
-
-
 def ignoring_none(*validators: Callable[[T], None]) -> Callable[[T | None], None]:
     """
     A validator for (f.e.) strings cannot be applied to `str | None`, but it can
@@ -198,7 +176,7 @@ def assert_all_elements(val: Iterable[T]) -> None:
 
 
 def _compose_validators(
-    base_structure: StructureHook | str,
+    base_structure: StructureHook,
     validators: Sequence[Callable[[Any], None | bool]],
     detailed_validation: bool,
 ) -> Callable[[Any, Any], Any]:
@@ -208,13 +186,14 @@ def _compose_validators(
 
     The new hook will raise an ExceptionGroup.
     """
-    if isinstance(base_structure, str):
-        name = base_structure
+    bs = base_structure
+
+    if detailed_validation:
 
         def structure_hook(
-            val: dict[str, Any], t: Any, _name: str = name, _hooks=validators
+            val: dict[str, Any], t: Any, _hooks=validators, _bs=bs
         ) -> Any:
-            res = val[_name]
+            res = _bs(val, t)
             errors: list[Exception] = []
             for hook in _hooks:
                 try:
@@ -226,18 +205,13 @@ def structure_hook(
             return res
 
     else:
-        bs = base_structure
 
-        def structure_hook(val: dict[str, Any], t: Any, _hooks=validators) -> Any:
-            res = bs(val, t)
-            errors: list[Exception] = []
+        def structure_hook(
+            val: dict[str, Any], t: Any, _hooks=validators, _bs=bs
+        ) -> Any:
+            res = _bs(val, t)
             for hook in _hooks:
-                try:
-                    hook(val)
-                except Exception as exc:
-                    errors.append(exc)
-            if errors:
-                raise ExceptionGroup("Validation errors structuring {}", errors)
+                hook(val)
             return res
 
     return structure_hook

src/cattrs/v/_validators.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Callable, Protocol, TypeVar
+
+T = TypeVar("T")
+
+
+class Comparable(Protocol):
+    def __lt__(self: T, other: T) -> bool:
+        ...
+
+    def __le__(self: T, other: T) -> bool:
+        ...
+
+
+C = TypeVar("C", bound=Comparable)
+
+
+def greater_than(min: C) -> Callable[[C], None]:
+    def assert_gt(val: C, _min: C = min) -> None:
+        if _min >= val:
+            raise ValueError(f"{val} not greater than {_min}")
+
+    return assert_gt
+
+
+def between(min: C, max: C) -> Callable[[C], None]:
+    """Ensure the value of the attribute is between min (inclusive) and max (exclusive)."""
+
+    def assert_between(val: C, _min: C = min, _max: C = max) -> None:
+        if not (_min <= val) and not (_max < val):
+            raise ValueError(f"{val} not between {_min} and {_max}")
+
+    return assert_between

tests/v/test_fluent.py

@@ -5,20 +5,17 @@
 from attrs import fields as f
 from pytest import fixture, raises
 
-from cattrs import ClassValidationError, Converter
-from cattrs.v import V, customize, transform_error
+from cattrs import BaseConverter, ClassValidationError, Converter
+from cattrs.v import V, customize, greater_than, transform_error
 
 
 @fixture
-def c() -> Converter:
-    """We need only converters with detailed_validation=True."""
-    res = Converter()
-
-    res.register_structure_hook(
+def c(converter: BaseConverter) -> BaseConverter:
+    converter.register_structure_hook(
         Union[str, int], lambda v, _: v if isinstance(v, int) else str(v)
     )
 
-    return res
+    return converter
 
 
 @define
@@ -91,12 +88,18 @@ def test_simple_string_validation(c: Converter) -> None:
 
     unstructured = c.unstructure(instance)
 
-    with raises(ClassValidationError) as exc_info:
-        c.structure(unstructured, Model)
+    if c.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            c.structure(unstructured, Model)
+
+        assert transform_error(exc_info.value) == [
+            "invalid value ('A' not lowercase) @ $.b"
+        ]
+    else:
+        with raises(ValueError) as exc_info:
+            c.structure(unstructured, Model)
 
-    assert transform_error(exc_info.value) == [
-        "invalid value ('A' not lowercase) @ $.b"
-    ]
+        assert repr(exc_info.value) == "ValueError(\"'A' not lowercase\")"
 
     instance.b = "a"
     assert instance == c.structure(c.unstructure(instance), Model)
@@ -110,13 +113,51 @@ def test_multiple_string_validators(c: Converter) -> None:
 
     unstructured = c.unstructure(instance)
 
-    with raises(ClassValidationError) as exc_info:
-        c.structure(unstructured, Model)
+    if c.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            c.structure(unstructured, Model)
 
-    assert transform_error(exc_info.value) == [
-        "invalid value ('A' not lowercase) @ $.b",
-        "invalid value ('A' is not a valid email) @ $.b",
-    ]
+        assert transform_error(exc_info.value) == [
+            "invalid value ('A' not lowercase) @ $.b",
+            "invalid value ('A' is not a valid email) @ $.b",
+        ]
+    else:
+        with raises(ValueError) as exc_info:
+            c.structure(unstructured, Model)
+
+        assert repr(exc_info.value) == "ValueError(\"'A' not lowercase\")"
 
     instance.b = "a@b"
     assert instance == c.structure(c.unstructure(instance), Model)
+
+
+def test_multiple_field_validators(c: Converter) -> None:
+    """Multiple fields are validated."""
+    customize(
+        c,
+        Model,
+        V((fs := f(Model)).a).ensure(greater_than(5)),
+        V(fs.b).ensure(is_lowercase),
+    )
+
+    instance = Model(5, "A", ["1"], [1], "", 0, 0, {"a": 1})
+
+    unstructured = c.unstructure(instance)
+
+    if c.detailed_validation:
+        with raises(ClassValidationError) as exc_info:
+            c.structure(unstructured, Model)
+
+        assert transform_error(exc_info.value) == [
+            "invalid value (5 not greater than 5) @ $.a",
+            "invalid value ('A' not lowercase) @ $.b",
+        ]
+    else:
+        with raises(ValueError) as exc_info:
+            c.structure(unstructured, Model)
+
+        assert repr(exc_info.value) == "ValueError('5 not greater than 5')"
+
+    instance.a = 6
+    instance.b = "a"
+    assert instance == c.structure(c.unstructure(instance), Model)