Tweak tests for coverage

Author: Tinche

src/cattrs/converters.py

@@ -281,7 +281,11 @@ def __init__(
                 (is_tuple, self._structure_tuple),
                 (is_namedtuple, namedtuple_structure_factory, "extended"),
                 (is_mapping, self._structure_dict),
-                (is_supported_union, self._gen_attrs_union_structure, True),
+                *(
+                    [(is_supported_union, self._gen_attrs_union_structure, True)]
+                    if unstruct_strat is UnstructureStrategy.AS_DICT
+                    else []
+                ),
                 (is_optional, self._structure_optional),
                 (
                     lambda t: is_union_type(t) and t in self._union_struct_registry,

tests/test_converter.py

@@ -267,24 +267,20 @@ def test_nested_roundtrip_tuple(cls_and_vals, omit_if_default: bool):
     assert inst == converter.structure(unstructured, cl)
 
 
-@settings(suppress_health_check=[HealthCheck.filter_too_much, HealthCheck.too_slow])
+@settings(suppress_health_check=[HealthCheck.too_slow])
 @given(
-    simple_typed_classes(defaults=False, newtypes=False, allow_nan=False),
-    simple_typed_classes(defaults=False, newtypes=False, allow_nan=False),
-    unstructure_strats,
+    simple_typed_classes(defaults=False, newtypes=False, allow_nan=False, min_attrs=2),
+    simple_typed_classes(defaults=False, newtypes=False, allow_nan=False, min_attrs=1),
 )
-def test_union_field_roundtrip(cl_and_vals_a, cl_and_vals_b, strat):
+def test_union_field_roundtrip_dict(cl_and_vals_a, cl_and_vals_b):
     """
     Classes with union fields can be unstructured and structured.
     """
-    converter = Converter(unstruct_strat=strat)
+    converter = Converter()
     cl_a, vals_a, kwargs_a = cl_and_vals_a
     cl_b, _, _ = cl_and_vals_b
-    assume(strat is UnstructureStrategy.AS_DICT or not kwargs_a)
     a_field_names = {a.name for a in fields(cl_a)}
     b_field_names = {a.name for a in fields(cl_b)}
-    assume(a_field_names)
-    assume(b_field_names)
 
     common_names = a_field_names & b_field_names
     assume(len(a_field_names) > len(common_names))
@@ -295,20 +291,44 @@ class C:
 
     inst = C(a=cl_a(*vals_a, **kwargs_a))
 
-    if strat is UnstructureStrategy.AS_DICT:
-        unstructured = converter.unstructure(inst)
-        assert inst == converter.structure(converter.unstructure(unstructured), C)
-    else:
-        # Our disambiguation functions only support dictionaries for now.
-        with pytest.raises(ValueError):
-            converter.structure(converter.unstructure(inst), C)
+    unstructured = converter.unstructure(inst)
+    assert inst == converter.structure(converter.unstructure(unstructured), C)
 
-        def handler(obj, _):
-            return converter.structure(obj, cl_a)
 
-        converter.register_structure_hook(Union[cl_a, cl_b], handler)
-        unstructured = converter.unstructure(inst)
-        assert inst == converter.structure(unstructured, C)
+@settings(suppress_health_check=[HealthCheck.too_slow])
+@given(
+    simple_typed_classes(
+        defaults=False, newtypes=False, allow_nan=False, kw_only=False, min_attrs=2
+    ),
+    simple_typed_classes(
+        defaults=False, newtypes=False, allow_nan=False, kw_only=False, min_attrs=1
+    ),
+)
+def test_union_field_roundtrip_tuple(cl_and_vals_a, cl_and_vals_b):
+    """
+    Classes with union fields can be unstructured and structured.
+    """
+    converter = Converter(unstruct_strat=UnstructureStrategy.AS_TUPLE)
+    cl_a, vals_a, _ = cl_and_vals_a
+    cl_b, _, _ = cl_and_vals_b
+
+    @define
+    class C:
+        a: Union[cl_a, cl_b]
+
+    inst = C(a=cl_a(*vals_a))
+
+    # Our disambiguation functions only support dictionaries for now.
+    raw = converter.unstructure(inst)
+    with pytest.raises(StructureHandlerNotFoundError):
+        converter.structure(raw, C)
+
+    def handler(obj, _):
+        return converter.structure(obj, cl_a)
+
+    converter.register_structure_hook(Union[cl_a, cl_b], handler)
+    unstructured = converter.unstructure(inst)
+    assert inst == converter.structure(unstructured, C)
 
 
 @pytest.mark.skipif(not is_py310_plus, reason="3.10+ union syntax")

tests/test_gen_dict.py

@@ -108,7 +108,9 @@ def test_nodefs_generated_unstructuring_cl(
 
 @given(
     one_of(just(BaseConverter), just(Converter)),
-    nested_classes() | simple_classes() | simple_typed_dataclasses(),
+    nested_classes()
+    | simple_classes(min_attrs=1)
+    | simple_typed_dataclasses(min_attrs=1),
 )
 def test_individual_overrides(converter_cls, cl_and_vals):
     """
@@ -118,7 +120,9 @@ def test_individual_overrides(converter_cls, cl_and_vals):
     converter = converter_cls()
     cl, vals, kwargs = cl_and_vals
 
-    for attr in adapted_fields(cl):
+    fields = adapted_fields(cl)
+
+    for attr in fields:
         if attr.default is not NOTHING:
             break
     else:
@@ -142,7 +146,7 @@ def test_individual_overrides(converter_cls, cl_and_vals):
     assert "Hyp" not in repr(res)
     assert "Factory" not in repr(res)
 
-    for attr, val in zip(adapted_fields(cl), vals):
+    for attr, val in zip(fields, vals):
         if attr.name == chosen_name:
             assert attr.name in res
         elif attr.default is not NOTHING:

tests/untyped.py

@@ -2,12 +2,12 @@
 
 import keyword
 import string
+from collections.abc import Iterable
 from enum import Enum
 from typing import (
     Any,
     Deque,
     Dict,
-    Iterable,
     List,
     Mapping,
     MutableMapping,
@@ -25,8 +25,6 @@
 from hypothesis.strategies import SearchStrategy, booleans
 from typing_extensions import TypeAlias
 
-from . import FeatureFlag
-
 PosArg = Any
 PosArgs = tuple[PosArg]
 KwArgs = dict[str, Any]
@@ -206,7 +204,7 @@ def key(t):
 
 def just_class(tup):
     nested_cl = tup[1][0]
-    default = attr.Factory(nested_cl)
+    default = Factory(nested_cl)
     combined_attrs = list(tup[0])
     combined_attrs.append((attr.ib(default=default), st.just(nested_cl())))
     return _create_hyp_class(combined_attrs)
@@ -288,7 +286,7 @@ def make_with_default(takes_self: bool) -> SearchStrategy[AttrsAndArgs]:
 
 def dict_of_class(tup):
     nested_cl = tup[1][0]
-    default = attr.Factory(lambda: {"cls": nested_cl()})
+    default = Factory(lambda: {"cls": nested_cl()})
     combined_attrs = list(tup[0])
     combined_attrs.append((attr.ib(default=default), st.just({"cls": nested_cl()})))
     return _create_hyp_class(combined_attrs)
@@ -404,7 +402,7 @@ def dict_attrs(draw, defaults=None, kw_only=None):
     val_strat = st.dictionaries(keys=st.text(), values=st.integers())
     if defaults is True or (defaults is None and draw(st.booleans())):
         default_val = draw(val_strat)
-        default = attr.Factory(lambda: default_val)
+        default = Factory(lambda: default_val)
     return (
         attr.ib(
             default=default, kw_only=draw(st.booleans()) if kw_only is None else kw_only
@@ -460,9 +458,7 @@ def simple_classes(defaults=None, min_attrs=0, frozen=None, kw_only=None):
     )
 
 
-def nested_classes(
-    takes_self: FeatureFlag = "sometimes",
-) -> SearchStrategy[AttrsAndArgs]:
+def nested_classes() -> SearchStrategy[AttrsAndArgs]:
     # Ok, so st.recursive works by taking a base strategy (in this case,
     # simple_classes) and a special function. This function receives a strategy,
     # and returns another strategy (building on top of the base strategy).