def test_wikilink(self):
"""tests for building Wikilink nodes"""
tests = [
([
tokens.WikilinkOpen(),
tokens.Text(text="foobar"),
tokens.WikilinkClose()
], wrap([Wikilink(wraptext("foobar"))])),
([
tokens.WikilinkOpen(),
tokens.Text(text="spam"),
tokens.Text(text="eggs"),
tokens.WikilinkClose()
], wrap([Wikilink(wraptext("spam", "eggs"))])),
([
tokens.WikilinkOpen(),
tokens.Text(text="foo"),
tokens.WikilinkSeparator(),
tokens.Text(text="bar"),
tokens.WikilinkClose()
], wrap([Wikilink(wraptext("foo"), wraptext("bar"))])),
([
tokens.WikilinkOpen(),
tokens.Text(text="foo"),
tokens.Text(text="bar"),
tokens.WikilinkSeparator(),
tokens.Text(text="baz"),
tokens.Text(text="biz"),
tokens.WikilinkClose()
], wrap([Wikilink(wraptext("foo", "bar"), wraptext("baz",
"biz"))])),
]
for test, valid in tests:
self.assertWikicodeEqual(valid, self.builder.build(test))
def test_integration2(self):
"""an even more audacious test for building a horrible wikicode mess"""
# {{a|b|{{c|[[d]]{{{e}}}}}}}[[f|{{{g}}}<!--h-->]]{{i|j= }}
test = [tokens.TemplateOpen(), tokens.Text(text="a"),
tokens.TemplateParamSeparator(), tokens.Text(text="b"),
tokens.TemplateParamSeparator(), tokens.TemplateOpen(),
tokens.Text(text="c"), tokens.TemplateParamSeparator(),
tokens.WikilinkOpen(), tokens.Text(text="d"),
tokens.WikilinkClose(), tokens.ArgumentOpen(),
tokens.Text(text="e"), tokens.ArgumentClose(),
tokens.TemplateClose(), tokens.TemplateClose(),
tokens.WikilinkOpen(), tokens.Text(text="f"),
tokens.WikilinkSeparator(), tokens.ArgumentOpen(),
tokens.Text(text="g"), tokens.ArgumentClose(),
tokens.CommentStart(), tokens.Text(text="h"),
tokens.CommentEnd(), tokens.WikilinkClose(),
tokens.TemplateOpen(), tokens.Text(text="i"),
tokens.TemplateParamSeparator(), tokens.Text(text="j"),
tokens.TemplateParamEquals(), tokens.HTMLEntityStart(),
tokens.Text(text="nbsp"), tokens.HTMLEntityEnd(),
tokens.TemplateClose()]
valid = wrap(
[Template(wraptext("a"), params=[Parameter(wraptext("1"), wraptext(
"b"), showkey=False), Parameter(wraptext("2"), wrap([Template(
wraptext("c"), params=[Parameter(wraptext("1"), wrap([Wikilink(
wraptext("d")), Argument(wraptext("e"))]), showkey=False)])]),
showkey=False)]), Wikilink(wraptext("f"), wrap([Argument(wraptext(
"g")), Comment("h")])), Template(wraptext("i"), params=[
Parameter(wraptext("j"), wrap([HTMLEntity("nbsp",
named=True)]))])])
self.assertWikicodeEqual(valid, self.builder.build(test))
def test_strip(self):
"""test Wikilink.__strip__()"""
node = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
for a in (True, False):
for b in (True, False):
self.assertEqual("foobar", node.__strip__(a, b))
self.assertEqual("bar", node2.__strip__(a, b))
def test_children(self):
"""test Wikilink.__children__()"""
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wrap([Text("bar"), Text("baz")]))
gen1 = node1.__children__()
gen2 = node2.__children__()
self.assertEqual(node1.title, next(gen1))
self.assertEqual(node2.title, next(gen2))
self.assertEqual(node2.text, next(gen2))
self.assertRaises(StopIteration, next, gen1)
self.assertRaises(StopIteration, next, gen2)
def test_title(self):
"""test getter/setter for the title attribute"""
title = wraptext("foobar")
node1 = Wikilink(title)
node2 = Wikilink(title, wraptext("baz"))
self.assertIs(title, node1.title)
self.assertIs(title, node2.title)
node1.title = "héhehé"
node2.title = "héhehé"
self.assertWikicodeEqual(wraptext("héhehé"), node1.title)
self.assertWikicodeEqual(wraptext("héhehé"), node2.title)
def test_text(self):
"""test getter/setter for the text attribute"""
text = wraptext("baz")
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foobar"), text)
self.assertIs(None, node1.text)
self.assertIs(text, node2.text)
node1.text = "buzz"
node2.text = None
self.assertWikicodeEqual(wraptext("buzz"), node1.text)
self.assertIs(None, node2.text)
def test_iternodes(self):
"""test Wikilink.__iternodes__()"""
node1n1 = Text("foobar")
node2n1, node2n2, node2n3 = Text("foo"), Text("bar"), Text("baz")
node1 = Wikilink(wrap([node1n1]))
node2 = Wikilink(wrap([node2n1]), wrap([node2n2, node2n3]))
gen1 = node1.__iternodes__(getnodes)
gen2 = node2.__iternodes__(getnodes)
self.assertEqual((None, node1), next(gen1))
self.assertEqual((None, node2), next(gen2))
self.assertEqual((node1.title, node1n1), next(gen1))
self.assertEqual((node2.title, node2n1), next(gen2))
self.assertEqual((node2.text, node2n2), next(gen2))
self.assertEqual((node2.text, node2n3), next(gen2))
self.assertRaises(StopIteration, next, gen1)
self.assertRaises(StopIteration, next, gen2)
def test_showtree(self):
"""test Wikilink.__showtree__()"""
output = []
getter, marker = object(), object()
get = lambda code: output.append((getter, code))
mark = lambda: output.append(marker)
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
node1.__showtree__(output.append, get, mark)
node2.__showtree__(output.append, get, mark)
valid = [
"[[", (getter, node1.title), "]]", "[[", (getter, node2.title),
" | ", marker, (getter, node2.text), "]]"]
self.assertEqual(valid, output)
def test_strip(self):
"""test Wikilink.__strip__()"""
node = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
for a in (True, False):
for b in (True, False):
self.assertEqual("foobar", node.__strip__(a, b))
self.assertEqual("bar", node2.__strip__(a, b))
def test_text(self):
"""test getter/setter for the text attribute"""
text = wraptext("baz")
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foobar"), text)
self.assertIs(None, node1.text)
self.assertIs(text, node2.text)
node1.text = "buzz"
node2.text = None
self.assertWikicodeEqual(wraptext("buzz"), node1.text)
self.assertIs(None, node2.text)
def test_title(self):
"""test getter/setter for the title attribute"""
title = wraptext("foobar")
node1 = Wikilink(title)
node2 = Wikilink(title, wraptext("baz"))
self.assertIs(title, node1.title)
self.assertIs(title, node2.title)
node1.title = "héhehé"
node2.title = "héhehé"
self.assertWikicodeEqual(wraptext("héhehé"), node1.title)
self.assertWikicodeEqual(wraptext("héhehé"), node2.title)
def test_children(self):
"""test Wikilink.__children__()"""
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wrap([Text("bar"), Text("baz")]))
gen1 = node1.__children__()
gen2 = node2.__children__()
self.assertEqual(node1.title, next(gen1))
self.assertEqual(node2.title, next(gen2))
self.assertEqual(node2.text, next(gen2))
self.assertRaises(StopIteration, next, gen1)
self.assertRaises(StopIteration, next, gen2)
def test_showtree(self):
"""test Wikilink.__showtree__()"""
output = []
getter, marker = object(), object()
get = lambda code: output.append((getter, code))
mark = lambda: output.append(marker)
node1 = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
node1.__showtree__(output.append, get, mark)
node2.__showtree__(output.append, get, mark)
valid = [
"[[", (getter, node1.title), "]]", "[[", (getter, node2.title),
" | ", marker, (getter, node2.text), "]]"]
self.assertEqual(valid, output)
def test_parsing(self):
"""integration test for parsing overall"""
text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}"
expected = wrap([
Text("this is text; "),
Template(wraptext("this"), [
Parameter(wraptext("is"), wraptext("a")),
Parameter(wraptext("template"), wrap([
Template(wraptext("with"), [
Parameter(wraptext("1"),
wrap([Wikilink(wraptext("links"))]),
showkey=False),
Parameter(wraptext("2"),
wraptext("in"), showkey=False)
]),
Text("it")
]))
])
])
actual = parser.Parser().parse(text)
self.assertWikicodeEqual(expected, actual)
def test_strip(self):
"""test Wikilink.__strip__()"""
node = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
self.assertEqual("foobar", node.__strip__())
self.assertEqual("bar", node2.__strip__())
def test_strip(self):
"""test Wikilink.__strip__()"""
node = Wikilink(wraptext("foobar"))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
self.assertEqual("foobar", node.__strip__())
self.assertEqual("bar", node2.__strip__())
def test_tag(self):
"""tests for building Tag nodes"""
tests = [
# <ref></ref>
([
tokens.TagOpenOpen(),
tokens.Text(text="ref"),
tokens.TagCloseOpen(padding=""),
tokens.TagOpenClose(),
tokens.Text(text="ref"),
tokens.TagCloseClose()
],
wrap(
[Tag(wraptext("ref"), wrap([]),
closing_tag=wraptext("ref"))])),
# <ref name></ref>
([
tokens.TagOpenOpen(),
tokens.Text(text="ref"),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="name"),
tokens.TagCloseOpen(padding=""),
tokens.TagOpenClose(),
tokens.Text(text="ref"),
tokens.TagCloseClose()
],
wrap([
Tag(wraptext("ref"),
wrap([]),
attrs=[Attribute(wraptext("name"))])
])),
# <ref name="abc" />
([
tokens.TagOpenOpen(),
tokens.Text(text="ref"),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="name"),
tokens.TagAttrEquals(),
tokens.TagAttrQuote(char='"'),
tokens.Text(text="abc"),
tokens.TagCloseSelfclose(padding=" ")
],
wrap([
Tag(wraptext("ref"),
attrs=[Attribute(wraptext("name"), wraptext("abc"))],
self_closing=True,
padding=" ")
])),
# <br/>
([
tokens.TagOpenOpen(),
tokens.Text(text="br"),
tokens.TagCloseSelfclose(padding="")
], wrap([Tag(wraptext("br"), self_closing=True)])),
# <li>
([
tokens.TagOpenOpen(),
tokens.Text(text="li"),
tokens.TagCloseSelfclose(padding="", implicit=True)
], wrap([Tag(wraptext("li"), self_closing=True, implicit=True)])),
# </br>
([
tokens.TagOpenOpen(invalid=True),
tokens.Text(text="br"),
tokens.TagCloseSelfclose(padding="", implicit=True)
],
wrap([
Tag(wraptext("br"),
self_closing=True,
invalid=True,
implicit=True)
])),
# </br/>
([
tokens.TagOpenOpen(invalid=True),
tokens.Text(text="br"),
tokens.TagCloseSelfclose(padding="")
], wrap([Tag(wraptext("br"), self_closing=True, invalid=True)])),
# <ref name={{abc}} foo="bar {{baz}}" abc={{de}}f ghi=j{{k}}{{l}}
# mno = '{{p}} [[q]] {{r}}'>[[Source]]</ref>
([
tokens.TagOpenOpen(),
tokens.Text(text="ref"),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="name"),
tokens.TagAttrEquals(),
tokens.TemplateOpen(),
tokens.Text(text="abc"),
tokens.TemplateClose(),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="foo"),
tokens.TagAttrEquals(),
tokens.TagAttrQuote(char='"'),
tokens.Text(text="bar "),
tokens.TemplateOpen(),
tokens.Text(text="baz"),
tokens.TemplateClose(),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="abc"),
tokens.TagAttrEquals(),
tokens.TemplateOpen(),
tokens.Text(text="de"),
tokens.TemplateClose(),
tokens.Text(text="f"),
tokens.TagAttrStart(pad_first=" ",
pad_before_eq="",
pad_after_eq=""),
tokens.Text(text="ghi"),
tokens.TagAttrEquals(),
tokens.Text(text="j"),
tokens.TemplateOpen(),
tokens.Text(text="k"),
tokens.TemplateClose(),
tokens.TemplateOpen(),
tokens.Text(text="l"),
tokens.TemplateClose(),
tokens.TagAttrStart(pad_first=" \n ",
pad_before_eq=" ",
pad_after_eq=" "),
tokens.Text(text="mno"),
tokens.TagAttrEquals(),
tokens.TagAttrQuote(char="'"),
tokens.TemplateOpen(),
tokens.Text(text="p"),
tokens.TemplateClose(),
tokens.Text(text=" "),
tokens.WikilinkOpen(),
tokens.Text(text="q"),
tokens.WikilinkClose(),
tokens.Text(text=" "),
tokens.TemplateOpen(),
tokens.Text(text="r"),
tokens.TemplateClose(),
tokens.TagCloseOpen(padding=""),
tokens.WikilinkOpen(),
tokens.Text(text="Source"),
tokens.WikilinkClose(),
tokens.TagOpenClose(),
tokens.Text(text="ref"),
tokens.TagCloseClose()
],
wrap([
Tag(wraptext("ref"), wrap([Wikilink(wraptext("Source"))]), [
Attribute(wraptext("name"),
wrap([Template(wraptext("abc"))]), None),
Attribute(wraptext("foo"),
wrap([Text("bar "),
Template(wraptext("baz"))]),
pad_first=" "),
Attribute(wraptext("abc"),
wrap([Template(wraptext("de")),
Text("f")]), None),
Attribute(
wraptext("ghi"),
wrap([
Text("j"),
Template(wraptext("k")),
Template(wraptext("l"))
]), None),
Attribute(
wraptext("mno"),
wrap([
Template(wraptext("p")),
Text(" "),
Wikilink(wraptext("q")),
Text(" "),
Template(wraptext("r"))
]), "'", " \n ", " ", " ")
])
])),
# "''italic text''"
([
tokens.TagOpenOpen(wiki_markup="''"),
tokens.Text(text="i"),
tokens.TagCloseOpen(),
tokens.Text(text="italic text"),
tokens.TagOpenClose(),
tokens.Text(text="i"),
tokens.TagCloseClose()
],
wrap([
Tag(wraptext("i"), wraptext("italic text"), wiki_markup="''")
])),
# * bullet
([
tokens.TagOpenOpen(wiki_markup="*"),
tokens.Text(text="li"),
tokens.TagCloseSelfclose(),
tokens.Text(text=" bullet")
],
wrap([
Tag(wraptext("li"), wiki_markup="*", self_closing=True),
Text(" bullet")
])),
]
for test, valid in tests:
self.assertWikicodeEqual(valid, self.builder.build(test))
def test_unicode(self):
"""test Wikilink.__unicode__()"""
node = Wikilink(wraptext("foobar"))
self.assertEqual("[[foobar]]", str(node))
node2 = Wikilink(wraptext("foo"), wraptext("bar"))
self.assertEqual("[[foo|bar]]", str(node2))
