def test_nested_api_fields(self):
family_fields = {
'father': fields.Nested(person_fields),
'mother': fields.Nested(person_fields),
}
result = mask.apply(family_fields, 'father{name},mother{age}')
assert set(result.keys()) == set(['father', 'mother'])
assert isinstance(result['father'], fields.Nested)
assert set(result['father'].nested.keys()) == set(['name'])
assert isinstance(result['mother'], fields.Nested)
assert set(result['mother'].nested.keys()) == set(['age'])
data = {
'father': {
'name': 'John',
'age': 42
},
'mother': {
'name': 'Jane',
'age': 42
},
}
expected = {'father': {'name': 'John'}, 'mother': {'age': 42}}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family_fields), data)
def test_multiple_nested_api_fields(self):
level_2 = {'nested_2': fields.Nested(person_fields)}
level_1 = {'nested_1': fields.Nested(level_2)}
root = {'nested': fields.Nested(level_1)}
result = mask.apply(root, 'nested{nested_1{nested_2{name}}}')
assert set(result.keys()) == set(['nested'])
assert isinstance(result['nested'], fields.Nested)
assert set(result['nested'].nested.keys()) == set(['nested_1'])
data = {
'nested': {
'nested_1': {
'nested_2': {
'name': 'John',
'age': 42
}
}
}
}
expected = {'nested': {'nested_1': {'nested_2': {'name': 'John'}}}}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, root), data)
def test_list_fields_with_nested_inherited(self, app):
api = Api(app)
person = api.model('Person', {
'name': fields.String,
'age': fields.Integer
})
child = api.inherit('Child', person, {
'attr': fields.String
})
family = api.model('Family', {
'children': fields.List(fields.Nested(child))
})
result = mask.apply(family.resolved, 'children{name,attr}')
data = {'children': [
{'name': 'John', 'age': 5, 'attr': 'value-john'},
{'name': 'Jane', 'age': 42, 'attr': 'value-jane'},
]}
expected = {'children': [
{'name': 'John', 'attr': 'value-john'},
{'name': 'Jane', 'attr': 'value-jane'},
]}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family), data)
def test_list_fields_with_nested(self):
family_fields = {'members': fields.List(fields.Nested(person_fields))}
result = mask.apply(family_fields, 'members{name}')
assert set(result.keys()) == set(['members'])
assert isinstance(result['members'], fields.List)
assert isinstance(result['members'].container, fields.Nested)
assert set(result['members'].container.nested.keys()) == set(['name'])
data = {
'members': [
{
'name': 'John',
'age': 42
},
{
'name': 'Jane',
'age': 42
},
]
}
expected = {'members': [{'name': 'John'}, {'name': 'Jane'}]}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family_fields), data)
def test_marshal_handle_inheritance(self, app):
api = Api(app)
person = api.model('Person', {
'name': fields.String,
'age': fields.Integer,
})
child = api.inherit('Child', person, {
'extra': fields.String,
})
data = {'name': 'John Doe', 'age': 42, 'extra': 'extra'}
values = (
('name', {
'name': 'John Doe'
}),
('name,extra', {
'name': 'John Doe',
'extra': 'extra'
}),
('extra', {
'extra': 'extra'
}),
)
for value, expected in values:
result = marshal(data, child, mask=value)
assert result == expected
def test_marshal(self):
model = OrderedDict([('foo', fields.Raw)])
marshal_dict = OrderedDict([('foo', 'bar'), ('bat', 'baz')])
output = marshal(marshal_dict, model)
assert isinstance(output, dict)
assert not isinstance(output, OrderedDict)
assert output == {'foo': 'bar'}
def test_list_fields_with_raw(self):
family_fields = {
'members': fields.List(fields.Raw)
}
result = mask.apply(family_fields, 'members{name}')
data = {'members': [
{'name': 'John', 'age': 42},
{'name': 'Jane', 'age': 42},
]}
expected = {'members': [{'name': 'John'}, {'name': 'Jane'}]}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family_fields), data)
def test_marshal_wildcard_with_skip_none(self):
wild = fields.Wildcard(fields.String)
model = OrderedDict([('foo', fields.Raw), ('*', wild)])
marshal_dict = OrderedDict([('foo', None), ('bat', None),
('baz', 'biz'), ('bar', None)])
output = marshal(marshal_dict, model, skip_none=True)
assert output == {'baz': 'biz'}
def test_list_fields_with_simple_field(self):
family_fields = {
'name': fields.String,
'members': fields.List(fields.String)
}
result = mask.apply(family_fields, 'members')
assert set(result.keys()) == set(['members'])
assert isinstance(result['members'], fields.List)
assert isinstance(result['members'].container, fields.String)
data = {'name': 'Doe', 'members': ['John', 'Jane']}
expected = {'members': ['John', 'Jane']}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family_fields), data)
def test_raw_api_fields(self):
family_fields = {
'father': fields.Raw,
'mother': fields.Raw,
}
result = mask.apply(family_fields, 'father{name},mother{age}')
data = {
'father': {'name': 'John', 'age': 42},
'mother': {'name': 'Jane', 'age': 42},
}
expected = {'father': {'name': 'John'}, 'mother': {'age': 42}}
assert_data(marshal(data, result), expected)
# Should leave th original mask untouched
assert_data(marshal(data, family_fields), data)
def test_marshal_list_of_lists(self):
model = OrderedDict([('foo', fields.Raw),
('fee', fields.List(fields.List(fields.String)))])
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'),
('fee', [['fye'], ['fum']])])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'), ('fee', [['fye'], ['fum']])])
assert output == expected
def test_marshal_nested_with_skip_none(self):
model = OrderedDict([('foo', fields.Raw),
('fee',
fields.Nested(OrderedDict([('fye', fields.String)
]),
skip_none=True))])
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'),
('fee', None)])
output = marshal(marshal_fields, model, skip_none=True)
expected = OrderedDict([('foo', 'bar')])
assert output == expected
def test_marshal_list_of_nesteds(self):
model = OrderedDict([('foo', fields.Raw),
('fee',
fields.List(fields.Nested({'fye':
fields.String})))])
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'),
('fee', {
'fye': 'fum'
})])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'),
('fee', [OrderedDict([('fye', 'fum')])])])
assert output == expected
def test_marshal_nested_with_null(self):
model = OrderedDict([
('foo', fields.Raw),
('fee',
fields.Nested(OrderedDict([('fye', fields.String),
('blah', fields.String)]),
allow_null=True))
])
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'),
('fee', None)])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'), ('fee', None)])
assert output == expected
def test_marshal_nested_dict(self):
model = OrderedDict([
('foo', fields.Raw),
('bar', OrderedDict([
('a', fields.Raw),
('b', fields.Raw),
])),
])
marshal_fields = OrderedDict([('foo', 'foo-val'), ('bar', 'bar-val'),
('bat', 'bat-val'), ('a', 1), ('b', 2),
('c', 3)])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'foo-val'),
('bar', OrderedDict([('a', 1), ('b', 2)]))])
assert output == expected
def test_marshal_wildcard_with_envelope(self):
wild = fields.Wildcard(fields.String)
model = OrderedDict([('foo', fields.Raw), ('*', wild)])
marshal_dict = OrderedDict([('foo', {
'bat': 'baz'
}), ('a', 'toto'), ('b', 'tata')])
output = marshal(marshal_dict, model, envelope='hey')
assert output == {
'hey': {
'a': 'toto',
'b': 'tata',
'foo': {
'bat': 'baz'
}
}
}
def test_skip_none_presents_data(self):
model = OrderedDict([
('foo', fields.Raw),
('fee',
fields.Nested(OrderedDict([('fye', fields.String),
('blah', fields.String),
('foe', fields.String)]),
skip_none=True))
])
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'),
('fee', {
'blah': 'cool',
'foe': None
})])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'),
('fee', OrderedDict([('blah', 'cool')]))])
assert output == expected
def test_marshal_nested_ordered(self):
model = OrderedDict([('foo', fields.Raw),
('fee', fields.Nested({
'fye': fields.String,
}))])
marshal_fields = {
'foo': 'bar',
'bat': 'baz',
'fee': {
'fye': 'fum'
},
}
expected = OrderedDict([('foo', 'bar'),
('fee', OrderedDict([('fye', 'fum')]))])
output = marshal(marshal_fields, model, ordered=True)
assert isinstance(output, OrderedDict)
assert output == expected
assert isinstance(output['fee'], OrderedDict)
def test_marshal_nested(self):
model = {
'foo': fields.Raw,
'fee': fields.Nested({'fye': fields.String}),
}
marshal_fields = {
'foo': 'bar',
'bat': 'baz',
'fee': {
'fye': 'fum'
},
}
expected = {
'foo': 'bar',
'fee': {
'fye': 'fum'
},
}
output = marshal(marshal_fields, model)
assert output == expected
def test_marshal_nested_property_with_skip_none(self):
class TestObject(object):
@property
def fee(self):
return {'blah': 'cool', 'foe': None}
model = OrderedDict([
('foo', fields.Raw),
('fee',
fields.Nested(OrderedDict([('fye', fields.String),
('blah', fields.String),
('foe', fields.String)]),
skip_none=True))
])
obj = TestObject()
obj.foo = 'bar'
obj.bat = 'baz'
output = marshal([obj], model)
expected = [
OrderedDict([('foo', 'bar'),
('fee', OrderedDict([('blah', 'cool')]))])
]
assert output == expected
async def get(self, request):
return marshal({"foo": 3.0}, self.fields)
def test_marshal_field(self):
model = OrderedDict({'foo': fields.Raw()})
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz')])
output = marshal(marshal_fields, model)
assert output == {'foo': 'bar'}
def test_marshal_tuple(self):
model = OrderedDict({'foo': fields.Raw})
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz')])
output = marshal((marshal_fields, ), model)
assert output == [{'foo': 'bar'}]
def test_marshal_tuple_with_envelope(self):
model = OrderedDict({'foo': fields.Raw})
marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz')])
output = marshal((marshal_fields, ), model, envelope='hey')
assert output == {'hey': [{'foo': 'bar'}]}
def marshal_simple_with_mask(app):
with app.test_request_context('/', headers={'X-Fields': 'name'}):
return marshal(person(), person_fields)
def marshal_nested():
return marshal(family(), family_fields)
def marshal_nested_with_mask(app):
with app.test_request_context(
'/', headers={'X-Fields': 'father,children{name}'}):
return marshal(family(), family_fields)
def test_marshal_with_skip_none(self):
model = OrderedDict([('foo', fields.Raw), ('bat', fields.Raw),
('qux', fields.Raw)])
marshal_dict = OrderedDict([('foo', 'bar'), ('bat', None)])
output = marshal(marshal_dict, model, skip_none=True)
assert output == {'foo': 'bar'}
def test_marshal_with_envelope(self):
model = OrderedDict([('foo', fields.Raw)])
marshal_dict = OrderedDict([('foo', 'bar'), ('bat', 'baz')])
output = marshal(marshal_dict, model, envelope='hey')
assert output == {'hey': {'foo': 'bar'}}
def get(self):
return marshal({"foo": 3.0}, self.fields)
