MappingValidationError and tests

Author: Tinche

src/cattr/gen.py

@@ -22,7 +22,7 @@
 import attr
 from attr import NOTHING, resolve_types
 
-from cattrs.errors import ClassValidationError
+from cattrs.errors import ClassValidationError, MappingValidationError
 
 from ._compat import (
     adapted_fields,
@@ -527,7 +527,12 @@ def make_mapping_unstructure_fn(
 
 
 def make_mapping_structure_fn(
-    cl: Any, converter, structure_to=dict, key_type=NOTHING, val_type=NOTHING
+    cl: Any,
+    converter,
+    structure_to=dict,
+    key_type=NOTHING,
+    val_type=NOTHING,
+    extended_validation: bool = True,
 ):
     """Generate a specialized unstructure function for a mapping."""
     fn_name = "structure_mapping"
@@ -586,13 +591,35 @@ def make_mapping_structure_fn(
 
     if is_bare_dict:
         # No args, it's a bare dict.
-        lines.append("    res = dict(mapping)")
+        lines.append("  res = dict(mapping)")
     else:
-        lines.append(f"    res = {{{k_s}: {v_s} for k, v in mapping.items()}}")
+        if extended_validation:
+            globs["enumerate"] = enumerate
+            globs["MappingValidationError"] = MappingValidationError
+            lines.append("  res = {}; key_errors = {}; value_errors = {}")
+            lines.append("  for ix, (k, v) in enumerate(mapping.items()):")
+            lines.append("    try:")
+            lines.append(f"      value = {v_s}")
+            lines.append("    except Exception as e:")
+            lines.append("      value_errors[key] = e")
+            lines.append("      continue")
+            lines.append("    try:")
+            lines.append(f"      key = {k_s}")
+            lines.append("      res[key] = value")
+            lines.append("    except Exception as e:")
+            lines.append("      key_errors[ix] = e")
+            lines.append("  if key_errors or value_errors:")
+            lines.append(
+                "    raise MappingValidationError(key_errors, value_errors)"
+            )
+        else:
+            lines.append(
+                f"  res = {{{k_s}: {v_s} for k, v in mapping.items()}}"
+            )
     if structure_to is not dict:
-        lines.append("    res = __cattr_mapping_cl(res)")
+        lines.append("  res = __cattr_mapping_cl(res)")
 
-    total_lines = lines + ["    return res"]
+    total_lines = lines + ["  return res"]
 
     eval(compile("\n".join(total_lines), "", "exec"), globs)
 

src/cattrs/errors.py

@@ -17,6 +17,11 @@ class ValidationError(Exception):
 
 @define
 class IterableValidationError(ValidationError):
+    """Iterable validation errors.
+
+    A dictionary of indices to errors for the element at that index.
+    """
+
     errors_by_index: Dict[int, Exception]
 
 
@@ -25,3 +30,15 @@ class ClassValidationError(ValidationError):
     """Raised when validating a class if any attributes are invalid."""
 
     errors_by_attribute: Dict[str, Exception]
+
+
+@define
+class MappingValidationError(ValidationError):
+    """Mapping validation errors.
+
+    A dictionary of element indices to key validation errors, and
+    a dictionary of keys to value validation errors.
+    """
+
+    key_errors: Dict[int, Exception]
+    value_errors: Dict[str, Exception]

tests/test_generics.py

@@ -63,8 +63,11 @@ def test_able_to_structure_generics(converter: Converter, t, t2, result):
         (str, GenericCols("1", ["2"], {"3": "3"})),
     ),
 )
-def test_structure_generics_with_cols(t, result):
-    res = GenConverter().structure(asdict(result), GenericCols[t])
+@pytest.mark.parametrize("extended_validation", [True, False])
+def test_structure_generics_with_cols(t, result, extended_validation):
+    res = GenConverter(extended_validation=extended_validation).structure(
+        asdict(result), GenericCols[t]
+    )
 
     assert res == result
 

tests/test_validation.py

@@ -0,0 +1,25 @@
+"""Tests for the extended validation mode."""
+import pytest
+from attrs import define, field
+from attrs.validators import in_
+
+from cattrs import GenConverter
+from cattrs.errors import ClassValidationError
+
+
+def test_class_validation():
+    c = GenConverter(extended_validation=True)
+
+    @define
+    class Test:
+        a: int
+        b: str = field(validator=in_(["a", "b"]))
+        c: str
+
+    with pytest.raises(ClassValidationError) as exc:
+        c.structure({"a": "a", "b": "c"}, Test)
+
+    assert repr(exc.value.errors_by_attribute["a"]) == repr(
+        ValueError("invalid literal for int() with base 10: 'a'")
+    )
+    assert repr(exc.value.errors_by_attribute["c"]) == repr(KeyError("c"))