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_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 with pytest.raises(LookupError): leaf.el(u'0') with pytest.raises(LookupError): leaf.el(u's') assert leaf.el(u'.') is root assert root.el([u'0', u'0']) is leaf
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 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_set(): schema = List.of(Integer) el = schema() assert list(el) == [] el = schema() assert not el.set(1) assert el.value == [] el = schema() assert not el.set(None) assert el.value == [] el = schema() assert el.set(range(3)) assert el.value == [0, 1, 2] el = schema() assert el.set(xrange(3)) assert el.value == [0, 1, 2] el = schema([0, 1, 2]) assert el.value == [0, 1, 2] el = schema() el.extend([1, 2, 3]) assert el.value == [1, 2, 3] el.set([4, 5, 6]) assert el.value == [4, 5, 6] assert el.set([]) assert el.value == []
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_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
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))
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_values_equal_resolution(): v = ValuesEqual('x', '/sub/xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el, None) v = ValuesEqual('/x', 'xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el['sub'], None) # unhashable v = ValuesEqual('a', 'b') schema = Dict.of(List.named('a').of(String.named('x')), List.named('b').of(String.named('x'))) el = schema(dict(a=['a', 'b'], b=['a', 'b'])) assert v.validate(el, None) el = schema(dict(a=['a', 'b'], b=['x', 'y'])) assert not v.validate(el, None)
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_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_set_flat_doubly_anonymous_dict(): pairs = ((u'0_x', u'x0'), (u'0_y', u'y0'), (u'1_x', u'x1'), (u'1_y', u'y1'), (u'2_x', u'x2'), ) schema = List.of(String.named(u'x'), String.named(u'y')) el = schema.from_flat(pairs) eq_(len(el), 3) eq_(el[0].value, dict((k[-1], v) for k, v in pairs[0:2])) eq_(el[1].value, dict((k[-1], v) for k, v in pairs[2:4])) eq_(el[2].value, {u'x': u'x2', u'y': None})
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_corrupt_all_children(): # Ensure all_children won't spin out if the graph becomes cyclic. schema = List.of(String) el = schema() el.append(String(u'x')) el.append(String(u'y')) dupe = String(u'z') el.append(dupe) el.append(dupe) assert list(_.value for _ in el.children) == list(u'xyzz') assert list(_.value for _ in el.all_children) == list(u'xyz')
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_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_set_flat_pruned(): # pruned won't insert empty elements for a skipped index or empty rhs 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')) el = schema.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, 3]) schema2 = schema.using(maximum_set_flat_members=1) el = schema2.from_flat(pairs) eq_(len(el), 1) eq_(el.value, [0])
def test_set_flat_scalar(): pairs = [(u'l', u'1')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema() 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_(len(el), 0) eq_(el.value, []) eq_(canary, [])
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_raw(): schema = List.of(Integer) el = schema() assert el.raw is Unset el = schema(u'foo') assert el.raw == u'foo' el = schema([1, 2, 3]) assert el.raw == [1, 2, 3] el = schema((1, 2, 3)) assert el.raw == (1, 2, 3) el = schema({u'x': u'bar'}) assert el.raw == {u'x': u'bar'}
def test_set_default_int(): def factory(count, **kw): return List.named(u'l').using(default=count, **kw).of( String.named(u's').using(default=u'val')) schema = factory(3) el = schema() eq_(len(el), 0) eq_(el.value, []) el = schema() el.set_default() eq_(len(el), 3) eq_(el.value, [u'val'] * 3) el.append(None) eq_(len(el), 4) eq_(el[-1].value, None) el[-1].set_default() eq_(el[-1].value, u'val') el = schema([u'a', u'b']) eq_(len(el), 2) eq_(el.value, [u'a', u'b']) el.set_default() eq_(len(el), 3) eq_(el.value, [u'val'] * 3) schema0 = factory(0) el = schema0() el.set_default() eq_(len(el), 0) eq_(el.value, []) def calculated_default(element): assert isinstance(element, List) return 2 schemaf = List.named(u'l').using(default_factory=calculated_default).of( String.named(u's').using(default=u'val')) el = schemaf() el.set_default() eq_(len(el), 2) eq_(el.value, [u'val'] * 2)
def test_mutate_slices(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() canary = [] el.extend([u'3', u'4']) canary.extend([3, 4]) el[0:1] = [u'1', u'2', u'3'] canary[0:1] = [1, 2, 3] eq_(el.value, [1, 2, 3, 4]) eq_(canary, [1, 2, 3, 4]) del el[2:] del canary[2:] assert el.value == [1, 2] assert canary == [1, 2]
def test_element_set(): data = [] sentinel = lambda sender, adapted: data.append((sender, adapted)) schema = List.of(Integer) schema([0]) with element_set.connected_to(sentinel): schema([1]) schema([u'bogus']) assert len(data) == 4 # Integer, List, Integer, List assert data[1][0].value == [1] assert data[1][1] is True assert data[2][0].raw == u'bogus' assert data[2][1] is False assert data[3][1] is False
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 factory(default, **kw): return List.using(default=default, **kw).of( String.using(default=u'val'))
def factory(count, **kw): return List.named(u'l').using(default=count, **kw).of( String.named(u's').using(default=u'val'))
def test_set_flat_unnamed_child(): schema = List.named(u's').of(String) pairs = [(u's_0', u'abc'), (u's_1', u'def')] bogus = [(u's', u'xxx')] _assert_set_flat(schema, pairs, bogus)
def test_u(): schema = List.of(String) el = schema([u'x', u'x']) eq_(el.u, u"[u'x', u'x']")
def test_value(): schema = List.of(String) el = schema([u'x', u'x']) eq_(el.value, [u'x', u'x'])
def test_set_flat_anon_list_named_child(): schema = List.of(String.named(u's')) pairs = [(u'0_s', u'abc'), (u'1_s', u'def')] bogus = [(u's', u'xxx'), (u'0', u'yyy')] _assert_set_flat(schema, pairs, bogus)
class Bundle(Import): def adapt(self, value): return Import.adapt(self, 'glashammer.bundles.%s.setup_%s' % (value, value)) Url = Dict.of( String.named('url'), String.named('endpoint'), Import.named('view').using(optional=True), ) Urls = List.of(Url) Config = Dict.named('config').of(Dict) Settings = Dict.of(Element) TemplateSearchPaths = List.of(String) TemplateFilter = Dict.of( Import.named('filter'), String.named('name'), ) TemplateFilters = List.of(TemplateFilter) SharedPath = Dict.of(
# XXX forces circular dependency when it is in the head import block from MoinMoin.themes import utctimestamp # TODO: Add support for timezones dt = utctimestamp(dt) return dt DateTime = (DateTimeUNIX.with_properties(widget=WIDGET_DATETIME, placeholder=_("YYYY-MM-DD HH:MM:SS (example: 2013-12-31 23:59:59)")) .validated_by(Converted(incorrect=L_("Please use the following format: YYYY-MM-DD HH:MM:SS")))) File = FileStorage.with_properties(widget=WIDGET_FILE) Hidden = String.using(optional=True).with_properties(widget=WIDGET_HIDDEN) # optional=True is needed to get rid of the "required field" indicator on the UI (usually an asterisk) ReadonlyStringList = List.of(String).using(optional=True).with_properties(widget=WIDGET_READONLY_STRING_LIST) ReadonlyItemLinkList = ReadonlyStringList.with_properties(widget=WIDGET_READONLY_ITEM_LINK_LIST) # XXX When some user chooses a Reference candidate that is removed before the # user POSTs, the validator fails. This can be confusing. class ValidReference(Validator): """ Validator for Reference """ invalid_reference_msg = L_('Invalid Reference.') def validate(self, element, state): if element.value not in element.valid_values: return self.note_error(element, state, 'invalid_reference_msg')
def test_set_flat_fully_anonymous(): schema = List.of(String) pairs = [(u'0', u'abc'), (u'1', u'def')] bogus = [(u'x', u'xxx')] _assert_set_flat(schema, pairs, bogus)
def factory(default, **kw): return List.using(default=default, **kw).of(String.using(default=u'val'))