def test_page_link(self):
map = self.app.config['ayame.route.map']
map.connect('/<y:int>', SpamPage)
map.connect('/', SpamPage)
a = markup.Element(link._A)
with self.application(self.new_environ()):
l = link.PageLink('a', SpamPage)
l.render(a)
self.assert_equal(a.attrib, {link._HREF: '/'})
a = markup.Element(link._A)
with self.application(self.new_environ()):
l = link.PageLink('a', SpamPage, {'a': ['1', '2']})
l.render(a)
self.assert_equal(a.attrib, {link._HREF: '/?a=1&a=2'})
a = markup.Element(link._A)
with self.application(self.new_environ()):
l = link.PageLink('a', SpamPage, {'y': 2012})
l.render(a)
self.assert_equal(a.attrib, {link._HREF: '/2012'})
a = markup.Element(link._A)
with self.application(self.new_environ()):
l = link.PageLink('a', SpamPage, {'y': 2012, 'a': ['1', '2']})
l.render(a)
self.assert_equal(a.attrib, {link._HREF: '/2012?a=1&a=2'})
def test_list_view_error(self):
root = markup.Element(self.of('root'), attrib={markup.AYAME_ID: 'b'})
label = markup.Element(self.of('label'), attrib={markup.AYAME_ID: 'c'})
root.append(label)
mc = ayame.MarkupContainer('a')
m = model.Model([str(i) for i in five.range(3)])
mc.add(basic.ListView('b', m, None))
with self.assert_raises_regex(ayame.ComponentError,
r"\bcomponent .* 'c' .* not found\b"):
mc.render(root)
def new_markup(self, lang):
m = markup.Markup()
m.xml_decl = {
u'version': u'1.0',
u'standalone': u'yes'
}
m.lang = lang
spam = markup.Element(markup.QName(u'spam', u'spam'),
attrib={markup.QName(u'spam', u'id'): u'a'},
ns={u'': u'spam'})
eggs = markup.Element(markup.QName(u'spam', u'eggs'))
eggs.append(0)
spam.append(eggs)
m.root = spam
return m
def test_list_view_empty_model(self):
def populate_item(li):
li.add(basic.Label('c', li.model.object))
root = markup.Element(self.of('root'), attrib={markup.AYAME_ID: 'b'})
label = markup.Element(self.of('label'), attrib={markup.AYAME_ID: 'c'})
root.append(label)
mc = ayame.MarkupContainer('a')
m = model.Model(None)
mc.add(basic.ListView('b', m, populate_item))
root = mc.render(root)
self.assert_equal(root.qname, self.of('root'))
self.assert_equal(root.attrib, {})
self.assert_equal(root.children, [])
def test_overwrite_ns_uri(self):
m = self.new_markup('xml')
m.root[0].ns[u''] = u'eggs'
ham = markup.Element(markup.QName(u'spam', u'ham'))
m.root[0][:] = [ham]
self.assert_error("namespace URI .*''.* overwritten$",
m)
def test_link_unknown(self):
div = markup.Element(markup.DIV)
with self.application():
l = link.Link('a', 'spam')
l.render(div)
self.assert_equal(div.attrib, {})
self.assert_equal(div.children, ['spam'])
def test_link_replace_children(self):
a = markup.Element(link._A)
with self.application():
l = link.Link('a', 'spam')
l.render(a)
self.assert_equal(a.attrib, {})
self.assert_equal(a.children, ['spam'])
def assert_a(path, value):
a = markup.Element(self.html_of('a'))
href = self.html_of('href')
with self.application(self.new_environ(path=path)):
am = basic.ContextPathGenerator(href, 'eggs.html')
am.on_component(None, a)
self.assert_equal(a.attrib, {href: value})
def assert_img(path, value):
img = markup.Element(self.html_of('img'))
src = self.html_of('src')
with self.application(self.new_environ(path=path)):
c = basic.ContextImage(src, 'eggs.gif')
img = c.render(img)
self.assert_equal(img.attrib, {src: value})
def test_label(self):
c = basic.Label('a')
self.assert_is_none(c.model)
elem = c.render(markup.Element(None))
self.assert_equal(elem.attrib, {})
self.assert_equal(elem.children, [''])
def assert_meta(path, value):
meta = markup.Element(self.html_of('meta'))
href = self.html_of('href')
with self.application(self.new_environ(path=path)):
c = basic.ContextLink(href, 'eggs.css')
meta = c.render(meta)
self.assert_equal(meta.attrib, {href: value})
def test_list_view(self):
def populate_item(li):
li.add(basic.Label('c', li.model.object))
root = markup.Element(self.of('root'), attrib={markup.AYAME_ID: 'b'})
label = markup.Element(self.of('label'), attrib={markup.AYAME_ID: 'c'})
root.append(label)
mc = ayame.MarkupContainer('a')
m = model.Model([str(i) for i in five.range(3)])
mc.add(basic.ListView('b', m, populate_item))
root = mc.render(root)
self.assert_equal(root.qname, self.of('root'))
self.assert_equal(root.attrib, {})
self.assert_equal(len(root), 3)
label = root[0]
self.assert_equal(label.qname, self.of('label'))
self.assert_equal(label.attrib, {})
self.assert_equal(label.children, ['0'])
label = root[1]
self.assert_equal(label.qname, self.of('label'))
self.assert_equal(label.attrib, {})
self.assert_equal(label.children, ['1'])
label = root[2]
self.assert_equal(label.qname, self.of('label'))
self.assert_equal(label.attrib, {})
self.assert_equal(label.children, ['2'])
self.assert_equal(len(mc.children), 1)
lv = mc.children[0]
self.assert_equal(len(lv.children), 3)
self.assert_equal(lv.children[0].index, 0)
self.assert_equal(lv.children[1].index, 1)
self.assert_equal(lv.children[2].index, 2)
self.assert_is_instance(lv.children[0].model, basic._ListItemModel)
self.assert_is_instance(lv.children[1].model, basic._ListItemModel)
self.assert_is_instance(lv.children[2].model, basic._ListItemModel)
lv.children[0].model.object = 10
lv.children[1].model.object = 11
lv.children[2].model.object = 12
self.assert_equal(lv.children[0].model.object, 10)
self.assert_equal(lv.children[1].model.object, 11)
self.assert_equal(lv.children[2].model.object, 12)
def new_element(self, name, attrib=None):
elem = markup.Element(self.html_of(name),
type=markup.Element.OPEN,
ns={'': markup.XHTML_NS})
if attrib:
for n, v in five.items(attrib):
elem.attrib[self.html_of(n)] = v
return elem
def test_label_with_string(self):
with self.application():
c = basic.Label('a', '<tag>')
self.assert_equal(c.model.object, '<tag>')
elem = c.render(markup.Element(None))
self.assert_equal(elem.attrib, {})
self.assert_equal(elem.children, ['<tag>'])
def test_default_ns_attr(self):
m = self.new_markup('xml')
eggs = markup.Element(markup.QName(u'eggs', u'eggs'),
attrib={markup.QName(u'eggs', u'a'): u'1',
markup.QName(u'spam', u'a'): u'2'},
ns={u'eggs': u'eggs'})
m.root[:] = [eggs]
self.assert_error(' default namespace$',
m)
def test_label_with_string_model(self):
with self.application():
m = model.Model('<tag>')
c = basic.Label('a', m)
self.assert_is(c.model, m)
elem = c.render(markup.Element(None))
self.assert_equal(elem.attrib, {})
self.assert_equal(elem.children, ['<tag>'])
def test_label_with_object_model(self):
with self.application():
m = model.Model([])
c = basic.Label('a', m)
self.assert_is(c.model, m)
elem = c.render(markup.Element(None))
self.assert_equal(elem.attrib, {})
self.assert_equal(elem.children, ['[]'])
def test_property_list_view_render_body_only(self):
def populate_item(li):
li.add(basic.Label('c', li.model.object))
li.find('c').render_body_only = True
root = markup.Element(self.of('root'), attrib={markup.AYAME_ID: 'b'})
root.append('[')
label = markup.Element(self.of('label'), attrib={markup.AYAME_ID: 'c'})
root.append(label)
root.append(']')
m = model.CompoundModel({'b': [str(i) for i in five.range(3)]})
mc = ayame.MarkupContainer('a', m)
mc.add(basic.PropertyListView('b', None, populate_item))
root = mc.render(root)
self.assert_equal(root.qname, self.of('root'))
self.assert_equal(root.attrib, {})
self.assert_equal(len(root), 9)
root.normalize()
self.assert_equal(root.children, ['[0][1][2]'])
def test_fragment(self):
br = markup.Element(self.html_of('br'),
type=markup.Element.EMPTY)
f = markup.Fragment(['before', br, 'after'])
self.assert_equal(len(f), 3)
f = f.copy()
self.assert_is_instance(f, markup.Fragment)
self.assert_equal(len(f), 3)
self.assert_equal(f[0], 'before')
self.assert_is_not(f[1], br)
self.assert_equal(f[2], 'after')
def test_link_href(self):
a = markup.Element(link._A)
with self.application():
l = link.Link('a')
l.render(a)
self.assert_equal(a.attrib, {})
self.assert_equal(a.children, [])
a = markup.Element(link._A,
attrib={link._HREF: None})
with self.application():
l = link.Link('a')
l.render(a)
self.assert_equal(a.attrib, {})
self.assert_equal(a.children, [])
a = markup.Element(link._A,
attrib={link._HREF: '/spam'})
with self.application():
l = link.Link('a')
l.render(a)
self.assert_equal(a.attrib, {link._HREF: '/spam'})
self.assert_equal(a.children, [])
def test_link_src(self):
script = markup.Element(link._SCRIPT)
with self.application():
l = link.Link('a')
l.render(script)
self.assert_equal(script.attrib, {})
self.assert_equal(script.children, [])
script = markup.Element(link._SCRIPT,
attrib={link._SRC: None})
with self.application():
l = link.Link('a')
l.render(script)
self.assert_equal(script.attrib, {})
self.assert_equal(script.children, [])
script = markup.Element(link._SCRIPT,
attrib={link._SRC: '/spam'})
with self.application():
l = link.Link('a')
l.render(script)
self.assert_equal(script.attrib, {link._SRC: '/spam'})
self.assert_equal(script.children, [])
def test_string_validator_maxlength(self):
root = markup.Element(validator._INPUT,
attrib={validator._TYPE: 'text'})
mc = ayame.MarkupContainer('a')
v = validator.StringValidator()
mc.add(v)
root = mc.render(root)
self.assert_equal(root.attrib, {validator._TYPE: 'text'})
v.max = 3
root = mc.render(root)
self.assert_equal(root.attrib, {
validator._TYPE: 'text',
validator._MAXLENGTH: '3'
})
def test_markup_handler(self):
class MarkupHandler(markup.MarkupHandler):
@property
def xml(self):
return super(MarkupHandler, self).xml
def is_empty(self, element):
return super(MarkupHandler, self).is_empty(element)
def start_tag(self):
super(MarkupHandler, self).start_tag()
self.renderer.write(u'start_tag\n')
def end_tag(self):
super(MarkupHandler, self).end_tag()
self.renderer.write(u'end_tag\n')
class MarkupRenderer(io.StringIO):
def peek(self):
pass
def writeln(self, *args):
for a in args:
self.write(a)
self.write(u'\n')
with self.assert_raises(TypeError):
markup.MarkupHandler(None)
r = MarkupRenderer()
h = MarkupHandler(r)
self.assert_is_none(h.xml)
self.assert_is_none(h.is_empty(None))
h.doctype(u'doctype')
h.start_tag()
h.end_tag()
h.text(0, u'')
h.text(0, u'text\n')
h.indent(0, 0)
self.assert_equal(r.getvalue(), u'doctype\nstart_tag\nend_tag\ntext\n')
elem = markup.Element(None)
elem[:] = ('',) * 3
h.compile(elem)
self.assert_equal(elem.children, [])
def new_ayame_element(name, **kwargs):
kwargs['type'] = markup.Element.OPEN
return markup.Element(self.ayame_of(name), **kwargs)
def new_element(name, type=markup.Element.OPEN, **kwargs):
return markup.Element(self.html_of(name), type=type, **kwargs)
def test_render_xml(self):
renderer = markup.MarkupRenderer()
xml = u"""\
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE spam SYSTEM "spam.dtd">
<spam xmlns="spam" a="a">
a
<eggs/>
b
c
<eggs:eggs xmlns:eggs="eggs" xmlns:ham="ham" a="1" ham:a="2">
<ham>
1
2
</ham>
</eggs:eggs>
</spam>
""".encode('iso-8859-1')
# pretty output
m = markup.Markup()
m.xml_decl = {
'version': u'1.0',
'encoding': u'iso-8859-1'
}
m.lang = 'xml'
m.doctype = u'<!DOCTYPE spam SYSTEM "spam.dtd">'
m.root = markup.Element(markup.QName(u'spam', u'spam'),
attrib={markup.QName(u'spam', u'a'): u'a'},
type=markup.Element.OPEN,
ns={u'': u'spam'})
m.root.append(u'\n'
u' a\n'
u' \n')
eggs = markup.Element(markup.QName(u'spam', u'eggs'),
type=markup.Element.EMPTY)
m.root.append(eggs)
m.root.append(u'\n'
u' b\n'
u' c\n')
eggs = markup.Element(markup.QName(u'eggs', u'eggs'),
attrib={markup.QName(u'eggs', u'a'): u'1',
markup.QName(u'ham', u'a'): u'2'},
type=markup.Element.OPEN,
ns={u'eggs': u'eggs',
u'ham': u'ham'})
ham = markup.Element(markup.QName(u'spam', u'ham'),
type=markup.Element.OPEN)
ham.append(u'\n'
u' 1\n'
u' 2\n')
eggs.append(ham)
m.root.append(eggs)
self.assert_equal(renderer.render(self, m, pretty=True), xml)
# raw output
m = markup.Markup()
m.xml_decl = {
'version': u'1.0',
'encoding': u'iso-8859-1'
}
m.lang = 'xml'
m.doctype = u'<!DOCTYPE spam SYSTEM "spam.dtd">'
m.root = markup.Element(markup.QName(u'spam', u'spam'),
attrib={markup.QName(u'spam', u'a'): u'a'},
type=markup.Element.OPEN,
ns={u'': u'spam'})
m.root.append(u'\n'
u' a\n'
u' ')
eggs = markup.Element(markup.QName(u'spam', u'eggs'))
eggs.type = markup.Element.EMPTY
m.root.append(eggs)
m.root.append(u'\n'
u' b\n'
u' c\n'
u' ')
eggs = markup.Element(markup.QName(u'eggs', u'eggs'),
attrib={markup.QName(u'eggs', u'a'): u'1',
markup.QName(u'ham', u'a'): u'2'},
type=markup.Element.OPEN,
ns={u'eggs': u'eggs',
u'ham': u'ham'})
eggs.append(u'\n'
u' ')
ham = markup.Element(markup.QName(u'spam', u'ham'),
type=markup.Element.OPEN)
ham.append(u'\n'
u' 1\n'
u' 2\n'
u' ')
eggs.append(ham)
eggs.append(u'\n'
u' ')
m.root.append(eggs)
m.root.append(u'\n')
self.assert_equal(renderer.render(self, m), xml)
