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_sparsedict_set_default(): schema = SparseDict.of( Integer.named(u'x').using(default=123), Integer.named(u'y')) el = schema() el.set_default() assert el.value == {}
def test_access(): pairs = ((u'l_0_i', u'10'), (u'l_1_i', u'11'), (u'l_2_i', u'12'),) schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) elements = list(Integer.named(u'i')(val) for val in (u'10', u'11', u'12')) assert len(el) == 3 assert el[0] == elements[0] assert el[1] == elements[1] assert el[2] == elements[2] assert el[0].value == 10 assert el[:0] == elements[:0] assert el[:1] == elements[:1] assert el[0:5] == elements[0:5] assert el[-2:-1] == elements[-2:-1] assert el[0] in el assert elements[0] in el assert u'10' in el assert 10 in el assert el.count(elements[0]) == 1 assert el.count(u'10') == 1 assert el.count(10) == 1 assert el.index(elements[0]) == 0 assert el.index(u'10') == 0 assert el.index(10) == 0
class Double(Compound): field_schema = [Integer.named(u'x'), Integer.named(u'y')] def compose(self): ex, ey = self.get(u'x'), self.get(u'y') ux, uy = ex.u, ey.u if ex.u and ey.u: string = u"%sx%s" % (ex.u, ey.u) else: string = u'' if ex.value is not None and ey.value is not None: value = (ex.value, ey.value) else: value = None return string, value def explode(self, value): if value == u'boom': raise AttributeError('boom') if value == u'return-none': return try: x, y = value except (TypeError, ValueError): return False res = True res &= self[u'x'].set(x) res &= self[u'y'].set(y) return res
def test_sparsedict_set_default(): schema = SparseDict.of(Integer.named(u'x').using(default=123), Integer.named(u'y')) el = schema() el.set_default() assert el.value == {}
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_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_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_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_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_sparsedict_required_set_default(): schema = SparseDict.using(minimum_fields='required').\ of(Integer.named(u'x').using(default=123), Integer.named(u'y').using(default=456, optional=True), Integer.named(u'z').using(optional=True)) el = schema() el.set_default() assert el.value == {u'x': 123}
def test_sparsedict_required_set_default(): schema = SparseDict.using(minimum_fields='required').\ of(Integer.named(u'x').using(default=123), Integer.named(u'y').using(default=456, optional=True), Integer.named(u'z').using(optional=True)) el = schema() el.set_default() assert el.value == {u'x': 123}
def test_sparsedict_from_flat(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y')) el = schema.from_flat([]) assert el.items() == [] el = schema.from_flat([(u'x', u'123')]) assert el.value == {u'x': 123} el = schema.from_flat([(u'x', u'123'), (u'z', u'456')]) assert el.value == {u'x': 123}
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 new_schema(self): dictkw, x_kw, y_kw = {}, {}, {} if self.policy is not Unspecified: dictkw['policy'] = self.policy if self.x_default is not Unspecified: x_kw['default'] = self.x_default if self.y_default is not Unspecified: y_kw['default'] = self.y_default return self.schema.named(u's').using(**dictkw).of( Integer.named(u'x').using(**x_kw), Integer.named(u'y').using(**y_kw))
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_sparsedict_from_flat(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y')) el = schema.from_flat([]) assert el.items() == [] el = schema.from_flat([(u'x', u'123')]) assert el.value == {u'x': 123} el = schema.from_flat([(u'x', u'123'), (u'z', u'456')]) assert el.value == {u'x': 123}
def new_schema(self): dictkw, x_kw, y_kw = {}, {}, {} if self.policy is not Unspecified: dictkw['policy'] = self.policy if self.x_default is not Unspecified: x_kw['default'] = self.x_default if self.y_default is not Unspecified: y_kw['default'] = self.y_default return self.schema.named(u's').using(**dictkw).of( Integer.named(u'x').using(**x_kw), Integer.named(u'y').using(**y_kw))
def test_mutation(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() new_element = Integer.named(u'i') def order_ok(): slot_names = list(_.name for _ in el._slots) for idx, name in enumerate(slot_names): assert name == str(idx).decode('ascii') assert not el order_ok() # FIXME:? seems to want parsable data, not elements el.append(new_element(u'0')) assert el.value == [0] order_ok() el.append(u'123') assert el.value == [0, 123] order_ok() el.extend([u'4', u'5']) assert el.value == [0, 123, 4, 5] order_ok() el[0] = u'3' assert el.value == [3, 123, 4, 5] order_ok() el.insert(0, u'2') assert el.value == [2, 3, 123, 4, 5] order_ok() v = el.pop() assert v.value == 5 assert not v.parent order_ok() v = el.pop(0) assert v.value == 2 assert el.value == [3, 123, 4] order_ok() el.remove(u'3') assert el.value == [123, 4] order_ok() del el[:] assert el.value == [] order_ok()
def test_mutation(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() new_element = Integer.named(u'i') def order_ok(): slot_names = list(_.name for _ in el._slots) for idx, name in enumerate(slot_names): assert name == str(idx).decode('ascii') assert not el order_ok() # FIXME:? seems to want parsable data, not elements el.append(new_element(u'0')) assert el.value == [0] order_ok() el.append(u'123') assert el.value == [0, 123] order_ok() el.extend([u'4', u'5']) assert el.value == [0, 123, 4, 5] order_ok() el[0] = u'3' assert el.value == [3, 123, 4, 5] order_ok() el.insert(0, u'2') assert el.value == [2, 3, 123, 4, 5] order_ok() v = el.pop() assert v.value == 5 assert not v.parent order_ok() v = el.pop(0) assert v.value == 2 assert el.value == [3, 123, 4] order_ok() el.remove(u'3') assert el.value == [123, 4] order_ok() del el[:] assert el.value == [] order_ok()
def test_sparsedict_required_validation(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y').using(optional=True)).\ using(minimum_fields='required') el = schema() assert not el.validate() el = schema({u'y': 456}) assert not el.validate() el = schema({u'x': 123, u'y': 456}) assert el.validate()
def test_sparsedict_required_from_flat(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y').using(optional=True)).\ using(minimum_fields='required') el = schema.from_flat([]) assert el.value == {u'x': None} el = schema.from_flat([(u'x', u'123')]) assert el.value == {u'x': 123} el = schema.from_flat([(u'y', u'456'), (u'z', u'789')]) assert el.value == {u'x': None, u'y': 456}
def test_sparsedict_required_validation(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y').using(optional=True)).\ using(minimum_fields='required') el = schema() assert not el.validate() el = schema({u'y': 456}) assert not el.validate() el = schema({u'x': 123, u'y': 456}) assert el.validate()
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_sparsedict_required_from_flat(): schema = SparseDict.of(Integer.named(u'x'), Integer.named(u'y').using(optional=True)).\ using(minimum_fields='required') el = schema.from_flat([]) assert el.value == {u'x': None} el = schema.from_flat([(u'x', u'123')]) assert el.value == {u'x': 123} el = schema.from_flat([(u'y', u'456'), (u'z', u'789')]) assert el.value == {u'x': None, u'y': 456}
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 _populate_app_fields(self): with WindowServiceProxy(59000) as w: self.video_mode_map = w.get_video_mode_map() if self.video_mode_map: self._video_available = True else: self._video_available = False self.video_mode_keys = sorted(self.video_mode_map.keys()) if self._video_available: self.device_key, self.devices = w.get_video_source_configs() field_list = [ Integer.named('overlay_opacity').using(default=50, optional=True), Directory.named('device_directory').using(default='', optional=True), String.named('transform_matrix').using(default='', optional=True, properties={'show_in_gui': False}), ] if self._video_available: video_mode_enum = Enum.named('video_mode').valued( *self.video_mode_keys).using(default=self.video_mode_keys[0], optional=True) video_enabled_boolean = Boolean.named('video_enabled').using( default=False, optional=True, properties={'show_in_gui': True}) recording_enabled_boolean = Boolean.named('recording_enabled').using( default=False, optional=True, properties={'show_in_gui': False}) field_list.append(video_mode_enum) field_list.append(video_enabled_boolean) field_list.append(recording_enabled_boolean) return Form.of(*field_list)
class PersonForm(FormView): schema_type = Dict.of( String.named('name'), Integer.named('age'), Boolean.named('friendly'), )
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_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_reverse(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')] el.reverse() assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
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_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_reverse(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')] el.reverse() assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
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 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_slots(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([1, 2]) assert len(list(el._slots)) == 2 for slot in el._slots: # don't really care what it says, just no crashy. assert repr(slot) assert [slot.value for slot in el._slots] == [1, 2]
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_slots(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([1, 2]) assert len(list(el._slots)) == 2 for slot in el._slots: # don't really care what it says, just no crashy. assert repr(slot) assert [slot.value for slot in el._slots] == [1, 2]
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()
class Schema(Form): i1 = Integer.using(default=0) d1 = Dict.of( Integer.named('d1i1').using(default=1), Integer.named('d1i2').using(default=2)) l1 = List.using(default=2).of(Integer.named('l1i1').using(default=3)) l2 = List.using(default=3).of( Integer.named('l2i1').using(default=4), Integer.named('l2i2').using(default=5)) l3 = List.using(default=2).of( List.named('l3l1').using(default=2).of(Integer.using(default=6))) a1 = Array.using(default=[10, 11, 12, 13, 14, 15]).of(Integer) dt1 = DateYYYYMMDD.using(default=date.today())
def test_dict_update(): schema = Dict.of(Integer.named(u'x'), Integer.named(u'y')) el = schema() def value_dict(element): return dict((k, v.value) for k, v in element.iteritems()) try: el.update(x=20, y=30) except UnicodeError: assert not unicode_coercion_available() el.update(udict(x=20, y=30)) assert udict(x=20, y=30) == el.value el.update({u'y': 40}) assert udict(x=20, y=40) == el.value el.update() assert udict(x=20, y=40) == el.value el.update((_, 100) for _ in u'xy') assert udict(x=100, y=100) == el.value try: el.update([(u'x', 1)], y=2) assert udict(x=1, y=2) == el.value except UnicodeError: assert not unicode_coercion_available() try: el.update([(u'x', 10), (u'y', 10)], x=20, y=20) assert udict(x=20, y=20) == el.value except UnicodeError: assert not unicode_coercion_available() if unicode_coercion_available(): assert_raises(TypeError, el.update, z=1) assert_raises(TypeError, el.update, x=1, z=1) assert_raises(TypeError, el.update, {u'z': 1}) assert_raises(TypeError, el.update, {u'x': 1, u'z': 1}) assert_raises(TypeError, el.update, ((u'z', 1), )) assert_raises(TypeError, el.update, ((u'x', 1), (u'z', 1)))
def test_dict_update(): schema = Dict.of(Integer.named(u'x'), Integer.named(u'y')) el = schema() def value_dict(element): return dict((k, v.value) for k, v in element.iteritems()) try: el.update(x=20, y=30) except UnicodeError: assert not unicode_coercion_available() el.update(udict(x=20, y=30)) assert udict(x=20, y=30) == el.value el.update({u'y': 40}) assert udict(x=20, y=40) == el.value el.update() assert udict(x=20, y=40) == el.value el.update((_, 100) for _ in u'xy') assert udict(x=100, y=100) == el.value try: el.update([(u'x', 1)], y=2) assert udict(x=1, y=2) == el.value except UnicodeError: assert not unicode_coercion_available() try: el.update([(u'x', 10), (u'y', 10)], x=20, y=20) assert udict(x=20, y=20) == el.value except UnicodeError: assert not unicode_coercion_available() if unicode_coercion_available(): assert_raises(TypeError, el.update, z=1) assert_raises(TypeError, el.update, x=1, z=1) assert_raises(TypeError, el.update, {u'z': 1}) assert_raises(TypeError, el.update, {u'x': 1, u'z': 1}) assert_raises(TypeError, el.update, ((u'z', 1),)) assert_raises(TypeError, el.update, ((u'x', 1), (u'z', 1)))
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_sort(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) el.sort(key=lambda el: el.value) assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')] el.sort(key=lambda el: el.value, reverse=True) assert el.value == [2, 1] assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
def test_sparsedict_flattening(): schema = SparseDict.named(u'top').\ of(Integer.named(u'x'), Integer.named(u'y')) els = [ schema({'x': 123, 'y': 456}), schema(), schema(), schema(), ] els[1].set({'x': 123, 'y': 456}) els[2]['x'] = 123 els[2]['y'] = 456 els[3]['x'] = Integer(123) els[3]['y'] = Integer(456) wanted = [(u'top_x', u'123'), (u'top_y', u'456')] for el in els: got = sorted(el.flatten()) assert wanted == got
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_flattening(): schema = SparseDict.named(u'top').\ of(Integer.named(u'x'), Integer.named(u'y')) els = [ schema({u'x': 123, u'y': 456}), schema(), schema(), schema(), ] els[1].set({u'x': 123, u'y': 456}) els[2][u'x'] = 123 els[2][u'y'] = 456 els[3][u'x'] = Integer(123) els[3][u'y'] = Integer(456) wanted = [(u'top_x', u'123'), (u'top_y', u'456')] for el in els: got = sorted(el.flatten()) assert wanted == got
def test_sort(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) el.sort(key=lambda el: el.value) assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')] el.sort(key=lambda el: el.value, reverse=True) assert el.value == [2, 1] assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
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_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_set_flat_unpruned(): pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False) el = schema.from_flat(pairs) eq_(len(el), 4) eq_(el.value, [0, None, None, 3]) schema2 = schema.using(maximum_set_flat_members=2) el = schema2.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, None])
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_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_set_flat_unpruned(): pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False) el = schema.from_flat(pairs) eq_(len(el), 4) eq_(el.value, [0, None, None, 3]) schema2 = schema.using(maximum_set_flat_members=2) el = schema2.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, None])
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')