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_push_unknown():
ctx = Context()
needle = 'xyzzy'
assert needle not in _default_context.keys()
assert_raises(KeyError, ctx.push, **{needle: Nothing})
assert_raises(RuntimeError, ctx.pop)
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_el():
schema = Array.of(String.named(u's'))
element = schema(u'abc')
eq_(list(element.value), [u'a', u'b', u'c'])
eq_(element.el(u'0').value, u'a')
eq_(element.el(u'2').value, u'c')
assert_raises(KeyError, element.el, u'a')
def test_read_write_unknown():
ctx = Context()
needle = u'xyzzy'
assert needle not in _default_context.keys()
assert needle not in ctx
assert_raises(KeyError, lambda: ctx[needle])
assert_raises(KeyError, ctx.__setitem__, needle, Nothing)
def test_find():
schema = Array.of(String.named(u's'))
element = schema(u'abc')
eq_(list(element.value), [u'a', u'b', u'c'])
eq_(element.find_one(u'0').value, u'a')
eq_(element.find_one(u'2').value, u'c')
assert_raises(LookupError, element.find_one, u'a')
def test_read_write_unknown():
ctx = Context()
needle = 'xyzzy'
assert needle not in _default_context.keys()
assert needle not in ctx
assert_raises(KeyError, lambda: ctx[needle])
assert_raises(KeyError, ctx.__setitem__, needle, Nothing)
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_naming_bogus():
e = String(name=u's')
assert e.el(u'.') is e
assert_raises(LookupError, e.el, u'')
assert_raises(TypeError, e.el, None)
assert_raises(LookupError, e.el, ())
assert_raises(LookupError, e.el, iter(()))
assert_raises(TypeError, e.el)
def test_push_unknown():
ctx = Context()
needle = u'xyzzy'
needle_attribute = 'xyzzy' # native text type
assert needle not in _default_context.keys()
assert_raises(KeyError, ctx.push, **{needle_attribute: Nothing})
assert_raises(RuntimeError, ctx.pop)
def test_naming_bogus():
e = String(name=u's')
assert e.el(u'.') is e
assert_raises(LookupError, e.el, u'')
assert_raises(TypeError, e.el, None)
assert_raises(LookupError, e.el, ())
assert_raises(LookupError, e.el, iter(()))
assert_raises(TypeError, e.el)
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_bogus_tags():
for snippet in [
u'<form:auto-name/>',
u'<form:auto-value/>',
u'<form:auto-domid/>',
u'<form:auto-for/>',
u'<form:auto-tabindex/>',
]:
assert_raises(TemplateSyntaxError, render, snippet, 'xml', schema)
def test_bogus_tags():
for snippet in [
u'<form:auto-name/>',
u'<form:auto-value/>',
u'<form:auto-domid/>',
u'<form:auto-for/>',
u'<form:auto-tabindex/>',
]:
assert_raises(TemplateSyntaxError, render, snippet, u'xml', schema)
def test_dsl_descent_validated_by():
s = Sequence.using(descent_validators=(123, 456))
eq_(s.descent_validators, (123, 456))
s = Sequence.descent_validated_by(123, 456)
eq_(s.descent_validators, [123, 456])
s = Sequence.using(descent_validators=(123, 456)).descent_validated_by(789)
eq_(s.descent_validators, [789])
assert_raises(TypeError, Sequence.descent_validated_by, int)
def test_dsl_descent_validated_by():
s = Sequence.using(descent_validators=(123, 456))
eq_(s.descent_validators, (123, 456))
s = Sequence.descent_validated_by(123, 456)
eq_(s.descent_validators, [123, 456])
s = Sequence.using(descent_validators=(123, 456)).descent_validated_by(789)
eq_(s.descent_validators, [789])
assert_raises(TypeError, Sequence.descent_validated_by, int)
def test_dsl_validated_by():
s = Element.using(validators=(123, 456))
eq_(s.validators, [123, 456])
s = Element.validated_by(123, 456)
eq_(s.validators, [123, 456])
s = Element.using(validators=(123, 456)).validated_by(789)
eq_(s.validators, [789])
assert_raises(TypeError, Element.validated_by, int)
def test_dsl_validated_by():
s = Element.using(validators=(123, 456))
eq_(s.validators, [123, 456])
s = Element.validated_by(123, 456)
eq_(s.validators, [123, 456])
s = Element.using(validators=(123, 456)).validated_by(789)
eq_(s.validators, [789])
assert_raises(TypeError, Element.validated_by, int)
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_naming_shallow():
root = String(name=u's')
assert root.fq_name() == u'.'
assert root.flattened_name() == u's'
assert root.el(u'.') is root
root = String(name=None)
assert root.fq_name() == u'.'
assert root.flattened_name() == u''
assert root.el(u'.') is root
assert_raises(LookupError, root.el, ())
assert root.el([Root]) is root
def test_naming_shallow():
root = String(name=u's')
assert root.fq_name() == u'.'
assert root.flattened_name() == u's'
assert root.el(u'.') is root
root = String(name=None)
assert root.fq_name() == u'.'
assert root.flattened_name() == u''
assert root.el(u'.') is root
assert_raises(LookupError, root.el, ())
assert root.el([Root]) is root
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_find_strict_loose():
el = Schema.from_defaults()
_cases = [
(el, 'bogus'),
(el, '/d1/d1i3'),
(el, 'l1[5]'),
(el, 'l3[:]/missing'),
]
for element, path in _cases:
assert_raises(LookupError, element.find, path)
found = element.find(path, strict=False)
assert not found
def test_find_strict_loose():
el = Schema.from_defaults()
_cases = [
(el, 'bogus'),
(el, '/d1/d1i3'),
(el, 'l1[5]'),
(el, 'l3[:]/missing'),
]
for element, path in _cases:
assert_raises(LookupError, element.find, path)
found = element.find(path, strict=False)
assert not found
def test_stack_plain_push_pop():
ctx = Context()
needle, initial_value = _default_context.items()[0]
assert ctx[needle] == initial_value
ctx.push()
assert ctx[needle] == initial_value
ctx[needle] = Nothing
assert ctx[needle] is Nothing
ctx.pop()
assert ctx[needle] is not Nothing
assert ctx[needle] == initial_value
assert_raises(RuntimeError, ctx.pop)
def test_stack_plain_push_pop():
ctx = Context()
needle, initial_value = _default_context.items()[0]
assert ctx[needle] == initial_value
ctx.push()
assert ctx[needle] == initial_value
ctx[needle] = Nothing
assert ctx[needle] is Nothing
ctx.pop()
assert ctx[needle] is not Nothing
assert ctx[needle] == initial_value
assert_raises(RuntimeError, ctx.pop)
def test_compound_init_sequencing():
class Canary(Exception):
pass
class InitNotCalledAtClassConstruction(Compound):
@classmethod
def __compound_init__(cls):
raise Canary
# __compound_init_ not called until an instance is constructed
assert True
# called when an instance is created
assert_raises(Canary, InitNotCalledAtClassConstruction)
# and again, if it fails
assert_raises(Canary, InitNotCalledAtClassConstruction)
def test_meta_connect_failure():
def meta_received(**kw):
raise TypeError('boom')
assert not receiver_connected.receivers
receiver_connected.connect(meta_received)
def receiver(**kw):
pass
sig = Signal()
assert_raises(TypeError, sig.connect, receiver)
assert not sig.receivers
assert not sig._by_receiver
eq_(sig._by_sender, {ANY_ID: set()})
receiver_connected._clear_state()
def test_meta_connect_failure():
def meta_received(**kw):
raise TypeError('boom')
assert not receiver_connected.receivers
receiver_connected.connect(meta_received)
def receiver(**kw):
pass
sig = Signal()
assert_raises(TypeError, sig.connect, receiver)
assert not sig.receivers
assert not sig._by_receiver
eq_(sig._by_sender, {ANY_ID: set()})
receiver_connected._clear_state()
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_compound_init_sequencing():
class Canary(Exception):
pass
class InitNotCalledAtClassConstruction(Compound):
@classmethod
def __compound_init__(cls):
raise Canary
# __compound_init_ not called until an instance is constructed
assert True
# called when an instance is created
assert_raises(Canary, InitNotCalledAtClassConstruction)
# and again, if it fails
assert_raises(Canary, InitNotCalledAtClassConstruction)
def test_as_mapping():
class Foo(object):
clazz = 'c'
def __init__(self):
self.inzt = 'i'
m = util.as_mapping(Foo)
assert 'clazz' in m
assert m['clazz'] == 'c'
assert sorted(dir(Foo)) == sorted(m)
assert_raises(KeyError, m.__getitem__, 'inzt')
mi = util.as_mapping(Foo())
assert 'clazz' in mi
assert mi['clazz'] == 'c'
assert 'inzt' in mi
assert mi['inzt'] == 'i'
assert sorted(dir(Foo())) == sorted(mi)
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_as_mapping():
class Foo(object):
clazz = 'c'
def __init__(self):
self.inzt = 'i'
m = util.as_mapping(Foo)
assert 'clazz' in m
assert m['clazz'] == 'c'
assert sorted(dir(Foo)) == sorted(m)
assert_raises(KeyError, m.__getitem__, 'inzt')
mi = util.as_mapping(Foo())
assert 'clazz' in mi
assert mi['clazz'] == 'c'
assert 'inzt' in mi
assert mi['inzt'] == 'i'
assert sorted(dir(Foo())) == sorted(mi)
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_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_compound_snarfs_override_init_keywords():
class MyCompound(Compound):
field_schema = [String.named(u'x')]
attr = 'value'
def __init__(self, value='sentinel', abc=1):
# __new__'s value= should not trump this one
assert value == 'sentinel'
self.abc = abc
mc1 = MyCompound()
assert mc1.abc == 1
mc2 = MyCompound(attr='new value')
assert mc2.abc == 1
assert mc2.attr == 'new value'
assert mc1.attr == 'value'
assert type(mc2) is not type(mc1)
assert_raises(TypeError, MyCompound, unknown='boom')
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_list():
for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_s'), (None, u'',
u'0_s')):
schema = List.named(name).of(String.named(u's'))
root = schema([u'x'])
leaf = root[0]
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.0'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.0') is leaf
assert root.el(u'0') is leaf
assert leaf.el(u'.0') is leaf
assert_raises(LookupError, leaf.el, u'0')
assert_raises(LookupError, leaf.el, u's')
assert leaf.el(u'.') is root
assert root.el([u'0']) 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_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_compound_snarfs_override_init_keywords():
class MyCompound(Compound):
field_schema = [String.named(u'x')]
attr = 'value'
def __init__(self, value='sentinel', abc=1):
# __new__'s value= should not trump this one
assert value == 'sentinel'
self.abc = abc
mc1 = MyCompound()
assert mc1.abc == 1
mc2 = MyCompound(attr='new value')
assert mc2.abc == 1
assert mc2.attr == 'new value'
assert mc1.attr == 'value'
assert type(mc2) is not type(mc1)
assert_raises(TypeError, MyCompound, unknown='boom')
def test_naming_list():
for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_s'),
(None, u'', u'0_s')):
schema = List.named(name).of(String.named(u's'))
root = schema([u'x'])
leaf = root[0]
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.0'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.0') is leaf
assert root.el(u'0') is leaf
assert leaf.el(u'.0') is leaf
assert_raises(LookupError, leaf.el, u'0')
assert_raises(LookupError, leaf.el, u's')
assert leaf.el(u'.') is root
assert root.el([u'0']) is leaf
def test_validator_return():
# Validator returns can be bool, int or None.
class Bool(object):
"""A truthy object that does not implement __and__"""
def __init__(self, val):
self.val = val
def __bool__(self):
return bool(self.val)
__nonzero__ = __bool__
Validatable = Element.using(validates_down='validators')
# mostly we care about allowing None for False
true = lambda *a: True
skip = lambda *a: Skip
skipall = lambda *a: SkipAll
one = lambda *a: 1
false = lambda *a: False
skipallfalse = lambda *a: SkipAllFalse
zero = lambda *a: 0
none = lambda *a: None
no = lambda *a: Bool(False)
for validator in true, one, skip, skipall:
el = Validatable(validators=(validator, ))
assert el.validate()
for validator in false, zero, none, skipallfalse:
el = Validatable(validators=(validator, ))
assert not el.validate()
for validator in [no]:
el = Validatable(validators=(validator, ))
assert_raises(TypeError, el.validate)
def test_naming_list_list():
# make sure nested Slots-users don't bork
for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_l2_0_s'),
(None, u'', u'0_l2_0_s')):
schema = List.named(name).of(List.named(u'l2').of(String.named(u's')))
root = schema([u'x'])
leaf = root[0][0]
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.0.0'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.0.0') is leaf
assert root.el(u'0.0') is leaf
assert leaf.el(u'.0.0') is leaf
assert_raises(LookupError, leaf.el, u'0')
assert_raises(LookupError, leaf.el, u's')
assert leaf.el(u'.') is root
assert root.el([u'0', u'0']) is leaf
def test_lazy_property():
poison = False
class Foo(object):
@util.lazy_property
def squiznart(self):
assert not poison
return 'abc'
assert Foo.squiznart != 'abc'
assert hasattr(Foo.squiznart, '__get__')
f = Foo()
assert 'squiznart' not in f.__dict__
assert f.squiznart == 'abc'
assert f.__dict__['squiznart'] == 'abc'
poison = True
assert f.squiznart == 'abc'
new_foo = Foo()
assert_raises(AssertionError, getattr, new_foo, 'squiznart')
assert 'squiznart' not in new_foo.__dict__
def test_naming_list_list():
# make sure nested Slots-users don't bork
for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_l2_0_s'),
(None, u'', u'0_l2_0_s')):
schema = List.named(name).of(List.named(u'l2').of(String.named(u's')))
root = schema([u'x'])
leaf = root[0][0]
assert root.fq_name() == u'.'
assert root.flattened_name() == root_flat
assert root.el(u'.') is root
assert leaf.fq_name() == u'.0.0'
assert leaf.flattened_name() == leaf_flat
assert root.el(u'.0.0') is leaf
assert root.el(u'0.0') is leaf
assert leaf.el(u'.0.0') is leaf
assert_raises(LookupError, leaf.el, u'0')
assert_raises(LookupError, leaf.el, u's')
assert leaf.el(u'.') is root
assert root.el([u'0', u'0']) is leaf
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')
def test_validator_return():
# Validator returns can be bool, int or None.
class Bool(object):
"""A truthy object that does not implement __and__"""
def __init__(self, val):
self.val = val
def __nonzero__(self):
return bool(self.val)
Validatable = Element.using(validates_down='validators')
# mostly we care about allowing None for False
true = lambda *a: True
skip = lambda *a: Skip
skipall = lambda *a: SkipAll
one = lambda *a: 1
false = lambda *a: False
skipallfalse = lambda *a: SkipAllFalse
zero = lambda *a: 0
none = lambda *a: None
no = lambda *a: Bool(False)
for validator in true, one, skip, skipall:
el = Validatable(validators=(validator,))
assert el.validate()
for validator in false, zero, none, skipallfalse:
el = Validatable(validators=(validator,))
assert not el.validate()
for validator in [no]:
el = Validatable(validators=(validator,))
assert_raises(TypeError, el.validate)
def test_sparsedict_key_mutability():
schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
ok, bogus = u'x', u'z'
el[ok] = 123
assert el[ok].value == 123
assert_raises(TypeError, el.__setitem__, bogus, 123)
del el[ok]
assert ok not in el
assert_raises(TypeError, el.__delitem__, bogus)
assert el.setdefault(ok, 456)
assert_raises(TypeError, el.setdefault, bogus, 456)
el[ok] = 123
assert el.pop(ok)
assert_raises(KeyError, el.pop, bogus)
assert_raises(NotImplementedError, el.popitem)
el.clear()
assert not el
def test_sparsedict_key_mutability():
schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y'))
el = schema()
ok, bogus = u'x', u'z'
el[ok] = 123
assert el[ok].value == 123
assert_raises(TypeError, el.__setitem__, bogus, 123)
del el[ok]
assert ok not in el
assert_raises(TypeError, el.__delitem__, bogus)
assert el.setdefault(ok, 456)
assert_raises(TypeError, el.setdefault, bogus, 456)
el[ok] = 123
assert el.pop(ok)
assert_raises(KeyError, el.pop, bogus)
assert_raises(NotImplementedError, el.popitem)
el.clear()
assert not el
def test_lazy_property():
poison = False
class Foo(object):
@util.lazy_property
def squiznart(self):
assert not poison
return 'abc'
assert Foo.squiznart != 'abc'
assert hasattr(Foo.squiznart, '__get__')
f = Foo()
assert 'squiznart' not in f.__dict__
assert f.squiznart == 'abc'
assert f.__dict__['squiznart'] == 'abc'
poison = True
assert f.squiznart == 'abc'
new_foo = Foo()
assert_raises(AssertionError, getattr, new_foo, 'squiznart')
assert 'squiznart' not in new_foo.__dict__
def test_version_sensor():
from flatland.out import genshi
template = 'not a Genshi 0.6+ template'
assert_raises(RuntimeError, genshi.setup, template)
def test_mutation():
schema = Array.of(String)
el = schema()
assert not el
el.set([u'b'])
assert el[0].u == u'b'
assert el.value == [u'b']
el.append(u'x')
assert el[1].u == u'x'
assert el.value == [u'b', u'x']
assert el[1].parent is el
el[1] = u'a'
assert el[1].u == u'a'
assert el.value == [u'b', u'a']
assert el[1].parent is el
el.remove(u'b')
assert el.value == [u'a']
el.extend(u'bcdefg')
eq_(el.value[0:4], [u'a', u'b', u'c', u'd'])
assert el[2].parent is el
del el[0]
eq_(el.value[0:4], [u'b', u'c', u'd', u'e'])
del el[0:4]
eq_(el.value, [u'f', u'g'])
el.pop()
eq_(el.value, [u'f'])
eq_(el[0].u, u'f')
eq_(el.u.encode('ascii'), repr([u'f']))
del el[:]
eq_(list(el), [])
eq_(el.value, [])
eq_(el.u, u'[]')
el[:] = u'abc'
eq_(el.value, [u'a', u'b', u'c'])
assert el[1].parent is el
el.insert(1, u'z')
eq_(el.value, [u'a', u'z', u'b', u'c'])
assert el[1].parent is el
def assign():
el.u = u'z'
assert_raises(AttributeError, assign)
eq_(el.value, [u'a', u'z', u'b', u'c'])
def assign2():
el.value = u'abc'
del el[:]
assert_raises(AttributeError, assign2)
eq_(el.value, [])
def test_set_flat_anonymous_dict():
schema = Array.of(Dict.of(String.named('x')))
pairs = [(u'x', u'abc'), (u'x', u'def')]
assert_raises(AssertionError, schema.from_flat, pairs)
def test_bogus_elements():
for snippet in [
u'<div form:with="snacks" />',
u'<div form:set="snacks" />',
]:
assert_raises(TemplateSyntaxError, render, snippet, 'xml', schema)
