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)
