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_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_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))
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_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')]
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_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_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_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_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_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_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_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_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_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_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_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 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 factory(count, **kw):
return List.named(u'l').using(default=count, **kw).of(
String.named(u's').using(default=u'val'))
def test_value():
schema = List.of(String)
el = schema([u'x', u'x'])
eq_(el.value, [u'x', u'x'])
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_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)
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 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 factory(default, **kw):
return List.using(default=default,
**kw).of(String.using(default=u'val'))
