Fix tests

Author: Tinche

src/cattr/converters.py

@@ -93,20 +93,20 @@ class Converter:
         "_union_struct_registry",
         "_structure_func",
         "_prefer_attrib_converters",
-        "extended_validation",
+        "detailed_validation",
     )
 
     def __init__(
         self,
         dict_factory: Callable[[], Any] = dict,
         unstruct_strat: UnstructureStrategy = UnstructureStrategy.AS_DICT,
         prefer_attrib_converters: bool = False,
-        extended_validation: bool = True,
+        detailed_validation: bool = True,
     ) -> None:
         unstruct_strat = UnstructureStrategy(unstruct_strat)
         self._prefer_attrib_converters = prefer_attrib_converters
 
-        self.extended_validation = extended_validation
+        self.detailed_validation = detailed_validation
 
         # Create a per-instance cache.
         if unstruct_strat is UnstructureStrategy.AS_DICT:
@@ -441,7 +441,7 @@ def _structure_list(self, obj, cl):
         else:
             elem_type = cl.__args__[0]
             handler = self._structure_func.dispatch(elem_type)
-            if self.extended_validation:
+            if self.detailed_validation:
                 errors = []
                 res = []
                 ix = 0  # Avoid `enumerate` for performance.
@@ -455,7 +455,7 @@ def _structure_list(self, obj, cl):
                         ix += 1
                 if errors:
                     raise IterableValidationError(
-                        f"While structuring {cl.__name__}", errors, cl
+                        f"While structuring {cl!r}", errors, cl
                     )
             else:
                 res = [handler(e, elem_type) for e in obj]
@@ -467,7 +467,7 @@ def _structure_set(self, obj, cl, structure_to=set):
             return structure_to(obj)
         elem_type = cl.__args__[0]
         handler = self._structure_func.dispatch(elem_type)
-        if self.extended_validation:
+        if self.detailed_validation:
             errors = []
             res = set()
             for e in obj:
@@ -479,9 +479,7 @@ def _structure_set(self, obj, cl, structure_to=set):
                     )
                     errors.append(exc)
             if errors:
-                raise IterableValidationError(
-                    f"While structuring {cl.__name__}", errors, cl
-                )
+                raise IterableValidationError(f"While structuring {cl!r}", errors, cl)
             return res if structure_to is set else structure_to(res)
         elif structure_to is set:
             return {handler(e, elem_type) for e in obj}
@@ -538,7 +536,7 @@ def _structure_tuple(self, obj, tup: Type[T]):
             # We're dealing with a homogenous tuple, Tuple[int, ...]
             tup_type = tup_params[0]
             conv = self._structure_func.dispatch(tup_type)
-            if self.extended_validation:
+            if self.detailed_validation:
                 errors = []
                 res = []
                 for ix, e in enumerate(obj):
@@ -549,14 +547,14 @@ def _structure_tuple(self, obj, tup: Type[T]):
                         errors.append(exc)
                 if errors:
                     raise IterableValidationError(
-                        f"While structuring {tup.__name__}", errors, tup
+                        f"While structuring {tup!r}", errors, tup
                     )
                 return tuple(res)
             else:
                 return tuple(conv(e, tup_type) for e in obj)
         else:
             # We're dealing with a heterogenous tuple.
-            if self.extended_validation:
+            if self.detailed_validation:
                 errors = []
                 res = []
                 for ix, (t, e) in enumerate(zip(tup_params, obj)):
@@ -568,7 +566,7 @@ def _structure_tuple(self, obj, tup: Type[T]):
                         errors.append(exc)
                 if errors:
                     raise IterableValidationError(
-                        f"While structuring {tup.__name__}", errors, tup
+                        f"While structuring {tup!r}", errors, tup
                     )
                 return tuple(res)
             else:
@@ -614,13 +612,13 @@ def __init__(
         type_overrides: Mapping[Type, AttributeOverride] = {},
         unstruct_collection_overrides: Mapping[Type, Callable] = {},
         prefer_attrib_converters: bool = False,
-        extended_validation: bool = True,
+        detailed_validation: bool = True,
     ):
         super().__init__(
             dict_factory=dict_factory,
             unstruct_strat=unstruct_strat,
             prefer_attrib_converters=prefer_attrib_converters,
-            extended_validation=extended_validation,
+            detailed_validation=detailed_validation,
         )
         self.omit_if_default = omit_if_default
         self.forbid_extra_keys = forbid_extra_keys
@@ -746,7 +744,7 @@ def gen_structure_attrs_fromdict(self, cl: Type[T]) -> T:
             self,
             _cattrs_forbid_extra_keys=self.forbid_extra_keys,
             _cattrs_prefer_attrib_converters=self._prefer_attrib_converters,
-            _cattrs_extended_validation=self.extended_validation,
+            _cattrs_detailed_validation=self.detailed_validation,
             **attrib_overrides,
         )
         # only direct dispatch so that subclasses get separately generated

src/cattrs/gen.py

@@ -214,7 +214,7 @@ def make_dict_structure_fn(
     _cattrs_forbid_extra_keys: bool = False,
     _cattrs_use_linecache: bool = True,
     _cattrs_prefer_attrib_converters: bool = False,
-    _cattrs_extended_validation: bool = True,
+    _cattrs_detailed_validation: bool = True,
     **kwargs,
 ) -> Callable[[Mapping[str, Any], Any], T]:
     """Generate a specialized dict structuring function for an attrs class."""
@@ -258,7 +258,7 @@ def make_dict_structure_fn(
         resolve_types(cl)
 
     allowed_fields = set()
-    if _cattrs_extended_validation:
+    if _cattrs_detailed_validation:
         lines.append("  res = {}")
         lines.append("  errors = []")
         invocation_lines.append("**res,")
@@ -595,7 +595,7 @@ def make_mapping_structure_fn(
     structure_to=dict,
     key_type=NOTHING,
     val_type=NOTHING,
-    extended_validation: bool = True,
+    detailed_validation: bool = True,
 ):
     """Generate a specialized unstructure function for a mapping."""
     fn_name = "structure_mapping"
@@ -656,7 +656,7 @@ def make_mapping_structure_fn(
         # No args, it's a bare dict.
         lines.append("  res = dict(mapping)")
     else:
-        if extended_validation:
+        if detailed_validation:
             globs["enumerate"] = enumerate
             globs["IterableValidationError"] = IterableValidationError
             lines.append("  res = {}; errors = []")

tests/metadata/test_genconverter.py

@@ -34,11 +34,11 @@
 @given(
     simple_typed_classes() | simple_typed_dataclasses(), unstructure_strats, booleans()
 )
-def test_simple_roundtrip(cls_and_vals, strat, extended_validation):
+def test_simple_roundtrip(cls_and_vals, strat, detailed_validation):
     """
     Simple classes with metadata can be unstructured and restructured.
     """
-    converter = Converter(unstruct_strat=strat, extended_validation=extended_validation)
+    converter = Converter(unstruct_strat=strat, detailed_validation=detailed_validation)
     cl, vals = cls_and_vals
     inst = cl(*vals)
     unstructured = converter.unstructure(inst)

tests/test_gen.py

@@ -15,7 +15,7 @@ def test_structure_linecache():
     class A:
         a: int
 
-    c = GenConverter(extended_validation=False)
+    c = GenConverter(detailed_validation=False)
     try:
         c.structure({"a": "test"}, A)
     except ValueError:

tests/test_generics.py

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

tests/test_structure.py

@@ -209,9 +209,9 @@ def test_structuring_optional_primitives(primitive_and_type):
 
 
 @given(lists_of_primitives().filter(lambda lp: not is_bare(lp[1])), booleans())
-def test_structuring_lists_of_opt(list_and_type, extended_validation: bool):
+def test_structuring_lists_of_opt(list_and_type, detailed_validation: bool):
     """Test structuring lists of Optional primitive types."""
-    converter = Converter(extended_validation=extended_validation)
+    converter = Converter(detailed_validation=detailed_validation)
     l, t = list_and_type
 
     l.append(None)
@@ -226,7 +226,7 @@ def test_structuring_lists_of_opt(list_and_type, extended_validation: bool):
     if not is_bare(t) and (args[0] not in (Any, str) and not is_optional):
         with raises(
             (TypeError, ValueError)
-            if not extended_validation
+            if not detailed_validation
             else IterableValidationError
         ):
             converter.structure(l, t)

tests/test_validation.py

@@ -11,7 +11,7 @@
 
 def test_class_validation():
     """Proper class validation errors are raised when structuring."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     @define
     class Test:
@@ -39,7 +39,7 @@ class Test:
 
 def test_list_validation():
     """Proper validation errors are raised structuring lists."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure(["1", 2, "a", 3.0, "c"], List[int])
@@ -57,7 +57,7 @@ def test_list_validation():
 
 def test_mapping_validation():
     """Proper validation errors are raised structuring mappings."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure({"1": 1, "2": "b", "c": 3}, Dict[int, int])
@@ -75,7 +75,7 @@ def test_mapping_validation():
 
 def test_set_validation():
     """Proper validation errors are raised structuring sets."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure({"1", 2, "a"}, Set[int])
@@ -88,7 +88,7 @@ def test_set_validation():
 
 def test_frozenset_validation():
     """Proper validation errors are raised structuring frozensets."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure({"1", 2, "a"}, FrozenSet[int])
@@ -101,7 +101,7 @@ def test_frozenset_validation():
 
 def test_homo_tuple_validation():
     """Proper validation errors are raised structuring homogenous tuples."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure(["1", 2, "a"], Tuple[int, ...])
@@ -117,7 +117,7 @@ def test_homo_tuple_validation():
 
 def test_hetero_tuple_validation():
     """Proper validation errors are raised structuring heterogenous tuples."""
-    c = GenConverter(extended_validation=True)
+    c = GenConverter(detailed_validation=True)
 
     with pytest.raises(IterableValidationError) as exc:
         c.structure(["1", 2, "a"], Tuple[int, int, int])