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_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_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'}}")
class PersonForm(FormView):
schema_type = Dict.of(
String.named('name'),
Integer.named('age'),
Boolean.named('friendly'),
)
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_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 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 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_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_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_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_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_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_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_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_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_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 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_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_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_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_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_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_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_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_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(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.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_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 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 small_form(values=None):
SmallForm = Dict.of(String.named(u'field1'), String.named(u'field2'),
Boolean.named(u'toggle1'), Boolean.named(u'toggle2'),
Array.named(u'multi').of(String),
DateYYYYMMDD.named(u'date1'))
if values is None:
values = {
u'field1': u'val',
u'toggle2': True,
u'multi': [u'a', u'b'],
u'date1': datetime.date(1999, 12, 31),
}
el = SmallForm(values)
return {'form': el}
def test_dict_raw():
schema = Dict.of(Integer.named('x').using(optional=False))
el = schema()
assert el.raw is Unset
el = schema({u'x': u'bar'})
assert el.raw == {u'x': u'bar'}
el = schema([(u'x', u'bar')])
assert el.raw == [(u'x', u'bar')]
el.set_flat([(u'x', u'123')])
assert el.raw is Unset
el = schema.from_flat([(u'x', u'123')])
assert el.raw is Unset
assert el[u'x'].raw == u'123'
def test_dict_raw():
schema = Dict.of(Integer.named('x').using(optional=False))
el = schema()
assert el.raw is Unset
el = schema({u'x': u'bar'})
assert el.raw == {u'x': u'bar'}
el = schema([(u'x', u'bar')])
assert el.raw == [(u'x', u'bar')]
el.set_flat([(u'x', u'123')])
assert el.raw is Unset
el = schema.from_flat([(u'x', u'123')])
assert el.raw is Unset
assert el[u'x'].raw == u'123'
def test_local_gettext_search_is_not_overeager():
catalog = GetTextish()
def poison(*a):
assert False
# if a translator is found on an element, its parents won't be searched
schema = (Dict.of(
String.named(u'age').using(validators=[Converted()],
ugettext=catalog.ugettext,
ungettext=catalog.ungettext)).using(
ugettext=poison, ungettext=poison))
data = schema()
data.validate()
assert data[u'age'].errors == [u'reg AGE']
def test_local_gettext_search_is_not_overeager():
catalog = GetTextish()
def poison(*a):
assert False
# if a translator is found on an element, its parents won't be searched
schema = (Dict.of(String.named('age').
using(validators=[Converted()],
ugettext=catalog.ugettext,
ungettext=catalog.ungettext)).
using(ugettext=poison,
ungettext=poison))
data = schema()
data.validate()
assert data['age'].errors == [u'reg AGE']
def test_builtin_gettext():
catalog = GetTextish()
schema = Dict.of(String.named('age').using(validators=[Converted()]))
data = schema()
try:
# translators can go into the builtins
from six.moves import builtins
builtins.ugettext = catalog.ugettext
builtins.ungettext = catalog.ungettext
data.validate()
assert data['age'].errors == [u'reg AGE']
finally:
del builtins.ugettext
del builtins.ungettext
def test_builtin_gettext():
catalog = GetTextish()
schema = Dict.of(String.named(u'age').using(validators=[Converted()]))
data = schema()
try:
# translators can go into the builtins
import __builtin__
__builtin__.ugettext = catalog.ugettext
__builtin__.ungettext = catalog.ungettext
data.validate()
assert data[u'age'].errors == [u'reg AGE']
finally:
del __builtin__.ugettext
del __builtin__.ungettext
def test_values_equal_resolution():
v = ValuesEqual('x', '/sub/xx')
el = form(dict(x='a', sub=dict(xx='a')))
assert v.validate(el, None)
v = ValuesEqual('/x', 'xx')
el = form(dict(x='a', sub=dict(xx='a')))
assert v.validate(el['sub'], None)
# unhashable
v = ValuesEqual('a', 'b')
schema = Dict.of(List.named('a').of(String.named('x')),
List.named('b').of(String.named('x')))
el = schema(dict(a=['a', 'b'], b=['a', 'b']))
assert v.validate(el, None)
el = schema(dict(a=['a', 'b'], b=['x', 'y']))
assert not v.validate(el, None)
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_set_signal():
data = []
sentinel = lambda sender, adapted: data.append((sender, adapted))
schema = Dict.of(Integer.named(u'x'))
schema({u'x': 0})
with element_set.connected_to(sentinel):
schema({u'x': 1})
schema({u'x': u'bogus'})
assert len(data) == 4 # Integer, Dict, Integer, Dict
assert data[1][0].value == {u'x': 1}
assert data[1][1] is True
assert data[2][0].raw == u'bogus'
assert data[2][1] is False
assert data[3][1] is False
def small_form(values=None):
SmallForm = Dict.of(
String.named(u'field1'),
String.named(u'field2'),
Boolean.named(u'toggle1'),
Boolean.named(u'toggle2'),
Array.named(u'multi').of(String),
DateYYYYMMDD.named(u'date1'))
if values is None:
values = {
u'field1': u'val',
u'toggle2': True,
u'multi': [u'a', u'b'],
u'date1': datetime.date(1999, 12, 31),
}
el = SmallForm(values)
return {'form': el}
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_slice():
schema = Dict.of(String.named(u'x'), String.named(u'y'))
def same_(source, kw):
el = schema(source)
sliced = el.slice(**kw)
wanted = dict(keyslice_pairs(el.value.items(), **kw))
eq_(sliced, wanted)
eq_(set(type(_) for _ in sliced.keys()),
set(type(_) for _ in wanted.keys()))
yield same_, {u'x': u'X', u'y': u'Y'}, {}
yield same_, {u'x': u'X', u'y': u'Y'}, dict(key=asciistr)
yield same_, {u'x': u'X', u'y': u'Y'}, dict(include=[u'x'])
yield same_, {u'x': u'X', u'y': u'Y'}, dict(omit=[u'x'])
yield same_, {u'x': u'X', u'y': u'Y'}, dict(omit=[u'x'],
rename={u'y': u'z'})
def test_slice():
schema = Dict.of(String.named(u'x'), String.named(u'y'))
def same_(source, kw):
el = schema(source)
sliced = el.slice(**kw)
wanted = dict(keyslice_pairs(el.value.items(), **kw))
eq_(sliced, wanted)
eq_(set(type(_) for _ in sliced.keys()),
set(type(_) for _ in wanted.keys()))
yield same_, {u'x': u'X', u'y': u'Y'}, {}
yield same_, {u'x': u'X', u'y': u'Y'}, dict(key=asciistr)
yield same_, {u'x': u'X', u'y': u'Y'}, dict(include=[u'x'])
yield same_, {u'x': u'X', u'y': u'Y'}, dict(omit=[u'x'])
yield same_, {u'x': u'X', u'y': u'Y'}, dict(omit=[u'x'],
rename={u'y': u'z'})
def test_values_equal_resolution():
v = ValuesEqual('x', '/sub/xx')
el = form(dict(x='a', sub=dict(xx='a')))
assert v.validate(el, None)
v = ValuesEqual('/x', 'xx')
el = form(dict(x='a', sub=dict(xx='a')))
assert v.validate(el['sub'], None)
# unhashable
v = ValuesEqual('a', 'b')
schema = Dict.of(List.named('a').of(String.named('x')),
List.named('b').of(String.named('x')))
el = schema(dict(a=['a', 'b'], b=['a', 'b']))
assert v.validate(el, None)
el = schema(dict(a=['a', 'b'], b=['x', 'y']))
assert not v.validate(el, None)
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_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_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')
