def test_over_set_flat(self):
wanted = {u'x': 123, u'y': None}
pairs = ((u's_x', u'123'), (u's_z', u'nope'))
el = self.new_element()
el.set_flat(pairs)
eq_(el.value, wanted)
def test_full_set_flat(self):
wanted = {u'x': 101, u'y': 102}
pairs = ((u's_x', u'101'), (u's_y', u'102'))
el = self.new_element()
el.set_flat(pairs)
eq_(el.value, wanted)
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_full_set_flat(self):
wanted = {u'x': 101, u'y': 102}
pairs = ((u's_x', u'101'), (u's_y', u'102'))
el = self.new_element()
el.set_flat(pairs)
eq_(el.value, wanted)
def setup_package():
from flatland.schema import base
eq_(base.Element.__bases__, (base._BaseElement, ))
import flatland.out.genshi
flatland.out.genshi.install_element_mixin()
assert len(base.Element.__bases__) == 2
def test_over_set_flat(self):
wanted = {u'x': 123, u'y': None}
pairs = ((u's_x', u'123'), (u's_z', u'nope'))
el = self.new_element()
el.set_flat(pairs)
eq_(el.value, wanted)
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 setup_package():
from flatland.schema import base
eq_(base.Element.__bases__, (base._BaseElement,))
import flatland.out.genshi
flatland.out.genshi.install_element_mixin()
assert len(base.Element.__bases__) == 2
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_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 teardown_package():
from flatland.schema import base
assert len(base.Element.__bases__) == 2
import flatland.out.genshi
flatland.out.genshi.uninstall_element_mixin()
eq_(base.Element.__bases__, (base._BaseElement, ))
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_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_url_canonicalizer_default():
v = URLCanonicalizer()
el = scalar(u'http://localhost/#foo')
eq_(el.value, u'http://localhost/#foo')
assert v.validate(el, None)
eq_(el.value, u'http://localhost/')
assert not el.errors
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_url_canonicalizer_want_all():
v = URLCanonicalizer(discard_parts=())
el = scalar(u'http://*****:*****@there/path#fragment')
eq_(el.value, u'http://*****:*****@there/path#fragment')
assert v.validate(el, None)
eq_(el.value, u'http://*****:*****@there/path#fragment')
assert not el.errors
def teardown_package():
from flatland.schema import base
assert len(base.Element.__bases__) == 2
import flatland.out.genshi
flatland.out.genshi.uninstall_element_mixin()
eq_(base.Element.__bases__, (base._BaseElement,))
def test_url_canonicalizer_default():
v = URLCanonicalizer()
el = scalar('http://localhost/#foo')
eq_(el.value, 'http://localhost/#foo')
assert v.validate(el, None)
eq_(el.value, 'http://localhost/')
assert not el.errors
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 test_url_canonicalizer_want_all():
v = URLCanonicalizer(discard_parts=())
el = scalar('http://*****:*****@there/path#fragment')
eq_(el.value, 'http://*****:*****@there/path#fragment')
assert v.validate(el, None)
eq_(el.value, 'http://*****:*****@there/path#fragment')
assert not el.errors
def test_set_default(self):
wanted = {u'x': 11, u'y': 12}
schema = self.new_schema()
schema.default = wanted
el = schema()
el.set_default()
eq_(el.value, wanted)
def test_set_default(self):
wanted = {u'x': 11, u'y': 12}
schema = self.new_schema()
schema.default = wanted
el = schema()
el.set_default()
eq_(el.value, wanted)
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()))
def test_http_validator_default():
v = HTTPURLValidator(forbidden_part='X')
el = scalar('http://there/path#fragment')
assert v.validate(el, None)
assert not el.errors
el = scalar('http://*****:*****@there/path#fragment')
not v.validate(el, None)
eq_(el.errors, ['X'])
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()))
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 validate_element_set(type_, raw, value, uni, schema_opts={},
set_return=None):
if set_return is None:
set_return = value is not None
element = type_(**schema_opts)
eq_(element.set(raw), set_return)
eq_(element.value, value)
eq_(element.u, uni)
eq_(unicode(element), uni)
eq_(element.__nonzero__(), bool(uni and value))
def test_map_equal():
v = MapEqual('x', 'y',
transform=lambda el: el.value.upper(),
unequal='%(labels)s/%(last_label)s')
el = form(dict(x='a', y='A'))
assert v.validate(el, None)
el = form(dict(x='a', y='B'))
assert not v.validate(el, None)
eq_(el.errors, ['x/y'])
def validate_element_set(type_, raw, value, uni, schema_opts={},
set_return=None):
if set_return is None:
set_return = value is not None
element = type_(**schema_opts)
eq_(element.set(raw), set_return)
eq_(element.value, value)
eq_(element.u, uni)
eq_(unicode(element), uni)
eq_(element.__nonzero__(), bool(uni and value))
def test_half_set(self):
wanted = {u'x': 123, u'y': None}
el = self.new_element()
el.set({u'x': 123})
eq_(el.value, wanted)
el = self.new_element()
el.set([(u'x', 123)])
eq_(el.value, wanted)
def test_map_equal():
v = MapEqual('x', 'y',
transform=lambda el: el.value.upper(),
unequal='%(labels)s/%(last_label)s')
el = form(dict(x='a', y='A'))
assert v.validate(el, None)
el = form(dict(x='a', y='B'))
assert not v.validate(el, None)
eq_(el.errors, ['x/y'])
def test_straight_parse():
form = SimpleForm1.from_flat(REQUEST_DATA)
eq_(set(form.flatten()), set(((u'fname', u'FN'),
(u'surname', u'SN'),
(u'age', u'99'))))
eq_(form.value, dict(fname=u'FN',
surname=u'SN',
age=99,
snacks=[]))
def test_url_validator_schemes():
v = URLValidator(allowed_schemes=(), blocked_scheme='X')
el = scalar('http://*****:*****@there/path#fragment')
assert not v.validate(el, None)
eq_(el.errors, ['X'])
v = URLValidator(allowed_schemes=('https',), blocked_scheme='X')
el = scalar('http://*****:*****@there/path#fragment')
assert not v.validate(el, None)
eq_(el.errors, ['X'])
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_set_flat_pruned():
sub = String.named(u's')
pairs = [(u's', u'val0'), (u's', u''), (u's', u'val1'), (u's', u'')]
wanted = [u'val0', u'val1']
for schema in Array.of(sub), Array.of(sub).using(prune_empty=True):
el = schema.from_flat(pairs)
eq_(len(el), len(wanted))
eq_(el.value, wanted)
def test_set_flat_pruned():
sub = String.named(u's')
pairs = [(u's', u'val0'), (u's', ''), (u's', u'val1'), (u's', u'')]
wanted = [u'val0', u'val1']
for schema in Array.of(sub), Array.of(sub).using(prune_empty=True):
el = schema.from_flat(pairs)
eq_(len(el), len(wanted))
eq_(el.value, wanted)
def test_url_validator_schemes():
v = URLValidator(allowed_schemes=(), blocked_scheme='X')
el = scalar(u'http://*****:*****@there/path#fragment')
assert not v.validate(el, None)
eq_(el.errors, [u'X'])
v = URLValidator(allowed_schemes=('https', ), blocked_scheme='X')
el = scalar(u'http://*****:*****@there/path#fragment')
assert not v.validate(el, None)
eq_(el.errors, [u'X'])
def test_half_set(self):
wanted = {u'x': 123, u'y': None}
el = self.new_element()
el.set({u'x': 123})
eq_(el.value, wanted)
el = self.new_element()
el.set([(u'x', 123)])
eq_(el.value, wanted)
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_set_default_from_children(self):
el = self.new_element()
el.set_default()
wanted = {
u'x':
self.x_default if self.x_default is not Unspecified else None,
u'y':
self.y_default if self.y_default is not Unspecified else None,
}
eq_(el.value, wanted)
def test_set_default_from_children(self):
el = self.new_element()
el.set_default()
wanted = {
u'x': self.x_default if self.x_default is not Unspecified
else None,
u'y': self.y_default if self.y_default is not Unspecified
else None,
}
eq_(el.value, wanted)
def test_values_equal_two():
v = ValuesEqual('x', 'y')
el = form(dict(x='a', y='a', z='a'))
assert v.validate(el, None)
el = form(dict(x='a', y='b', z='c'))
assert not v.validate(el, None)
eq_(el.errors, ['x and y do not match.'])
el = form(dict(x='a'))
assert not v.validate(el, None)
eq_(el.errors, ['x and y do not match.'])
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_values_equal_three():
v = ValuesEqual(u'x', u'y', u'z')
el = form(dict(x=u'a', y=u'a', z=u'a'))
assert v.validate(el, None)
el = form(dict(x=u'a', y=u'b', z=u'c'))
assert not v.validate(el, None)
eq_(el.errors, [u'x, y and z do not match.'])
el = form(dict(x=u'a'))
assert not v.validate(el, None)
eq_(el.errors, [u'x, y and z do not match.'])
def test_values_equal_three():
v = ValuesEqual('x', 'y', 'z')
el = form(dict(x='a', y='a', z='a'))
assert v.validate(el, None)
el = form(dict(x='a', y='b', z='c'))
assert not v.validate(el, None)
eq_(el.errors, ['x, y and z do not match.'])
el = form(dict(x='a'))
assert not v.validate(el, None)
eq_(el.errors, ['x, y and z do not match.'])
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_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_chunk_assertion_blocks_1():
input = """
foo
bar
:: test
thing
thing
:: eq
thing thing
:: endtest
"""
eq_(chunk_assertion_blocks(input),
[[1, '1', 'thing thing', 'thing thing']])
def test_chunk_assertion_blocks_1():
input = """
foo
bar
:: test
thing
thing
:: eq
thing thing
:: endtest
"""
eq_(chunk_assertion_blocks(input),
[[1, '1', 'thing thing', 'thing thing']])
def test_http_validator_default():
v = HTTPURLValidator(forbidden_part='X')
el = scalar(u'http://there/path#fragment')
assert v.validate(el, None)
assert not el.errors
el = scalar(u'http://*****:*****@there/path#fragment')
not v.validate(el, None)
eq_(el.errors, [u'X'])
el = scalar('www.example.com')
not v.validate(el, None)
eq_(el.errors, ['test is not a valid URL.'])
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_message_buckets():
el = Element()
el.add_error('error')
eq_(el.errors, ['error'])
el.add_error('error')
eq_(el.errors, ['error'])
el.add_error('error2')
eq_(el.errors, ['error', 'error2'])
el.add_warning('warning')
eq_(el.warnings, ['warning'])
el.add_warning('warning')
eq_(el.warnings, ['warning'])
def test_scalar_assignments_are_independent():
element = Scalar()
assert not element.u
assert not element.value
element.u = u'abc'
assert element.value is None
element = Scalar()
assert not element.u
assert not element.value
element.value = u'abc'
eq_(element.u, u'')
eq_(element.value, u'abc')
def test_message_buckets():
el = Element()
el.add_error('error')
eq_(el.errors, ['error'])
el.add_error('error')
eq_(el.errors, ['error'])
el.add_error('error2')
eq_(el.errors, ['error', 'error2'])
el.add_warning('warning')
eq_(el.warnings, ['warning'])
el.add_warning('warning')
eq_(el.warnings, ['warning'])
def test_scalar_assignments_are_independent():
element = Scalar()
assert not element.u
assert not element.value
element.u = u'abc'
assert element.value is None
element = Scalar()
assert not element.u
assert not element.value
element.value = u'abc'
eq_(element.u, u'')
eq_(element.value, u'abc')
def test_scalar_set_flat(self):
wanted = {u'x': None, u'y': None}
pairs = ((u's', u'xxx'),)
el = self.new_element()
canary = []
def setter(self, value):
canary.append(value)
return type(el).set(self, value)
el.set = setter.__get__(el, type(el))
el.set_flat(pairs)
eq_(el.value, wanted)
assert canary == []
def test_strong_receiver():
sentinel = []
def received(**kw):
sentinel.append(kw)
fn_id = id(received)
sig = Signal()
sig.connect(received, weak=False)
del received
assert not sentinel
sig.send()
assert sentinel
eq_([id(fn) for fn in sig.receivers.values()], [fn_id])
