def test_mixed_all_children():
data = {u'A1': u'1',
u'A2': u'2',
u'A3': {u'A3B1': {u'A3B1C1': u'1',
u'A3B1C2': u'2'},
u'A3B2': {u'A3B2C1': u'1'},
u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'],
[u'A3B3C1D0', u'A3B3C1D1'],
[u'A3B3C2D0', u'A3B3C2D1']]}}
schema = (
Dict.named(u'R').of(
String.named(u'A1'),
String.named(u'A2'),
Dict.named(u'A3').of(
Dict.named(u'A3B1').of(
String.named(u'A3B1C1'),
String.named(u'A3B1C2')),
Dict.named(u'A3B2').of(
String.named(u'A3B2C1')),
List.named(u'A3B3').of(
List.named(u'A3B3Cx').of(
String.named(u'A3B3x'))))))
top = schema(data)
names = list(e.name for e in top.all_children)
assert set(names[0:3]) == set([u'A1', u'A2', u'A3'])
assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3'])
assert set(names[6:12]) == set([u'A3B1C1', u'A3B1C2',
u'A3B2C1', u'A3B3Cx'])
assert set(names[12:]) == set([u'A3B3x'])
assert len(names[12:]) == 6
def test_path():
schema = Dict.named(u'root').of(
String.named(u'element'),
Dict.named(u'dict').of(String.named(u'dict_element')))
element = schema()
eq_(list(element.find_one([u'dict', u'dict_element']).path),
[element, element[u'dict'], element[u'dict'][u'dict_element']])
def test_path():
schema = Dict.named('root').of(
String.named('element'),
Dict.named('dict').of(String.named('dict_element')))
element = schema()
assert (list(element.el(['dict', 'dict_element']).path) ==
[element, element['dict'], element['dict']['dict_element']])
def test_path():
schema = Dict.named('root').of(
String.named('element'),
Dict.named('dict').of(String.named('dict_element')))
element = schema()
eq_(list(element.el(['dict', 'dict_element']).path),
[element, element['dict'], element['dict']['dict_element']])
def elements():
from flatland import Dict, String
anon = Dict.of(String.named(u'anon_field'))()
named = Dict.named(u'named').of(String.named(u'named_field'))()
prefixed = Dict.named(u'prefixed').of(String.named(u'prefixed_field'))()
prefixed.set_prefix(u'three.levels.down')
return {'form': anon,
'forms': {'named': named },
'three': {'levels': {'down': prefixed}}}
def shadow():
schema = Dict.named(u'dict_name').of(String.named(u'name'),
String.named(u'u'))
element = schema({u'name': u'string name', u'u': u'string u'})
element.set_prefix(u'top')
return {'top': element, 'bound': element.bind}
def test_set_with_all():
Int = Integer.using(optional=True)
schema = (Dict.named(u'point').of(
Int.named(u'x'),
Int.named(u'y')).using(policy=None).validated_by(SetWithAllFields()))
# no coverage of set_flat
el = schema.from_flat([(u'point_x', u'1'), (u'point_Z', u'3')])
assert el.value == {u'x': 1, u'y': None}
assert el.validate()
el = schema({u'x': 1, u'Z': 3})
assert el.value == {u'x': 1, u'y': None}
assert not el.validate()
assert el.errors == [u'point must contain y and not contain Z']
el = schema({u'x': 1, u'y': 2, u'Z': 3, u'A': 4})
assert el.value == {u'x': 1, u'y': 2}
assert not el.validate()
assert el.errors == [u'point may not contain A, Z']
el = schema({u'x': 1})
assert el.value == {u'x': 1, u'y': None}
assert not el.validate()
assert el.errors == [u'point must contain y']
def test_naming_dict():
for name, root_flat, leaf_flat in ((u'd', u'd', u'd_s'),
(None, u'', u's')):
schema = Dict.named(name).of(String.named(u's'))
root = schema()
leaf = root[u's']
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.s'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.s') is leaf
assert root.el(u's') is leaf
assert leaf.el(u'.s') is leaf
with pytest.raises(LookupError):
leaf.el(u's')
assert leaf.el(u'.') is root
assert root.el([Root]) is root
assert root.el([u's']) is leaf
assert root.el([Root, u's']) is leaf
assert root.el(iter([u's'])) is leaf
assert root.el(iter([Root, u's'])) is leaf
def test_nested_dict_as_unicode():
schema = Dict.of(Dict.named(u'd').of(
Integer.named(u'x').using(default=10)))
el = schema.from_defaults()
eq_(el.value, {u'd': {u'x': 10}})
eq_(el.u, u"{u'd': {u'x': u'10'}}")
def test_nested_dict_as_unicode():
schema = Dict.of(
Dict.named(u'd').of(Integer.named(u'x').using(default=10)))
el = schema.from_defaults()
eq_(el.value, {u'd': {u'x': 10}})
eq_(el.u, u"{u'd': {u'x': u'10'}}")
def test_dict_el():
# stub
schema = Dict.named(u's').of(Integer.named(u'x'), Integer.named(u'y'))
element = schema()
assert element.el(u'x').name == u'x'
assert_raises(KeyError, element.el, u'not_x')
def test_dict_el():
# stub
schema = Dict.named(u's').of(Integer.named(u'x'), Integer.named(u'y'))
element = schema()
assert element.el(u'x').name == u'x'
assert_raises(KeyError, element.el, u'not_x')
def test_no_duplicates_list_dict():
nd = NotDuplicated(failure=u'%(container_label)s %(position)s')
schema = (List.named('test').
of(Dict.named('xyz').
of(Integer.named('x'),
Integer.named('y')).
using(validators=[nd])))
_test_no_duplicates(schema, {'x': 1, 'y': 2}, {'x': 3, 'y': 4})
def test_dict_find():
# stub
schema = Dict.named(u's').of(Integer.named(u'x'), Integer.named(u'y'))
element = schema()
assert element.find_one(u'x').name == u'x'
assert element.find_one(u'/x').name == u'x'
assert_raises(LookupError, element.find_one, u'not_x')
def shadow():
schema = Dict.named(u'dict_name').of(
String.named(u'name'),
String.named(u'u'))
element = schema({u'name': u'string name',
u'u': u'string u'})
element.set_prefix(u'top')
return {'top': element, 'bound': element.bind}
def elements():
from flatland import Dict, String
anon = Dict.of(String.named(u'anon_field'))()
named = Dict.named(u'named').of(String.named(u'named_field'))()
prefixed = Dict.named(u'prefixed').of(
String.named(u'prefixed_field'))()
prefixed.set_prefix(u'three.levels.down')
return {
'form': anon,
'forms': {
'named': named
},
'three': {
'levels': {
'down': prefixed
}
}
}
def test_naming_dict_dict():
for name, root_flat, leaf_flat in ((u'd', u'd', u'd_d2_s'), (None, u'',
u'd2_s')):
schema = Dict.named(name).of(Dict.named(u'd2').of(String.named(u's')))
root = schema()
leaf = root[u'd2'][u's']
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.d2.s'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.d2.s') is leaf
assert root.el(u'd2.s') is leaf
assert leaf.el(u'.d2.s') is leaf
assert_raises(LookupError, leaf.el, u'd2.s')
assert leaf.el(u'.') is root
assert root.el([u'd2', u's']) is leaf
def test_naming_dict_dict():
for name, root_flat, leaf_flat in ((u'd', u'd', u'd_d2_s'),
(None, u'', u'd2_s')):
schema = Dict.named(name).of(
Dict.named(u'd2').of(String.named(u's')))
root = schema()
leaf = root[u'd2'][u's']
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.d2.s'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.d2.s') is leaf
assert root.el(u'd2.s') is leaf
assert leaf.el(u'.d2.s') is leaf
assert_raises(LookupError, leaf.el, u'd2.s')
assert leaf.el(u'.') is root
assert root.el([u'd2', u's']) is leaf
def test_mixed_all_children():
data = {
u'A1': u'1',
u'A2': u'2',
u'A3': {
u'A3B1': {
u'A3B1C1': u'1',
u'A3B1C2': u'2'
},
u'A3B2': {
u'A3B2C1': u'1'
},
u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'], [u'A3B3C1D0', u'A3B3C1D1'],
[u'A3B3C2D0', u'A3B3C2D1']]
}
}
schema = (Dict.named(u'R').of(
String.named(u'A1'), String.named(u'A2'),
Dict.named(u'A3').of(
Dict.named(u'A3B1').of(String.named(u'A3B1C1'),
String.named(u'A3B1C2')),
Dict.named(u'A3B2').of(String.named(u'A3B2C1')),
List.named(u'A3B3').of(
List.named(u'A3B3Cx').of(String.named(u'A3B3x'))))))
top = schema(data)
names = list(e.name for e in top.all_children)
assert set(names[0:3]) == set([u'A1', u'A2', u'A3'])
assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3'])
assert set(names[6:12]) == set(
[u'A3B1C1', u'A3B1C2', u'A3B2C1', u'A3B3Cx'])
assert set(names[12:]) == set([u'A3B3x'])
assert len(names[12:]) == 6
def form():
schema = Dict.named(u'field0').of(
String.named(u'field1'), String.named(u'field2'),
List.named(u'field3').of(String.named(u'field4')),
List.named(u'field5').of(
List.named(u'field6').of(String.named(u'field7'))))
element = schema({
u'field1': u'val1',
u'field2': u'val2',
u'field3': [u'val3'],
u'field5': [[u'val4']]
})
element.set_prefix(u'form')
return {'form': element, 'bound': element.bind}
def form():
schema = Dict.named(u'field0').of(
String.named(u'field1'),
String.named(u'field2'),
List.named(u'field3').of(String.named(u'field4')),
List.named(u'field5').of(
List.named(u'field6').of(String.named(u'field7'))))
element = schema(
{u'field1': u'val1',
u'field2': u'val2',
u'field3': [u'val3'],
u'field5': [[u'val4']]})
element.set_prefix(u'form')
return {'form': element, 'bound': element.bind}
def test_naming_dict():
for name, root_flat, leaf_flat in ((u'd', u'd', u'd_s'), (None, u'',
u's')):
schema = Dict.named(name).of(String.named(u's'))
root = schema()
leaf = root[u's']
assert root.fq_name() == u'/'
assert root.flattened_name() == root_flat
assert root.find_one(u'.') is root
assert leaf.fq_name() == u'/s'
assert leaf.flattened_name() == leaf_flat
assert root.find_one(u'/s') is leaf
assert root.find_one(u's') is leaf
assert leaf.find_one(u'/s') is leaf
assert_raises(LookupError, leaf.find_one, u's')
assert leaf.find_one(u'/') is root
assert root.find_one([u's']) is leaf
assert root.find_one(iter([u's'])) is leaf
def test_nested_unicode_dict_as_unicode():
schema = Dict.of(
Dict.named(u'd').of(String.named(u'x').using(default=u'\u2308\u2309')))
el = schema.from_defaults()
eq_(el.value, {u'd': {u'x': u'\u2308\u2309'}})
eq_(el.u, ur"{u'd': {u'x': u'\u2308\u2309'}}")
def test_dict():
s = Dict.named('dict').of(String.named('k1'),
String.named('k2'))
el = s()
assert s
assert el
class Bundle(Import):
def adapt(self, value):
return Import.adapt(self,
'glashammer.bundles.%s.setup_%s' % (value, value))
Url = Dict.of(
String.named('url'),
String.named('endpoint'),
Import.named('view').using(optional=True),
)
Urls = List.of(Url)
Config = Dict.named('config').of(Dict)
Settings = Dict.of(Element)
TemplateSearchPaths = List.of(String)
TemplateFilter = Dict.of(
Import.named('filter'),
String.named('name'),
)
TemplateFilters = List.of(TemplateFilter)
SharedPath = Dict.of(
String.named('name'),
String.named('path'),
def test_dict():
s = Dict.named('dict').of(String.named('k1'),
String.named('k2'))
el = s()
assert s
assert el
def test_path():
schema = Dict.named("root").of(String.named("element"), Dict.named("dict").of(String.named("dict_element")))
element = schema()
eq_(list(element.el(["dict", "dict_element"]).path), [element, element["dict"], element["dict"]["dict_element"]])
def test_nested_unicode_dict_as_unicode():
schema = Dict.of(Dict.named(u'd').of(
String.named(u'x').using(default=u'\u2308\u2309')))
el = schema.from_defaults()
eq_(el.value, {u'd': {u'x': u'\u2308\u2309'}})
eq_(el.u, ur"{u'd': {u'x': u'\u2308\u2309'}}")
def test_no_duplicates_list_dict():
nd = NotDuplicated(failure=u'%(container_label)s %(position)s')
schema = (List.named(u'test').of(
Dict.named(u'xyz').of(Integer.named(u'x'),
Integer.named(u'y')).using(validators=[nd])))
_test_no_duplicates(schema, {u'x': 1, u'y': 2}, {u'x': 3, u'y': 4})
def test_dict():
s = Dict.named("dict").of(String.named("k1"), String.named("k2"))
el = s()
assert s
assert el
