class UserSchema(Schema):
id = fields.Integer()
username = fields.String()
firstname = fields.String()
lastname = fields.String()
email = fields.String()
role = fields.Embed(schema=RoleSchema)
class ApiPlainKeySchema(Schema):
id = fields.Integer()
role = fields.Embed(schema=RoleSchema)
domains = fields.Embed(schema=DomainSchema, many=True)
accounts = fields.Embed(schema=AccountSummarySchema, many=True)
description = fields.String()
plain_key = fields.String()
class AccountSchema(Schema):
id = fields.Integer()
name = fields.String()
description = fields.String()
contact = fields.String()
mail = fields.String()
domains = fields.Embed(schema=DomainSchema, many=True)
class UserDetailedSchema(Schema):
id = fields.Integer()
username = fields.String()
firstname = fields.String()
lastname = fields.String()
email = fields.String()
role = fields.Embed(schema=RoleSchema)
accounts = fields.Embed(schema=AccountSummarySchema)
class SomeSchema(schema.Schema):
at__foo = fields.String(attr='foo')
dash__foo = fields.String(attr='foo')
dot__foo = fields.String(attr='foo')
hash__foo = fields.String(attr='foo')
plus__foo = fields.String(attr='foo')
nil__at__foo = fields.String(attr='foo')
nil__class = fields.String(attr='foo')
def test_schema_field_order_1(self):
'''Test if fields are in the expected order.'''
# this test is rather long. surely there is a better way to do this
field1 = fields.String()
field2 = fields.String()
field3 = fields.String()
field4 = fields.String()
field5 = fields.String()
field6 = fields.String()
field7 = fields.String()
field8 = fields.String()
field9 = fields.String()
# to test overrides
new_field4 = fields.String()
new_field5 = fields.String()
class TestSchema1(schema.Schema):
one = field1
two = field2
three = field3
four = field4
five = field5
test_instance1 = TestSchema1()
expected = OrderedDict([
('one', field1),
('two', field2),
('three', field3),
('four', field4),
('five', field5),
])
assert TestSchema1.__fields__ == expected
assert test_instance1._fields == expected
class TestMixin(schema.Schema):
five = new_field5
six = field6
# should NOT override TestSchema1's field5
class TestSchema2(TestSchema1, TestMixin):
pass
test_instance2 = TestSchema2()
expected = OrderedDict([
('one', field1),
('two', field2),
('three', field3),
('four', field4),
('five', field5),
('six', field6),
])
assert TestSchema2.__fields__ == expected
assert test_instance2._fields == expected
# SHOULD override TestSchema1's field5. Also, different order.
class TestSchema3(TestMixin, TestSchema1):
pass
test_instance3 = TestSchema3()
expected = OrderedDict([
('five', new_field5),
('six', field6),
('one', field1),
('two', field2),
('three', field3),
('four', field4),
])
assert TestSchema3.__fields__ == expected
assert test_instance3._fields == expected
class TestSchema4(TestSchema1):
four = new_field4 # this should replace inherited
six = field6 # this should land afterwards
seven = field7 # this should land afterwards
__lima_args__ = {
'include':
OrderedDict([
('five', new_field5), # this should replace inherited
('eight', field8), # this sould land afterwards
('nine', field9), # this sould land afterwards
])
}
test_instance4 = TestSchema4()
expected = OrderedDict([
('one', field1),
('two', field2),
('three', field3),
('four', new_field4),
('five', new_field5),
('six', field6),
('seven', field7),
('eight', field8),
('nine', field9),
])
assert TestSchema4.__fields__ == expected
assert test_instance4._fields == expected
# see if only/exclude don't mess up order
class TestSchema5(TestSchema1):
__lima_args__ = {'only': ['three', 'five', 'one']}
class TestSchema6(TestSchema1):
__lima_args__ = {'exclude': ['four', 'two']}
test_instance5 = TestSchema5()
test_instance6 = TestSchema6()
test_instance1a = TestSchema1(only=['three', 'five', 'one'])
test_instance1b = TestSchema1(exclude=['four', 'two'])
expected = OrderedDict([
('one', field1),
('three', field3),
('five', field5),
])
assert TestSchema5.__fields__ == expected
assert test_instance5._fields == expected
assert TestSchema6.__fields__ == expected
assert test_instance6._fields == expected
assert test_instance1a._fields == expected
assert test_instance1b._fields == expected
# see if include gets placed at the position of __lima_args__
class TestSchema7(schema.Schema):
one = field1
two = field2
__lima_args__ = {
'include': OrderedDict([('three', field3), ('four', field4)]),
'exclude': 'six'
}
five = field5
six = field6
seven = field7
test_instance7 = TestSchema7()
expected = OrderedDict([
('one', field1),
('two', field2),
('three', field3),
('four', field4),
('five', field5),
('seven', field7),
])
assert TestSchema7.__fields__ == expected
assert test_instance7._fields == expected
class FieldWithGetterArgSchema(schema.Schema):
full_name = fields.String(
get=lambda obj: '{} {}'.format(obj.title, obj.name))
def str_field():
return fields.String()
class ExoticFieldNamesSchema(schema.Schema):
__lima_args__ = {
'include':
{name: fields.String(attr='foo')
for name in exotic_names}
}
class KnightListSchema(schema.Schema):
title = fields.String(key=0)
name = fields.String(key=1)
number = fields.Integer(key=2)
born = fields.Date(key=3)
class CoverageSchema(Schema):
id = fields.String(attr='_id')
name = fields.String()
class EmbeddingSchema(schema.Schema):
another_field = fields.String()
# here we provide a schema _instance_. the kwarg "many" is unnecessary
incorrect_embed_field = fields.Embed(schema=embed_schema, many=True)
class TestSchema(schema.Schema):
foo = fields.String()
foo.attr = 'class' # 'class' is a keyword
class TestSchema(schema.Schema):
__lima_args__ = {
'include': {
'not;an-identifier': fields.String(attr='but_with_attr')
}
}
class NonLocalSchema(schema.Schema):
foo = fields.String()
class TestSchema(schema.Schema):
foo = fields.String()
foo.attr = 'this-is@not;an+identifier'
class AccountSummarySchema(Schema):
id = fields.Integer()
name = fields.String()
domains = fields.Embed(schema=DomainSchema, many=True)
class ApiKeySummarySchema(Schema):
id = fields.Integer()
description = fields.String()
class DomainSchema(Schema):
id = fields.Integer()
name = fields.String()
class AccountSummarySchema(Schema):
id = fields.Integer()
name = fields.String()
class ApiKeySchema(Schema):
id = fields.Integer()
role = fields.Embed(schema=RoleSchema)
domains = fields.Embed(schema=DomainSchema, many=True)
description = fields.String()
key = fields.String()
class RoleSchema(Schema):
id = fields.Integer()
name = fields.String()
class KnightSchema(schema.Schema):
title = fields.String()
name = fields.String()
number = fields.Integer()
born = fields.Date()
class TestSchema(schema.Schema):
__lima_args__ = {'include': {'not@an-identifier': fields.String()}}
class KnightDictSchema(schema.Schema):
title = fields.String(key='title')
name = fields.String(key='name')
number = fields.Integer(key='number')
born = fields.Date(key='born')
class TestSchema(schema.Schema):
__lima_args__ = {'include': {'class': fields.String()}}
class EmbedSchema(schema.Schema):
some_field = fields.String()
class TestSchema(schema.Schema):
foo = fields.String()
class SomeSchema(schema.Schema):
'''Schema for SomeClass (to test linked object fields).'''
name = fields.String()
number = fields.Integer()
