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