Support to respect default values from attr class

cattr/converters.py

@@ -281,16 +281,16 @@ def structure_attrs_fromdict(self, obj, cl):
     def _structure_attr_from_dict(self, a, name, mapping):
         """Handle an individual attrs attribute structuring."""
         type_ = a.metadata.get(TYPE_METADATA_KEY)
+        val = mapping.get(name, a.default)
         if type_ is None:
             # No type.
-            return mapping[name]
+            return val
         if _is_union_type(type_):
-            # This is a union.
-            val = mapping.get(name, NOTHING)
+
             if NoneType in type_.__args__ and val is NOTHING:
                 return None
             return self._structure_union(val, type_)
-        return self._structure.dispatch(type_)(mapping.get(a.name), type_)
+        return self._structure.dispatch(type_)(val, type_)
 
     def _structure_list(self, obj, cl):
         # type: (Type[GenericMeta], Iterable[T]) -> List[T]

tests/metadata/test_roundtrips.py

@@ -2,14 +2,14 @@
 import attr
 import pytest
 
-from attr import fields
+from attr import fields, make_class
 from hypothesis import assume, given
 from hypothesis.strategies import sampled_from
 
 from cattr import UnstructureStrategy, typed
 from typing import Union, Optional
 
-from . import simple_typed_classes, nested_typed_classes
+from . import simple_typed_classes, nested_typed_classes, simple_typed_attrs
 
 unstructure_strats = sampled_from(list(UnstructureStrategy))
 
@@ -25,6 +25,20 @@ def test_simple_roundtrip(converter, cls_and_vals, strat):
     assert inst == converter.structure(converter.unstructure(inst), cl)
 
 
+@given(simple_typed_attrs(defaults=True), unstructure_strats)
+def test_simple_roundtrip_defaults(converter, cls_and_vals, strat):
+    """
+    Simple classes with metadata can be unstructured and restructured.
+    """
+    a, _ = cls_and_vals
+    cl = make_class("HypClass", {"a": a})
+    converter.unstruct_strat = strat
+    inst = cl()
+    assert converter.unstructure(converter.structure(
+        {}, cl)) == converter.unstructure(inst)
+    assert inst == converter.structure(converter.unstructure(inst), cl)
+
+
 @given(nested_typed_classes, unstructure_strats)
 def test_nested_roundtrip(converter, cls_and_vals, strat):
     """

tests/test_structure_attrs.py

@@ -1,10 +1,10 @@
 """Loading of attrs classes."""
-from attr import asdict, astuple, fields
+from attr import asdict, astuple, fields, make_class
 from hypothesis import assume, given
 
 from typing import Union
 
-from . import simple_classes
+from . import simple_classes, simple_attrs
 
 
 @given(simple_classes())
@@ -20,6 +20,16 @@ def test_structure_simple_from_dict(converter, cl_and_vals):
     assert obj == loaded
 
 
+@given(simple_attrs(defaults=True))
+def test_structure_simple_from_dict_default(converter, cl_and_vals):
+    """Test structuring non-nested attrs classes with default value."""
+    a, _ = cl_and_vals
+    cl = make_class("HypClass", {"a": a})
+    obj = cl()
+    loaded = converter.structure({}, cl)
+    assert obj == loaded
+
+
 @given(simple_classes())
 def test_roundtrip(converter, cl_and_vals):
     # type: (Converter, Any) -> None