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_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_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_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(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()
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 test_simple_validation_shortcircuit():
Regular = Dict.of(Integer.using(optional=False))
el = Regular()
assert not el.validate()
def boom(element, state):
assert False
all_ok = lambda element, state: SkipAll
Boom = Integer.named(u'i').using(validators=[boom])
ShortCircuited = Dict.of(Boom).using(descent_validators=[all_ok])
el = ShortCircuited()
assert el.validate()
def test_simple_validation_shortcircuit():
Regular = Dict.of(Integer.using(optional=False))
el = Regular()
assert not el.validate()
def boom(element, state):
assert False
all_ok = lambda element, state: SkipAll
Boom = Integer.named(u'i').using(validators=[boom])
ShortCircuited = Dict.of(Boom).using(descent_validators=[all_ok])
el = ShortCircuited()
assert el.validate()
def test_no_duplicates_list_anon_dict():
nd = NotDuplicated(failure=u'%(container_label)s %(position)s')
schema = (List.named('test').
of(Dict.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_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_update_object():
class Obj(object):
def __init__(self, **kw):
for (k, v) in kw.items():
setattr(self, k, v)
schema = Dict.of(String.named(u'x'), String.named(u'y'))
o = Obj()
assert not hasattr(o, 'x')
assert not hasattr(o, 'y')
def updated_(obj_factory, initial_value, wanted=None, **update_kw):
el = schema(initial_value)
obj = obj_factory()
update_kw.setdefault('key', asciistr)
el.update_object(obj, **update_kw)
if wanted is None:
wanted = dict((asciistr(k), v) for k, v in initial_value.items())
have = dict(obj.__dict__)
assert have == wanted
updated_(Obj, {u'x': u'X', u'y': u'Y'})
updated_(Obj, {u'x': u'X'}, {'x': u'X', 'y': None})
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {'x': u'X', 'y': None})
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {
'x': u'X',
'y': u'Y'
},
omit=('y', ))
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {'y': u'Y'}, include=(u'z', ))
updated_(Obj, {u'x': u'X'}, {'y': None, 'z': u'X'}, rename=(('x', 'z'), ))
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_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
class PersonForm(FormView):
schema_type = Dict.of(
String.named('name'),
Integer.named('age'),
Boolean.named('friendly'),
)
def user_filter_form(values=None):
schema = Dict.of(
String.named(u'field1').using(optional=True), String.named(u'field2'))
if values is None:
values = {
u'field1': u'val',
}
el = schema(values)
el[u'field2'].errors.append(u'Missing')
def label_filter(tag, attrs, stream, context, el):
from genshi import QName
if el is None:
return tag, attrs, stream
content = stream.render()
if not content:
label = el.label
if not el.optional:
label += ' *'
stream = label
if not el.optional:
css = (attrs.get(u'class', u'') + u' required').strip()
attrs |= [(QName(u'class'), css)]
return tag, attrs, stream
label_filter.tags = (u'label', )
return dict(form=el, label_filter=label_filter)
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 user_filter_form(values=None):
schema = Dict.of(
String.named(u'field1').using(optional=True),
String.named(u'field2'))
if values is None:
values = {
u'field1': u'val',
}
el = schema(values)
el[u'field2'].errors.append(u'Missing')
def label_filter(tag, attrs, stream, context, el):
from genshi import QName
if el is None:
return tag, attrs, stream
content = stream.render()
if not content:
label = el.label
if not el.optional:
label += ' *'
stream = label
if not el.optional:
css = (attrs.get(u'class', u'') + u' required').strip()
attrs |= [(QName(u'class'), css)]
return tag, attrs, stream
label_filter.tags = (u'label',)
return dict(form=el, label_filter=label_filter)
def test_update_object():
class Obj(object):
def __init__(self, **kw):
for (k, v) in kw.items():
setattr(self, k, v)
schema = Dict.of(String.named(u'x'), String.named(u'y'))
o = Obj()
assert not hasattr(o, 'x')
assert not hasattr(o, 'y')
def updated_(obj_factory, initial_value, wanted=None, **update_kw):
el = schema(initial_value)
obj = obj_factory()
update_kw.setdefault('key', asciistr)
el.update_object(obj, **update_kw)
if wanted is None:
wanted = dict((asciistr(k), v) for k, v in initial_value.items())
have = dict(obj.__dict__)
assert have == wanted
updated_(Obj, {u'x': u'X', u'y': u'Y'})
updated_(Obj, {u'x': u'X'}, {'x': u'X', 'y': None})
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {'x': u'X', 'y': None})
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {'x': u'X', 'y': u'Y'},
omit=('y',))
updated_(lambda: Obj(y=u'Y'), {u'x': u'X'}, {'y': u'Y'},
include=(u'z',))
updated_(Obj, {u'x': u'X'}, {'y': None, 'z': u'X'},
rename=(('x', 'z'),))
def test_tuple_plural():
catalog = GetTextish()
schema = Dict.of(
String.named(u'name').using(validators=[LocalizedShort(2)]))
data = schema(dict(name=u'xxx'))
data.validate(catalog)
assert data[u'name'].errors == [u'plural NAME 2']
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 test_writable():
schema = Dict.of(Integer.named(u'main'),
Ref.named(u'aux').to(u'main').using(writable=True))
el = schema()
el[u'aux'] = 6
assert el[u'main'].value == 6
assert el[u'aux'].value == 6
def test_writable():
schema = Dict.of(Integer.named(u'main'),
Ref.named(u'aux').to(u'../main').using(writable=True))
el = schema()
el[u'aux'] = 6
assert el[u'main'].value == 6
assert el[u'aux'].value == 6
def test_descent(self):
schema = Dict.of(Integer).using(
descent_validators=[self.validator('1', True)])
el = schema()
assert not el.validate()
eq_(self.canary, ['1'])
assert el.valid
assert not el.all_valid
def test_not_writable():
schema = Dict.of(Integer.named(u'main'),
Ref.named(u'aux').to(u'main').using(writable=False))
el = schema()
with pytest.raises(TypeError):
el[u'aux'].set(6)
def test_compound_optional():
required = Dict.of(DateYYYYMMDD.named(u's').using(optional=False))
f = required.from_defaults()
assert not f.el(u's.year').optional
assert not f.el(u's.month').optional
assert not f.el(u's.day').optional
assert not f.validate()
optional = Dict.of(DateYYYYMMDD.named(u's').using(optional=True))
f = optional.from_defaults()
assert f.el(u's.year').optional
assert f.el(u's.month').optional
assert f.el(u's.day').optional
assert f.validate()
def test_tuple_plural():
catalog = GetTextish()
schema = Dict.of(String.named('name').
using(validators=[LocalizedShort(2)]))
data = schema(dict(name='xxx'))
data.validate(catalog)
assert data['name'].errors == [u'plural NAME 2']
def test_compound_optional():
required = Dict.of(DateYYYYMMDD.named(u's').using(optional=False))
f = required.from_defaults()
assert not f.find_one(u's/year').optional
assert not f.find_one(u's/month').optional
assert not f.find_one(u's/day').optional
assert not f.validate()
optional = Dict.of(DateYYYYMMDD.named(u's').using(optional=True))
f = optional.from_defaults()
assert f.find_one(u's/year').optional
assert f.find_one(u's/month').optional
assert f.find_one(u's/day').optional
assert f.validate()
def test_tuple_single():
catalog = GetTextish()
schema = Dict.of(
String.named('name').using(validators=[LocalizedShort(1)]))
data = schema(dict(name='xxx'))
data.validate(catalog)
assert data['name'].errors == [u'single NAME 1']
def test_descent(self):
schema = Dict.of(Integer).using(
descent_validators=[self.validator('1', True)])
el = schema()
assert not el.validate()
eq_(self.canary, ['1'])
assert el.valid
assert not el.all_valid
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_regular(self):
schema = (Dict.of(Integer).
using(validators=[self.validator('1', True)]))
el = schema()
assert not el.validate()
eq_(self.canary, ['1'])
assert el.valid
assert not el.all_valid
def test_paired2(self):
schema = Dict.of(Integer).using(
descent_validators=[self.validator('1', False)],
validators=[self.validator('2', True)])
el = schema()
assert not el.validate()
assert self.canary == ['1', '2']
assert not el.valid
assert not el.all_valid
def test_regular(self):
schema = (Dict.of(Integer).using(
validators=[self.validator('1', True)]))
el = schema()
assert not el.validate()
eq_(self.canary, ['1'])
assert el.valid
assert not el.all_valid
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_paired3(self):
schema = (Dict.of(
Integer.using(validators=[self.validator('2', True)])).using(
descent_validators=[self.validator('1', True)],
validators=[self.validator('3', True)]))
el = schema()
assert el.validate()
eq_(self.canary, ['1', '2', '3'])
assert el.valid
assert el.all_valid
def test_shortcircuit_up(self):
schema = (Dict.of(
Integer.using(validators=[self.validator('2', True)])).using(
descent_validators=[self.validator('1', True)],
validators=[self.validator('3', SkipAll)]))
el = schema()
assert el.validate()
eq_(self.canary, ['1', '2', '3'])
assert el.valid
assert el.all_valid
def test_regular_gettext():
catalog = GetTextish()
# translators placed at the top of the form
schema = Dict.of(String.named(u'age').using(validators=[Converted()])).\
using(ugettext=catalog.ugettext,
ungettext=catalog.ungettext)
data = schema()
data.validate()
assert data[u'age'].errors == [u'reg AGE']
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_local_gettext():
catalog = GetTextish()
# translators placed on a specific form element
schema = Dict.of(String.named('age').using(validators=[Converted()],
ugettext=catalog.ugettext,
ungettext=catalog.ungettext))
data = schema()
data.validate()
assert data['age'].errors == [u'reg AGE']
def test_regular_gettext():
catalog = GetTextish()
# translators placed at the top of the form
schema = Dict.of(String.named('age').using(validators=[Converted()])).\
using(ugettext=catalog.ugettext,
ungettext=catalog.ungettext)
data = schema()
data.validate()
assert data['age'].errors == [u'reg AGE']
def test_paired3(self):
schema = (
Dict.of(
Integer.using(validators=[self.validator('2', True)])).
using(
descent_validators=[self.validator('1', True)],
validators=[self.validator('3', True)]))
el = schema()
assert el.validate()
eq_(self.canary, ['1', '2', '3'])
assert el.valid
assert el.all_valid
def test_local_gettext():
catalog = GetTextish()
# translators placed on a specific form element
schema = Dict.of(
String.named(u'age').using(validators=[Converted()],
ugettext=catalog.ugettext,
ungettext=catalog.ungettext))
data = schema()
data.validate()
assert data[u'age'].errors == [u'reg AGE']
def test_shortcircuit_up(self):
schema = (
Dict.of(
Integer.using(validators=[self.validator('2', True)])).
using(
descent_validators=[self.validator('1', True)],
validators=[self.validator('3', SkipAll)]))
el = schema()
assert el.validate()
eq_(self.canary, ['1', '2', '3'])
assert el.valid
assert el.all_valid
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_shortcircuit_down_true(self):
schema = (
Dict.of(
Integer.using(validators=[self.validator('2', False)])).
using(
descent_validators=[self.validator('1', SkipAll)],
validators=[self.validator('3', True)]))
el = schema()
assert el.validate()
assert self.canary == ['1', '3']
assert el.valid
assert el.all_valid
def test_dict_strict():
# a mini test, this policy thing may get whacked
schema = Dict.using(policy='strict').of(Integer.named(u'x'),
Integer.named(u'y'))
el = schema({u'x': 123, u'y': 456})
el = schema()
assert_raises(TypeError, el.set, {u'x': 123})
el = schema()
assert_raises(KeyError, el.set, {u'x': 123, u'y': 456, u'z': 7})
def test_dict_strict():
# a mini test, this policy thing may get whacked
schema = Dict.using(policy='strict').of(Integer.named(u'x'),
Integer.named(u'y'))
el = schema({u'x': 123, u'y': 456})
el = schema()
assert_raises(TypeError, el.set, {u'x': 123})
el = schema()
assert_raises(KeyError, el.set, {u'x': 123, u'y': 456, u'z': 7})
def test_shortcircuit_down_false(self):
schema = (Dict.of(
Integer.named(u'i').using(
validators=[self.validator('2', True)])).using(
descent_validators=[self.validator('1', SkipAllFalse)],
validators=[self.validator('3', True)]))
el = schema()
assert not el.validate()
eq_(self.canary, ['1', '3'])
assert not el.valid
assert not el.all_valid
assert el[u'i'].valid is Unevaluated
def test_dict_immutable_keys():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
assert_raises(TypeError, el.__setitem__, u'z', 123)
assert_raises(TypeError, el.__delitem__, u'x')
assert_raises(KeyError, el.__delitem__, u'z')
assert_raises(TypeError, el.setdefault, u'x', 123)
assert_raises(TypeError, el.setdefault, u'z', 123)
assert_raises(TypeError, el.pop, u'x')
assert_raises(KeyError, el.pop, u'z')
assert_raises(TypeError, el.popitem)
assert_raises(TypeError, el.clear)
def test_shortcircuit_down_false(self):
schema = (
Dict.of(
Integer.named(u'i').using(
validators=[self.validator('2', True)])).
using(descent_validators=[self.validator('1', SkipAllFalse)],
validators=[self.validator('3', True)]))
el = schema()
assert not el.validate()
eq_(self.canary, ['1', '3'])
assert not el.valid
assert not el.all_valid
assert el[u'i'].valid is Unevaluated
def test_dict_immutable_keys():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
assert_raises(TypeError, el.__setitem__, u'z', 123)
assert_raises(TypeError, el.__delitem__, u'x')
assert_raises(KeyError, el.__delitem__, u'z')
assert_raises(TypeError, el.setdefault, u'x', 123)
assert_raises(TypeError, el.setdefault, u'z', 123)
assert_raises(TypeError, el.pop, u'x')
assert_raises(KeyError, el.pop, u'z')
assert_raises(TypeError, el.popitem)
assert_raises(TypeError, el.clear)
def test_state_gettext():
catalog = GetTextish()
schema = Dict.of(String.named('age').using(validators=[Converted()]))
# if state has ugettext or ungettext attributes, those will be used
data = schema()
data.validate(catalog)
assert data['age'].errors == [u'reg AGE']
# also works if state is dict-like
data = schema()
state = dict(ugettext=catalog.ugettext, ungettext=catalog.ungettext)
data.validate(state)
assert data['age'].errors == [u'reg AGE']
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_dereference_twice():
schema = Dict.of(Integer.named(u'main'),
Ref.named(u'aux').to(u'../main').using(writable=True))
# Previous revisions would fail after two dereferences
element = schema()
element[u'aux'] = 1
assert element[u'aux'].value == 1
element[u'aux'].set(1)
assert element[u'aux'].value == 1
assert element.find_one(element[u'aux'].target_path) is element[u'main']
assert element.find_one(element[u'aux'].target_path) is element[u'main']
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_state_gettext():
catalog = GetTextish()
schema = Dict.of(String.named(u'age').using(validators=[Converted()]))
# if state has ugettext or ungettext attributes, those will be used
data = schema()
data.validate(catalog)
assert data[u'age'].errors == [u'reg AGE']
# also works if state is dict-like
data = schema()
state = dict(ugettext=catalog.ugettext, ungettext=catalog.ungettext)
data.validate(state)
assert data[u'age'].errors == [u'reg AGE']
def test_dereference_twice():
schema = Dict.of(Integer.named(u'main'),
Ref.named(u'aux').to(u'main').using(writable=True))
# Previous revisions would fail after two dereferences
element = schema()
element[u'aux'] = 1
assert element[u'aux'].value == 1
element[u'aux'].set(1)
assert element[u'aux'].value == 1
assert element.el(element[u'aux'].target_path) is element[u'main']
assert element.el(element[u'aux'].target_path) is element[u'main']
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}
