def test_back_and_forth(): class Object1(object): c = 'b' class Object2(object): a = 2 b = Object1() d = [Object1(), Object1()] obj = Object2() serializer1 = serializer( field('c') ) serializer3 = serializer( field('a'), child('b', serializer=serializer1), many('d', serializer=serializer1), ) json_data = {'a': 2, 'b': {'c': 'b'}, 'd': [{'c': 'b'}, {'c': 'b'}]} serialized_data = serializer3.serialize(obj) assert serialized_data == json_data assert serialized_data == serializer3.deserialize(json_data)
def test_validation_strings(): a_field = field('a', validators=[validators.required(), validators.string()]) f_field = field('f', validators=[validators.required()]) g_field = field('g') a_serializer = serializer( a_field, f_field, g_field, ) from_json = { 'a': 1, 'f': [], } with pytest.raises(ValidationException) as exc_info: a_serializer.deserialize(from_json) assert hasattr(exc_info.value, 'errors') assert exc_info.value.errors == { 'f': ['This field is required'], }
def test_field(): serializer = field('a') test_obj = TestObject() target = {} serializer.serialize(test_obj, target) assert {'a': 1} == target from_json = {'a': 1} target = {} serializer.deserialize(from_json, target) assert {'a': 1} == target serializer = field('empty') test_obj = TestObject() target = {} serializer.serialize(test_obj, target) assert {"empty": None} == target serializer = field('empty') test_obj = TestObject() target = {} serializer.serialize(test_obj, target, serialization_context) assert {} == target
def test_many(): child_serializer = serializer( field('c1') ) a_serializer = serializer( field('a'), many('c', serializer=child_serializer) ) a_dict_serializer = serializer( dict_field('a'), many('c', serializer=child_serializer, attr_getter=lambda x: x.get('c')) ) test_obj = TestObject() target = a_serializer.serialize(test_obj) target2 = a_dict_serializer.serialize(TestObject.__dict__) reference = { 'a': 1, 'c': [{ 'c1': 'a', }, { 'c1': 'a', }] } assert reference == target == target2 target = a_serializer.deserialize(reference) assert target == reference
def test_validation_strings(): a_field = field('a', validators=[validators.required(), validators.string()]) f_field = field('f', validators=[validators.required()]) g_field = field('g') a_serializer = serializer( a_field, f_field, g_field, ) from_json = { 'a': 1, 'f': [], } try: a_serializer.deserialize(from_json) except Exception as e: assert hasattr(e, 'errors') assert e.errors == { 'f': ['This field is required'], }
def test_child(): child_serializer = serializer(field('b1')) a_serializer = serializer(field('a'), child('b', serializer=child_serializer)) a_dict_serializer = serializer( dict_field('a'), child('b', serializer=child_serializer, attr_getter=lambda x: x.get('b'))) test_obj = TestObject() target = a_serializer.serialize(test_obj) target2 = a_dict_serializer.serialize(test_obj.__class__.__dict__) assert { 'a': 1, 'b': { 'b1': 2, } } == target == target2 from_json = { 'a': 1, 'b': { 'b1': 2, } } target = a_serializer.deserialize(from_json) assert from_json == target
def test_docs(): artist_serializer = serializer( field('name', validators=[validators.required()])) album_schema = serializer( field('title', validators=[validators.required()]), field('release_date', validators=[validators.required(), validators.datetime()], formatters=[formatters.format_datetime()]), child('artist', serializer=artist_serializer, validators=[validators.required()])) class Artist(object): def __init__(self, name): self.name = name class Album(object): def __init__(self, title, release_date, artist): self.title = title self.release_date = release_date self.artist = artist bowie = Artist(name='David Bowie') album = Album(artist=bowie, title='Hunky Dory', release_date=datetime.datetime(1971, 12, 17)) assert album_schema.serialize(album) == { 'artist': { 'name': 'David Bowie' }, 'release_date': '1971-12-17T00:00:00', 'title': 'Hunky Dory' } assert album_schema.deserialize(album_schema.serialize(album)) == { 'artist': { 'name': 'David Bowie' }, 'release_date': datetime.datetime(1971, 12, 17, 0, 0, tzinfo=iso8601.UTC), 'title': 'Hunky Dory' } input = album_schema.serialize(album) del input['artist'] errors = None try: album_schema.deserialize(input) except Exception as e: errors = e.errors assert errors == {'artist': ['This field is required']}
def test_field_custom_attr_gettr(): serializer = field('a', attr_getter=lambda x: x.a + 1) test_obj = TestObject() target = {} serializer.serialize(test_obj, target) assert {'a': 2} == target
def test_empty_child(): child_serializer = serializer( field('b1'), field('c1'), ) a_serializer = serializer(field('a'), child('b2', serializer=child_serializer)) test_obj = TestObject() target = a_serializer.serialize(test_obj) assert target == {'a': 1, 'b2': {'b1': None, 'c1': None}} target = a_serializer.serialize(test_obj, context=serialization_context) assert target == {'a': 1}
def test_nested_required(): child_serializer = serializer( field('c1', validators=[validators.required()]) ) a_serializer = serializer( field('a'), many('c', serializer=child_serializer, validators=[validators.required()]) ) reference = { 'a': 1, } with pytest.raises(ValidationException): a_serializer.deserialize(reference) reference = { 'a': 1, 'c': [], } errors = None try: a_serializer.deserialize(reference) except ValidationException as e: errors = e.errors assert errors == {'c': {'_full_errors': ['This field is required']}} reference = { 'a': 1, 'c': [{}], } errors = None try: a_serializer.deserialize(reference) except ValidationException as e: errors = e.errors assert errors == {'c': {0: {'c1': ['This field is required']}}}
def test_serializer(): a_serializer = serializer(field('a')) test_obj = TestObject() target = a_serializer.serialize(test_obj) assert {'a': 1} == target from_json = {'a': 1} target == a_serializer.deserialize(from_json) assert {'a': 1} == target
def test_field_multiple_validation(): serializer = field('e', multiple=True, validators=[validators.string(max_length=1)]) test_obj = { 'e': ['a', 'bb'] } target = {} errors = None try: serializer.deserialize(test_obj, target) except ValidationException as e: errors = e.errors assert errors == {'e': {1: ['This field is to long, max length is 1']}}
def test_field_multiple(): serializer = field('d', multiple=True) test_obj = TestObject() target = {} serializer.serialize(test_obj, target) assert {'d': [1, 2]} == target from_json = {'d': [1, 2]} target = {} serializer.deserialize(from_json, target) assert {'d': [1, 2]} == target
def test_field(): serializer = field('a') test_obj = TestObject() target = {} serializer.serialize(test_obj, target) assert {'a': 1} == target from_json = {'a': 1} target = {} serializer.deserialize(from_json, target) assert {'a': 1} == target
d = ChildTestObject() e = [ChildTestObject(), ChildTestObject()] def valid_validator(value, context=None): return def nil_validator(value, context=None): raise ValidationException('Failed') def nil_validator_2(value, context=None): raise ValidationException('Failed, again') a_field = field('a', validators=[valid_validator, nil_validator, nil_validator_2]) b_field = field('b', validators=[valid_validator, nil_validator]) c_field = field('c', validators=[valid_validator]) d1_field = field('d1', validators=[valid_validator]) d2_field = field('d2', validators=[valid_validator, nil_validator]) a_serializer = serializer( a_field, b_field, c_field, ) d_serializer = serializer( d1_field, d2_field, )
import strainer __name__ = 'Strainer' sub_strainer_serializer = strainer.serializer( strainer.field('w'), strainer.field('x', attr_getter=lambda obj: obj.x + 10), strainer.field('y'), strainer.field('z'), ) complex_strainer_serializer = strainer.serializer( strainer.field('foo'), strainer.field('bar', attr_getter=lambda obj: obj.bar()), strainer.child('sub', serializer=sub_strainer_serializer), strainer.many('subs', serializer=sub_strainer_serializer), ) def serialization_func(obj, many): if many: return [complex_strainer_serializer.serialize(x) for x in obj] else: return complex_strainer_serializer.serialize(obj)