def test_array_field_walk():
aa = fields.StringField()
a = fields.DictField(properties={'aa': aa})
b = fields.StringField()
c = fields.StringField()
array_field = fields.ArrayField((a, b), additional_items=c)
path = list(array_field.walk())
expected_path = [array_field, a, aa, b, c]
assert path == expected_path
array_field = fields.ArrayField(a, additional_items=False)
path = list(array_field.walk())
expected_path = [array_field, a, aa]
assert path == expected_path
def test_array_field_to_schema():
items_mock = fields.StringField()
additional_items_mock = fields.DictField()
f = fields.ArrayField(items_mock)
assert f.get_definitions_and_schema() == ({}, {
'type': 'array',
'items': items_mock.get_schema(),
})
expected_items = [
('type', 'array'),
('id', 'test'),
('title', 'Array'),
('items', items_mock.get_schema()),
('additionalItems', additional_items_mock.get_schema()),
('minItems', 0),
('maxItems', 10),
('uniqueItems', True),
]
f = fields.ArrayField(items_mock,
id='test',
title='Array',
min_items=0,
max_items=10,
unique_items=True,
additional_items=additional_items_mock)
assert f.get_definitions_and_schema() == ({}, dict(expected_items))
definitions, ordered_schema = f.get_definitions_and_schema(ordered=True)
assert isinstance(ordered_schema, OrderedDict)
assert ordered_schema == OrderedDict(expected_items)
f = fields.ArrayField(items_mock, additional_items=True)
assert f.get_definitions_and_schema() == ({}, {
'type': 'array',
'items': items_mock.get_schema(),
'additionalItems': True,
})
f = fields.ArrayField(items_mock, additional_items=additional_items_mock)
assert f.get_definitions_and_schema() == ({}, {
'type':
'array',
'items':
items_mock.get_schema(),
'additionalItems':
additional_items_mock.get_schema(),
})
item_1_mock = fields.NumberField()
item_2_mock = fields.ArrayField(fields.StringField())
f = fields.ArrayField([item_1_mock, item_2_mock])
assert f.get_definitions_and_schema() == ({}, {
'type':
'array',
'items': [item_1_mock.get_schema(),
item_2_mock.get_schema()],
})
def test_array_field_to_schema():
s_f = fields.StringField()
d_f = fields.DictField()
f = fields.ArrayField(s_f)
definitions, schema = f.get_definitions_and_schema()
assert normalize(schema) == {
'type': 'array',
'items': s_f.get_schema(),
}
expected_items = [
('type', 'array'),
('id', 'test'),
('title', 'Array'),
('items', s_f.get_schema()),
('additionalItems', d_f.get_schema()),
('minItems', 0),
('maxItems', 10),
('uniqueItems', True),
]
f = fields.ArrayField(s_f,
id='test',
title='Array',
min_items=0,
max_items=10,
unique_items=True,
additional_items=d_f)
definitions, schema = f.get_definitions_and_schema()
assert normalize(schema) == dict(expected_items)
definitions, ordered_schema = f.get_definitions_and_schema(ordered=True)
assert isinstance(ordered_schema, OrderedDict)
assert normalize(ordered_schema) == OrderedDict(expected_items)
f = fields.ArrayField(s_f, additional_items=True)
definitions, schema = f.get_definitions_and_schema()
assert normalize(schema) == {
'type': 'array',
'items': s_f.get_schema(),
'additionalItems': True,
}
f = fields.ArrayField(s_f, additional_items=d_f)
definitions, schema = f.get_definitions_and_schema()
assert normalize(schema) == {
'type': 'array',
'items': s_f.get_schema(),
'additionalItems': d_f.get_schema(),
}
n_f = fields.NumberField()
a_f = fields.ArrayField(fields.StringField())
f = fields.ArrayField([n_f, a_f])
definitions, schema = f.get_definitions_and_schema()
assert normalize(schema) == {
'type': 'array',
'items': [n_f.get_schema(), a_f.get_schema()],
}
def test_of_fields():
field_1_mock = fields.StringField()
field_2_mock = fields.BooleanField()
field_3_mock = fields.ArrayField(fields.IntField())
of_fields = [field_1_mock, field_2_mock, field_3_mock]
f = fields.OneOfField(of_fields)
_, schema = f.get_definitions_and_schema()
assert normalize(schema) == {'oneOf': [f.get_schema() for f in of_fields]}
f = fields.AnyOfField(of_fields)
_, schema = f.get_definitions_and_schema()
assert normalize(schema) == {'anyOf': [f.get_schema() for f in of_fields]}
f = fields.AllOfField(of_fields)
_, schema = f.get_definitions_and_schema()
assert normalize(schema) == {'allOf': [f.get_schema() for f in of_fields]}
class Tree(Document):
node = fields.OneOfField([
fields.ArrayField(fields.DocumentField('self')),
fields.StringField(),
])
