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_sparsedict_set_default():
schema = SparseDict.of(
Integer.named(u'x').using(default=123), Integer.named(u'y'))
el = schema()
el.set_default()
assert el.value == {}
def test_access():
pairs = ((u'l_0_i', u'10'), (u'l_1_i', u'11'), (u'l_2_i', u'12'),)
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema.from_flat(pairs)
elements = list(Integer.named(u'i')(val)
for val in (u'10', u'11', u'12'))
assert len(el) == 3
assert el[0] == elements[0]
assert el[1] == elements[1]
assert el[2] == elements[2]
assert el[0].value == 10
assert el[:0] == elements[:0]
assert el[:1] == elements[:1]
assert el[0:5] == elements[0:5]
assert el[-2:-1] == elements[-2:-1]
assert el[0] in el
assert elements[0] in el
assert u'10' in el
assert 10 in el
assert el.count(elements[0]) == 1
assert el.count(u'10') == 1
assert el.count(10) == 1
assert el.index(elements[0]) == 0
assert el.index(u'10') == 0
assert el.index(10) == 0
class Double(Compound):
field_schema = [Integer.named(u'x'), Integer.named(u'y')]
def compose(self):
ex, ey = self.get(u'x'), self.get(u'y')
ux, uy = ex.u, ey.u
if ex.u and ey.u:
string = u"%sx%s" % (ex.u, ey.u)
else:
string = u''
if ex.value is not None and ey.value is not None:
value = (ex.value, ey.value)
else:
value = None
return string, value
def explode(self, value):
if value == u'boom':
raise AttributeError('boom')
if value == u'return-none':
return
try:
x, y = value
except (TypeError, ValueError):
return False
res = True
res &= self[u'x'].set(x)
res &= self[u'y'].set(y)
return res
def test_sparsedict_set_default():
schema = SparseDict.of(Integer.named(u'x').using(default=123),
Integer.named(u'y'))
el = schema()
el.set_default()
assert el.value == {}
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_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_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_dsl_of():
assert_raises(TypeError, Sequence.of)
t1 = Sequence.of(Integer)
assert t1.member_schema is Integer
t2 = Sequence.of(Integer.named(u'x'), Integer.named(u'y'))
assert issubclass(t2.member_schema, Dict)
assert sorted(t2.member_schema().keys()) == [u'x', u'y']
def test_dsl_of():
assert_raises(TypeError, Sequence.of)
t1 = Sequence.of(Integer)
assert t1.member_schema is Integer
t2 = Sequence.of(Integer.named(u'x'), Integer.named(u'y'))
assert issubclass(t2.member_schema, Dict)
assert sorted(t2.member_schema().keys()) == [u'x', u'y']
def test_sparsedict_required_set_default():
schema = SparseDict.using(minimum_fields='required').\
of(Integer.named(u'x').using(default=123),
Integer.named(u'y').using(default=456,
optional=True),
Integer.named(u'z').using(optional=True))
el = schema()
el.set_default()
assert el.value == {u'x': 123}
def test_sparsedict_required_set_default():
schema = SparseDict.using(minimum_fields='required').\
of(Integer.named(u'x').using(default=123),
Integer.named(u'y').using(default=456,
optional=True),
Integer.named(u'z').using(optional=True))
el = schema()
el.set_default()
assert el.value == {u'x': 123}
def test_sparsedict_from_flat():
schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema.from_flat([])
assert el.items() == []
el = schema.from_flat([(u'x', u'123')])
assert el.value == {u'x': 123}
el = schema.from_flat([(u'x', u'123'), (u'z', u'456')])
assert el.value == {u'x': 123}
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 new_schema(self):
dictkw, x_kw, y_kw = {}, {}, {}
if self.policy is not Unspecified:
dictkw['policy'] = self.policy
if self.x_default is not Unspecified:
x_kw['default'] = self.x_default
if self.y_default is not Unspecified:
y_kw['default'] = self.y_default
return self.schema.named(u's').using(**dictkw).of(
Integer.named(u'x').using(**x_kw),
Integer.named(u'y').using(**y_kw))
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_sparsedict_from_flat():
schema = SparseDict.of(Integer.named(u'x'),
Integer.named(u'y'))
el = schema.from_flat([])
assert el.items() == []
el = schema.from_flat([(u'x', u'123')])
assert el.value == {u'x': 123}
el = schema.from_flat([(u'x', u'123'), (u'z', u'456')])
assert el.value == {u'x': 123}
def new_schema(self):
dictkw, x_kw, y_kw = {}, {}, {}
if self.policy is not Unspecified:
dictkw['policy'] = self.policy
if self.x_default is not Unspecified:
x_kw['default'] = self.x_default
if self.y_default is not Unspecified:
y_kw['default'] = self.y_default
return self.schema.named(u's').using(**dictkw).of(
Integer.named(u'x').using(**x_kw),
Integer.named(u'y').using(**y_kw))
def test_mutation():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema()
new_element = Integer.named(u'i')
def order_ok():
slot_names = list(_.name for _ in el._slots)
for idx, name in enumerate(slot_names):
assert name == str(idx).decode('ascii')
assert not el
order_ok()
# FIXME:? seems to want parsable data, not elements
el.append(new_element(u'0'))
assert el.value == [0]
order_ok()
el.append(u'123')
assert el.value == [0, 123]
order_ok()
el.extend([u'4', u'5'])
assert el.value == [0, 123, 4, 5]
order_ok()
el[0] = u'3'
assert el.value == [3, 123, 4, 5]
order_ok()
el.insert(0, u'2')
assert el.value == [2, 3, 123, 4, 5]
order_ok()
v = el.pop()
assert v.value == 5
assert not v.parent
order_ok()
v = el.pop(0)
assert v.value == 2
assert el.value == [3, 123, 4]
order_ok()
el.remove(u'3')
assert el.value == [123, 4]
order_ok()
del el[:]
assert el.value == []
order_ok()
def test_mutation():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema()
new_element = Integer.named(u'i')
def order_ok():
slot_names = list(_.name for _ in el._slots)
for idx, name in enumerate(slot_names):
assert name == str(idx).decode('ascii')
assert not el
order_ok()
# FIXME:? seems to want parsable data, not elements
el.append(new_element(u'0'))
assert el.value == [0]
order_ok()
el.append(u'123')
assert el.value == [0, 123]
order_ok()
el.extend([u'4', u'5'])
assert el.value == [0, 123, 4, 5]
order_ok()
el[0] = u'3'
assert el.value == [3, 123, 4, 5]
order_ok()
el.insert(0, u'2')
assert el.value == [2, 3, 123, 4, 5]
order_ok()
v = el.pop()
assert v.value == 5
assert not v.parent
order_ok()
v = el.pop(0)
assert v.value == 2
assert el.value == [3, 123, 4]
order_ok()
el.remove(u'3')
assert el.value == [123, 4]
order_ok()
del el[:]
assert el.value == []
order_ok()
def test_sparsedict_required_validation():
schema = SparseDict.of(Integer.named(u'x'),
Integer.named(u'y').using(optional=True)).\
using(minimum_fields='required')
el = schema()
assert not el.validate()
el = schema({u'y': 456})
assert not el.validate()
el = schema({u'x': 123, u'y': 456})
assert el.validate()
def test_sparsedict_required_from_flat():
schema = SparseDict.of(Integer.named(u'x'),
Integer.named(u'y').using(optional=True)).\
using(minimum_fields='required')
el = schema.from_flat([])
assert el.value == {u'x': None}
el = schema.from_flat([(u'x', u'123')])
assert el.value == {u'x': 123}
el = schema.from_flat([(u'y', u'456'), (u'z', u'789')])
assert el.value == {u'x': None, u'y': 456}
def test_sparsedict_required_validation():
schema = SparseDict.of(Integer.named(u'x'),
Integer.named(u'y').using(optional=True)).\
using(minimum_fields='required')
el = schema()
assert not el.validate()
el = schema({u'y': 456})
assert not el.validate()
el = schema({u'x': 123, u'y': 456})
assert el.validate()
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_sparsedict_required_from_flat():
schema = SparseDict.of(Integer.named(u'x'),
Integer.named(u'y').using(optional=True)).\
using(minimum_fields='required')
el = schema.from_flat([])
assert el.value == {u'x': None}
el = schema.from_flat([(u'x', u'123')])
assert el.value == {u'x': 123}
el = schema.from_flat([(u'y', u'456'), (u'z', u'789')])
assert el.value == {u'x': None, u'y': 456}
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 _populate_app_fields(self):
with WindowServiceProxy(59000) as w:
self.video_mode_map = w.get_video_mode_map()
if self.video_mode_map:
self._video_available = True
else:
self._video_available = False
self.video_mode_keys = sorted(self.video_mode_map.keys())
if self._video_available:
self.device_key, self.devices = w.get_video_source_configs()
field_list = [
Integer.named('overlay_opacity').using(default=50, optional=True),
Directory.named('device_directory').using(default='', optional=True),
String.named('transform_matrix').using(default='', optional=True,
properties={'show_in_gui':
False}), ]
if self._video_available:
video_mode_enum = Enum.named('video_mode').valued(
*self.video_mode_keys).using(default=self.video_mode_keys[0],
optional=True)
video_enabled_boolean = Boolean.named('video_enabled').using(
default=False, optional=True, properties={'show_in_gui': True})
recording_enabled_boolean = Boolean.named('recording_enabled').using(
default=False, optional=True, properties={'show_in_gui': False})
field_list.append(video_mode_enum)
field_list.append(video_enabled_boolean)
field_list.append(recording_enabled_boolean)
return Form.of(*field_list)
class PersonForm(FormView):
schema_type = Dict.of(
String.named('name'),
Integer.named('age'),
Boolean.named('friendly'),
)
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_reverse():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([2, 1])
assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
el.reverse()
assert el.value == [1, 2]
assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
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_set_flat_linear():
pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)]
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema.from_flat(pairs)
eq_(len(el), len(pairs))
eq_(el.value, list(pair[1] for pair in pairs))
def test_reverse():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([2, 1])
assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
el.reverse()
assert el.value == [1, 2]
assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
def test_set_flat_miss():
pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')]
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema.from_flat(pairs)
eq_(len(el), 0)
eq_(el.value, [])
def test_set_flat_linear():
pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)]
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema.from_flat(pairs)
eq_(len(el), len(pairs))
eq_(el.value, list(pair[1] for pair in pairs))
def test_set_flat_miss():
pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')]
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema.from_flat(pairs)
eq_(len(el), 0)
eq_(el.value, [])
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_slots():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([1, 2])
assert len(list(el._slots)) == 2
for slot in el._slots:
# don't really care what it says, just no crashy.
assert repr(slot)
assert [slot.value for slot in el._slots] == [1, 2]
def test_sparsedict_operations():
schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
el[u'x'] = 123
del el[u'x']
assert_raises(KeyError, el.__delitem__, u'x')
assert el.setdefault(u'x', 123) == 123
assert el.setdefault(u'x', 456) == 123
assert el.setdefault(u'y', 123) == 123
assert el.setdefault(u'y', 456) == 123
assert schema().is_empty
assert not schema().validate()
opt_schema = schema.using(optional=True)
assert opt_schema().validate()
def test_slots():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([1, 2])
assert len(list(el._slots)) == 2
for slot in el._slots:
# don't really care what it says, just no crashy.
assert repr(slot)
assert [slot.value for slot in el._slots] == [1, 2]
def test_sparsedict_operations():
schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
el[u'x'] = 123
del el[u'x']
assert_raises(KeyError, el.__delitem__, u'x')
assert el.setdefault(u'x', 123) == 123
assert el.setdefault(u'x', 456) == 123
assert el.setdefault(u'y', 123) == 123
assert el.setdefault(u'y', 456) == 123
assert schema().is_empty
assert not schema().validate()
opt_schema = schema.using(optional=True)
assert opt_schema().validate()
class Schema(Form):
i1 = Integer.using(default=0)
d1 = Dict.of(
Integer.named('d1i1').using(default=1),
Integer.named('d1i2').using(default=2))
l1 = List.using(default=2).of(Integer.named('l1i1').using(default=3))
l2 = List.using(default=3).of(
Integer.named('l2i1').using(default=4),
Integer.named('l2i2').using(default=5))
l3 = List.using(default=2).of(
List.named('l3l1').using(default=2).of(Integer.using(default=6)))
a1 = Array.using(default=[10, 11, 12, 13, 14, 15]).of(Integer)
dt1 = DateYYYYMMDD.using(default=date.today())
def test_dict_update():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
def value_dict(element):
return dict((k, v.value) for k, v in element.iteritems())
try:
el.update(x=20, y=30)
except UnicodeError:
assert not unicode_coercion_available()
el.update(udict(x=20, y=30))
assert udict(x=20, y=30) == el.value
el.update({u'y': 40})
assert udict(x=20, y=40) == el.value
el.update()
assert udict(x=20, y=40) == el.value
el.update((_, 100) for _ in u'xy')
assert udict(x=100, y=100) == el.value
try:
el.update([(u'x', 1)], y=2)
assert udict(x=1, y=2) == el.value
except UnicodeError:
assert not unicode_coercion_available()
try:
el.update([(u'x', 10), (u'y', 10)], x=20, y=20)
assert udict(x=20, y=20) == el.value
except UnicodeError:
assert not unicode_coercion_available()
if unicode_coercion_available():
assert_raises(TypeError, el.update, z=1)
assert_raises(TypeError, el.update, x=1, z=1)
assert_raises(TypeError, el.update, {u'z': 1})
assert_raises(TypeError, el.update, {u'x': 1, u'z': 1})
assert_raises(TypeError, el.update, ((u'z', 1), ))
assert_raises(TypeError, el.update, ((u'x', 1), (u'z', 1)))
def test_dict_update():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
def value_dict(element):
return dict((k, v.value) for k, v in element.iteritems())
try:
el.update(x=20, y=30)
except UnicodeError:
assert not unicode_coercion_available()
el.update(udict(x=20, y=30))
assert udict(x=20, y=30) == el.value
el.update({u'y': 40})
assert udict(x=20, y=40) == el.value
el.update()
assert udict(x=20, y=40) == el.value
el.update((_, 100) for _ in u'xy')
assert udict(x=100, y=100) == el.value
try:
el.update([(u'x', 1)], y=2)
assert udict(x=1, y=2) == el.value
except UnicodeError:
assert not unicode_coercion_available()
try:
el.update([(u'x', 10), (u'y', 10)], x=20, y=20)
assert udict(x=20, y=20) == el.value
except UnicodeError:
assert not unicode_coercion_available()
if unicode_coercion_available():
assert_raises(TypeError, el.update, z=1)
assert_raises(TypeError, el.update, x=1, z=1)
assert_raises(TypeError, el.update, {u'z': 1})
assert_raises(TypeError, el.update, {u'x': 1, u'z': 1})
assert_raises(TypeError, el.update, ((u'z', 1),))
assert_raises(TypeError, el.update, ((u'x', 1), (u'z', 1)))
def test_sparsedict_required_operations():
schema = SparseDict.using(minimum_fields='required').\
of(Integer.named(u'opt').using(optional=True),
Integer.named(u'req'))
el = schema({u'opt': 123, u'req': 456})
del el[u'opt']
assert_raises(KeyError, el.__delitem__, u'opt')
assert_raises(TypeError, el.__delitem__, u'req')
el = schema()
assert el.setdefault(u'opt', 123) == 123
assert el.setdefault(u'opt', 456) == 123
assert el.setdefault(u'req', 123) == 123
assert el.setdefault(u'req', 456) == 123
assert not schema().is_empty
assert not schema().validate()
def test_sort():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([2, 1])
el.sort(key=lambda el: el.value)
assert el.value == [1, 2]
assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
el.sort(key=lambda el: el.value, reverse=True)
assert el.value == [2, 1]
assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
def test_sparsedict_flattening():
schema = SparseDict.named(u'top').\
of(Integer.named(u'x'), Integer.named(u'y'))
els = [
schema({'x': 123, 'y': 456}),
schema(),
schema(),
schema(),
]
els[1].set({'x': 123, 'y': 456})
els[2]['x'] = 123
els[2]['y'] = 456
els[3]['x'] = Integer(123)
els[3]['y'] = Integer(456)
wanted = [(u'top_x', u'123'), (u'top_y', u'456')]
for el in els:
got = sorted(el.flatten())
assert wanted == got
def test_sparsedict_required_operations():
schema = SparseDict.using(minimum_fields='required').\
of(Integer.named(u'opt').using(optional=True),
Integer.named(u'req'))
el = schema({u'opt': 123, u'req': 456})
del el[u'opt']
assert_raises(KeyError, el.__delitem__, u'opt')
assert_raises(TypeError, el.__delitem__, u'req')
el = schema()
assert el.setdefault(u'opt', 123) == 123
assert el.setdefault(u'opt', 456) == 123
assert el.setdefault(u'req', 123) == 123
assert el.setdefault(u'req', 456) == 123
assert not schema().is_empty
assert not schema().validate()
def test_sparsedict_flattening():
schema = SparseDict.named(u'top').\
of(Integer.named(u'x'), Integer.named(u'y'))
els = [
schema({u'x': 123, u'y': 456}),
schema(),
schema(),
schema(),
]
els[1].set({u'x': 123, u'y': 456})
els[2][u'x'] = 123
els[2][u'y'] = 456
els[3][u'x'] = Integer(123)
els[3][u'y'] = Integer(456)
wanted = [(u'top_x', u'123'), (u'top_y', u'456')]
for el in els:
got = sorted(el.flatten())
assert wanted == got
def test_sort():
schema = List.named(u'l').of(Integer.named(u'i'))
el = schema([2, 1])
el.sort(key=lambda el: el.value)
assert el.value == [1, 2]
assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
el.sort(key=lambda el: el.value, reverse=True)
assert el.value == [2, 1]
assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
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_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_set_flat_unpruned():
pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')]
schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False)
el = schema.from_flat(pairs)
eq_(len(el), 4)
eq_(el.value, [0, None, None, 3])
schema2 = schema.using(maximum_set_flat_members=2)
el = schema2.from_flat(pairs)
eq_(len(el), 2)
eq_(el.value, [0, None])
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_dict_reads():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
el[u'x'].set(u'10')
el[u'y'].set(u'20')
eq_(el[u'x'].value, 10)
eq_(el[u'y'].value, 20)
# the values are unhashable Elements, so this is a little painful
assert set(el.keys()) == set(u'xy')
eq_(set([(u'x', 10), (u'y', 20)]),
set([(_[0], _[1].value) for _ in el.items()]))
eq_(set([10, 20]), set([_.value for _ in el.values()]))
eq_(el.get(u'x').value, 10)
el[u'x'] = None
eq_(el.get(u'x').value, None)
eq_(el.get(u'x', 'default is never used').value, None)
assert_raises(KeyError, el.get, u'z')
assert_raises(KeyError, el.get, u'z', 'even with a default')
def test_set_flat_unpruned():
pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')]
schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False)
el = schema.from_flat(pairs)
eq_(len(el), 4)
eq_(el.value, [0, None, None, 3])
schema2 = schema.using(maximum_set_flat_members=2)
el = schema2.from_flat(pairs)
eq_(len(el), 2)
eq_(el.value, [0, None])
def test_dict_reads():
schema = Dict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
el[u'x'].set(u'10')
el[u'y'].set(u'20')
eq_(el[u'x'].value, 10)
eq_(el[u'y'].value, 20)
# the values are unhashable Elements, so this is a little painful
assert set(el.keys()) == set(u'xy')
eq_(set([(u'x', 10), (u'y', 20)]),
set([(_[0], _[1].value) for _ in el.items()]))
eq_(set([10, 20]), set([_.value for _ in el.values()]))
eq_(el.get(u'x').value, 10)
el[u'x'] = None
eq_(el.get(u'x').value, None)
eq_(el.get(u'x', 'default is never used').value, None)
assert_raises(KeyError, el.get, u'z')
assert_raises(KeyError, el.get, u'z', 'even with a default')
