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_mixed_all_children(): data = {u'A1': u'1', u'A2': u'2', u'A3': {u'A3B1': {u'A3B1C1': u'1', u'A3B1C2': u'2'}, u'A3B2': {u'A3B2C1': u'1'}, u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'], [u'A3B3C1D0', u'A3B3C1D1'], [u'A3B3C2D0', u'A3B3C2D1']]}} schema = ( Dict.named(u'R').of( String.named(u'A1'), String.named(u'A2'), Dict.named(u'A3').of( Dict.named(u'A3B1').of( String.named(u'A3B1C1'), String.named(u'A3B1C2')), Dict.named(u'A3B2').of( String.named(u'A3B2C1')), List.named(u'A3B3').of( List.named(u'A3B3Cx').of( String.named(u'A3B3x')))))) top = schema(data) names = list(e.name for e in top.all_children) assert set(names[0:3]) == set([u'A1', u'A2', u'A3']) assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3']) assert set(names[6:12]) == set([u'A3B1C1', u'A3B1C2', u'A3B2C1', u'A3B3Cx']) assert set(names[12:]) == set([u'A3B3x']) assert len(names[12:]) == 6
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_path(): schema = Dict.named('root').of( String.named('element'), Dict.named('dict').of(String.named('dict_element'))) element = schema() assert (list(element.el(['dict', 'dict_element']).path) == [element, element['dict'], element['dict']['dict_element']])
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_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 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_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_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 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_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 shadow(): schema = Dict.named(u'dict_name').of(String.named(u'name'), String.named(u'u')) element = schema({u'name': u'string name', u'u': u'string u'}) element.set_prefix(u'top') return {'top': element, 'bound': element.bind}
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.el(u'.') is root assert leaf.fq_name() == u'.s' assert leaf.flattened_name() == leaf_flat assert root.el(u'.s') is leaf assert root.el(u's') is leaf assert leaf.el(u'.s') is leaf with pytest.raises(LookupError): leaf.el(u's') assert leaf.el(u'.') is root assert root.el([Root]) is root assert root.el([u's']) is leaf assert root.el([Root, u's']) is leaf assert root.el(iter([u's'])) is leaf assert root.el(iter([Root, u's'])) is leaf
class PersonForm(FormView): schema_type = Dict.of( String.named('name'), Integer.named('age'), Boolean.named('friendly'), )
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_set_with_all(): Int = Integer.using(optional=True) schema = (Dict.named(u'point').of( Int.named(u'x'), Int.named(u'y')).using(policy=None).validated_by(SetWithAllFields())) # no coverage of set_flat el = schema.from_flat([(u'point_x', u'1'), (u'point_Z', u'3')]) assert el.value == {u'x': 1, u'y': None} assert el.validate() el = schema({u'x': 1, u'Z': 3}) assert el.value == {u'x': 1, u'y': None} assert not el.validate() assert el.errors == [u'point must contain y and not contain Z'] el = schema({u'x': 1, u'y': 2, u'Z': 3, u'A': 4}) assert el.value == {u'x': 1, u'y': 2} assert not el.validate() assert el.errors == [u'point may not contain A, Z'] el = schema({u'x': 1}) assert el.value == {u'x': 1, u'y': None} assert not el.validate() assert el.errors == [u'point must contain y']
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_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_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_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_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_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_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_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_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_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_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 shadow(): schema = Dict.named(u'dict_name').of( String.named(u'name'), String.named(u'u')) element = schema({u'name': u'string name', u'u': u'string u'}) element.set_prefix(u'top') return {'top': element, 'bound': element.bind}
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_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 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_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_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_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_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_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_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_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_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_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_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_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 form(): schema = Dict.named(u'field0').of( String.named(u'field1'), String.named(u'field2'), List.named(u'field3').of(String.named(u'field4')), List.named(u'field5').of( List.named(u'field6').of(String.named(u'field7')))) element = schema({ u'field1': u'val1', u'field2': u'val2', u'field3': [u'val3'], u'field5': [[u'val4']] }) element.set_prefix(u'form') return {'form': element, 'bound': element.bind}
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_mixed_all_children(): data = { u'A1': u'1', u'A2': u'2', u'A3': { u'A3B1': { u'A3B1C1': u'1', u'A3B1C2': u'2' }, u'A3B2': { u'A3B2C1': u'1' }, u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'], [u'A3B3C1D0', u'A3B3C1D1'], [u'A3B3C2D0', u'A3B3C2D1']] } } schema = (Dict.named(u'R').of( String.named(u'A1'), String.named(u'A2'), Dict.named(u'A3').of( Dict.named(u'A3B1').of(String.named(u'A3B1C1'), String.named(u'A3B1C2')), Dict.named(u'A3B2').of(String.named(u'A3B2C1')), List.named(u'A3B3').of( List.named(u'A3B3Cx').of(String.named(u'A3B3x')))))) top = schema(data) names = list(e.name for e in top.all_children) assert set(names[0:3]) == set([u'A1', u'A2', u'A3']) assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3']) assert set(names[6:12]) == set( [u'A3B1C1', u'A3B1C2', u'A3B2C1', u'A3B3Cx']) assert set(names[12:]) == set([u'A3B3x']) assert len(names[12:]) == 6
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.el(element[u'aux'].target_path) is element[u'main'] assert element.el(element[u'aux'].target_path) is element[u'main']
def form(): schema = Dict.named(u'field0').of( String.named(u'field1'), String.named(u'field2'), List.named(u'field3').of(String.named(u'field4')), List.named(u'field5').of( List.named(u'field6').of(String.named(u'field7')))) element = schema( {u'field1': u'val1', u'field2': u'val2', u'field3': [u'val3'], u'field5': [[u'val4']]}) element.set_prefix(u'form') return {'form': element, 'bound': element.bind}