def test_structure_forward_ref(class_with_forward_ref_attr, strat):
"""
Classes with forward_ref field can be unstructured and structured.
"""
converter = Converter(unstruct_strat=strat)
unstructured_expected = converter.unstructure(class_with_forward_ref_attr)
structured = converter.structure(unstructured_expected, C)
unstructured_actual = converter.unstructure(structured)
assert structured == class_with_forward_ref_attr
assert unstructured_actual == unstructured_expected
def test_enum_unstructure(enum, dump_strat, data):
"""Dumping enums of primitives converts them to their primitives."""
converter = Converter(unstruct_strat=dump_strat)
member = data.draw(sampled_from(list(enum.__members__.values())))
assert converter.unstructure(member) == member.value
def test_mapping_unstructure(map_and_type, dump_strat):
"""Dumping a mapping of primitives is a simple copy operation."""
converter = Converter(unstruct_strat=dump_strat)
mapping = map_and_type[0]
dumped = converter.unstructure(mapping)
assert dumped == mapping
assert dumped is not mapping
assert type(dumped) is type(mapping)
def test_seq_of_simple_classes_unstructure(cls_and_vals, seq_type):
"""Dumping a sequence of primitives is a simple copy operation."""
converter = Converter()
inputs = seq_type(cl(*vals) for cl, vals in cls_and_vals)
outputs = converter.unstructure(inputs)
assert type(outputs) == seq_type
assert all(type(e) is dict for e in outputs)
def test_enum_unstructure(enum, dump_strat, choice):
# type: (EnumMeta, UnstructureStrategy) -> None
"""Dumping enums of primitives converts them to their primitives."""
converter = Converter(unstruct_strat=dump_strat)
member = choice(list(enum.__members__.values()))
assert converter.unstructure(member) == member.value
def test_set_unstructure(set_and_type, dump_strat):
"""Dumping a set of primitives is a simple copy operation."""
converter = Converter(unstruct_strat=dump_strat)
assert converter.unstruct_strat is dump_strat
set = set_and_type[0]
dumped = converter.unstructure(set)
assert dumped == set
if set:
assert dumped is not set
assert type(dumped) is type(set)
def test_seq_unstructure(seq_and_type, dump_strat):
"""Dumping a sequence of primitives is a simple copy operation."""
converter = Converter(unstruct_strat=dump_strat)
assert converter.unstruct_strat is dump_strat
seq = seq_and_type[0]
dumped = converter.unstructure(seq)
assert dumped == seq
if not isinstance(seq, tuple):
assert dumped is not seq
assert type(dumped) is type(seq)
def test_roundtrip(cl_and_vals):
"""We dump the class, then we load it."""
converter = Converter()
cl, vals = cl_and_vals
obj = cl(*vals)
dumped = converter.unstructure(obj)
loaded = converter.structure(dumped, cl)
assert obj == loaded
def test_unstructure_hooks(cl_and_vals):
"""
Unstructure hooks work.
"""
converter = Converter()
cl, vals = cl_and_vals
inst = cl(*vals)
converter.register_unstructure_hook(cl, lambda _: "test")
assert converter.unstructure(inst) == "test"
def enrich_unstructured_wildcat(converter: Converter, obj: WC,
unstructured_obj_dict: dict) -> dict:
wildcat_attrs_names = get_attrs_names(type(obj))
wildcat_nonattrs_dict = {
key: converter.unstructure(obj[key])
for key in obj if key not in wildcat_attrs_names
}
# note that typed entries take absolute precedence over untyped in case of collisions.
# these collisions should generally be prevented at runtime by the wildcat
# logic that is injected into the type, but if something were to sneak through
# we would prefer whatever had been set via the attribute.
return {**wildcat_nonattrs_dict, **unstructured_obj_dict}
def test_structure_union_explicit(cl_and_vals_a, cl_and_vals_b):
"""Structuring of manually-disambiguable unions works."""
converter = Converter()
cl_a, vals_a = cl_and_vals_a
cl_b, vals_b = cl_and_vals_b
def dis(obj, _):
return converter.structure(obj, cl_a)
converter.register_structure_hook(Union[cl_a, cl_b], dis)
inst = cl_a(*vals_a)
assert inst == converter.structure(converter.unstructure(inst),
Union[cl_a, cl_b])
def test_attrs_astuple_unstructure(nested_class):
# type: (Type) -> None
"""Our dumping should be identical to `attrs`."""
converter = Converter(unstruct_strat=UnstructureStrategy.AS_TUPLE)
instance = nested_class[0]()
assert converter.unstructure(instance) == astuple(instance)
def test_attrs_asdict_unstructure(nested_class):
"""Our dumping should be identical to `attrs`."""
converter = Converter()
instance = nested_class[0]()
assert converter.unstructure(instance) == asdict(instance)