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_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_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_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_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_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_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_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_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_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)