ben
/
mwparserfromhell
kopia lustrzana https://github.com/earwig/mwparserfromhell
1
1
Forkuj 0
Kod Wydania 24 Aktywność
A Python parser for MediaWiki wikicode https://mwparserfromhell.readthedocs.io/
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
276 Commity
1 Gałąź
28 MiB
 
 
 
 
Drzewo: 7853e20745
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '7853e20745'
${ noResults }
mwparserfromhell/tests/test_template.py

341 wiersze
17 KiB
Czysty Wina Historia 

  1. # -*- coding: utf-8  -*-

  2. #

  3. # Copyright (C) 2012-2013 Ben Kurtovic <ben.kurtovic@verizon.net>

  4. #

  5. # Permission is hereby granted, free of charge, to any person obtaining a copy

  6. # of this software and associated documentation files (the "Software"), to deal

  7. # in the Software without restriction, including without limitation the rights

  8. # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9. # copies of the Software, and to permit persons to whom the Software is

  10. # furnished to do so, subject to the following conditions:

  11. #

  12. # The above copyright notice and this permission notice shall be included in

  13. # all copies or substantial portions of the Software.

  14. #

  15. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16. # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17. # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18. # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19. # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20. # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  21. # SOFTWARE.

  22. 

  23. from __future__ import unicode_literals

  24. import unittest

  25. 

  26. from mwparserfromhell.compat import str

  27. from mwparserfromhell.nodes import HTMLEntity, Template, Text

  28. from mwparserfromhell.nodes.extras import Parameter

  29. from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext

  30. 

  31. pgens = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=True)

  32. pgenh = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=False)

  33. 

  34. class TestTemplate(TreeEqualityTestCase):

  35.     """Test cases for the Template node."""

  36. 

  37.     def test_unicode(self):

  38.         """test Template.__unicode__()"""

  39.         node = Template(wraptext("foobar"))

  40.         self.assertEqual("{{foobar}}", str(node))

  41.         node2 = Template(wraptext("foo"),

  42.                          [pgenh("1", "bar"), pgens("abc", "def")])

  43.         self.assertEqual("{{foo|bar|abc=def}}", str(node2))

  44. 

  45.     def test_strip(self):

  46.         """test Template.__strip__()"""

  47.         node1 = Template(wraptext("foobar"))

  48.         node2 = Template(wraptext("foo"),

  49.                          [pgenh("1", "bar"), pgens("abc", "def")])

  50.         for a in (True, False):

  51.             for b in (True, False):

  52.                 self.assertEqual(None, node1.__strip__(a, b))

  53.                 self.assertEqual(None, node2.__strip__(a, b))

  54. 

  55.     def test_showtree(self):

  56.         """test Template.__showtree__()"""

  57.         output = []

  58.         getter, marker = object(), object()

  59.         get = lambda code: output.append((getter, code))

  60.         mark = lambda: output.append(marker)

  61.         node1 = Template(wraptext("foobar"))

  62.         node2 = Template(wraptext("foo"),

  63.                          [pgenh("1", "bar"), pgens("abc", "def")])

  64.         node1.__showtree__(output.append, get, mark)

  65.         node2.__showtree__(output.append, get, mark)

  66.         valid = [

  67.             "{{", (getter, node1.name), "}}", "{{", (getter, node2.name),

  68.             "    | ", marker, (getter, node2.params[0].name), "    = ", marker,

  69.             (getter, node2.params[0].value), "    | ", marker,

  70.             (getter, node2.params[1].name), "    = ", marker,

  71.             (getter, node2.params[1].value), "}}"]

  72.         self.assertEqual(valid, output)

  73. 

  74.     def test_name(self):

  75.         """test getter/setter for the name attribute"""

  76.         name = wraptext("foobar")

  77.         node1 = Template(name)

  78.         node2 = Template(name, [pgenh("1", "bar")])

  79.         self.assertIs(name, node1.name)

  80.         self.assertIs(name, node2.name)

  81.         node1.name = "asdf"

  82.         node2.name = "téstïng"

  83.         self.assertWikicodeEqual(wraptext("asdf"), node1.name)

  84.         self.assertWikicodeEqual(wraptext("téstïng"), node2.name)

  85. 

  86.     def test_params(self):

  87.         """test getter for the params attribute"""

  88.         node1 = Template(wraptext("foobar"))

  89.         plist = [pgenh("1", "bar"), pgens("abc", "def")]

  90.         node2 = Template(wraptext("foo"), plist)

  91.         self.assertEqual([], node1.params)

  92.         self.assertIs(plist, node2.params)

  93. 

  94.     def test_has_param(self):

  95.         """test Template.has_param()"""

  96.         node1 = Template(wraptext("foobar"))

  97.         node2 = Template(wraptext("foo"),

  98.                          [pgenh("1", "bar"), pgens("\nabc ", "def")])

  99.         node3 = Template(wraptext("foo"),

  100.                          [pgenh("1", "a"), pgens("b", "c"), pgens("1", "d")])

  101.         node4 = Template(wraptext("foo"), [pgenh("1", "a"), pgens("b", " ")])

  102.         self.assertFalse(node1.has_param("foobar"))

  103.         self.assertTrue(node2.has_param(1))

  104.         self.assertTrue(node2.has_param("abc"))

  105.         self.assertFalse(node2.has_param("def"))

  106.         self.assertTrue(node3.has_param("1"))

  107.         self.assertTrue(node3.has_param(" b "))

  108.         self.assertFalse(node4.has_param("b"))

  109.         self.assertTrue(node3.has_param("b", False))

  110.         self.assertTrue(node4.has_param("b", False))

  111. 

  112.     def test_get(self):

  113.         """test Template.get()"""

  114.         node1 = Template(wraptext("foobar"))

  115.         node2p1 = pgenh("1", "bar")

  116.         node2p2 = pgens("abc", "def")

  117.         node2 = Template(wraptext("foo"), [node2p1, node2p2])

  118.         node3p1 = pgens("b", "c")

  119.         node3p2 = pgens("1", "d")

  120.         node3 = Template(wraptext("foo"), [pgenh("1", "a"), node3p1, node3p2])

  121.         node4p1 = pgens(" b", " ")

  122.         node4 = Template(wraptext("foo"), [pgenh("1", "a"), node4p1])

  123.         self.assertRaises(ValueError, node1.get, "foobar")

  124.         self.assertIs(node2p1, node2.get(1))

  125.         self.assertIs(node2p2, node2.get("abc"))

  126.         self.assertRaises(ValueError, node2.get, "def")

  127.         self.assertIs(node3p1, node3.get("b"))

  128.         self.assertIs(node3p2, node3.get("1"))

  129.         self.assertIs(node4p1, node4.get("b "))

  130. 

  131.     def test_add(self):

  132.         """test Template.add()"""

  133.         node1 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  134.         node2 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  135.         node3 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  136.         node4 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  137.         node5 = Template(wraptext("a"), [pgens("b", "c"),

  138.                                          pgens("    d ", "e")])

  139.         node6 = Template(wraptext("a"), [pgens("b", "c"), pgens("b", "d"),

  140.                                          pgens("b", "e")])

  141.         node7 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  142.         node8p = pgenh("1", "d")

  143.         node8 = Template(wraptext("a"), [pgens("b", "c"), node8p])

  144.         node9 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")])

  145.         node10 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "e")])

  146.         node11 = Template(wraptext("a"), [pgens("b", "c")])

  147.         node12 = Template(wraptext("a"), [pgens("b", "c")])

  148.         node13 = Template(wraptext("a"), [

  149.             pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")])

  150.         node14 = Template(wraptext("a\n"), [

  151.             pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"),

  152.             pgens("h ", " i\n")])

  153.         node15 = Template(wraptext("a"), [

  154.             pgens("b  ", " c\n"), pgens("\nd  ", " e"), pgens("\nf  ", "g ")])

  155.         node16 = Template(wraptext("a"), [

  156.             pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")])

  157.         node17 = Template(wraptext("a"), [

  158.             pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")])

  159.         node18 = Template(wraptext("a\n"), [

  160.             pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"),

  161.             pgens("h ", " i\n")])

  162.         node19 = Template(wraptext("a"), [

  163.             pgens("b  ", " c\n"), pgens("\nd  ", " e"), pgens("\nf  ", "g ")])

  164.         node20 = Template(wraptext("a"), [

  165.             pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")])

  166.         node21 = Template(wraptext("a"), [pgenh("1", "b")])

  167.         node22 = Template(wraptext("a"), [pgenh("1", "b")])

  168.         node23 = Template(wraptext("a"), [pgenh("1", "b")])

  169.         node24 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"),

  170.                                           pgenh("3", "d"), pgenh("4", "e")])

  171.         node25 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"),

  172.                                           pgens("4", "d"), pgens("5", "e")])

  173.         node26 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"),

  174.                                           pgens("4", "d"), pgens("5", "e")])

  175.         node27 = Template(wraptext("a"), [pgenh("1", "b")])

  176.         node28 = Template(wraptext("a"), [pgenh("1", "b")])

  177.         node29 = Template(wraptext("a"), [pgens("b", "c")])

  178.         node30 = Template(wraptext("a"), [pgenh("1", "b")])

  179.         node31 = Template(wraptext("a"), [pgenh("1", "b")])

  180.         node32 = Template(wraptext("a"), [pgens("1", "b")])

  181.         node33 = Template(wraptext("a"), [

  182.             pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")])

  183.         node34 = Template(wraptext("a\n"), [

  184.             pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"),

  185.             pgens("h ", " i\n")])

  186.         node35 = Template(wraptext("a"), [

  187.             pgens("b  ", " c\n"), pgens("\nd  ", " e"), pgens("\nf  ", "g ")])

  188.         node36 = Template(wraptext("a"), [

  189.             pgens("\nb ", " c "), pgens("\nd ", " e "), pgens("\nf ", " g ")])

  190.         node37 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"),

  191.                                           pgens("b", "f"), pgens("b", "h"),

  192.                                           pgens("i", "j")])

  193.         node37 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"),

  194.                                           pgens("b", "f"), pgens("b", "h"),

  195.                                           pgens("i", "j")])

  196.         node38 = Template(wraptext("a"), [pgens("1", "b"), pgens("x", "y"),

  197.                                           pgens("1", "c"), pgens("2", "d")])

  198.         node39 = Template(wraptext("a"), [pgens("1", "b"), pgens("x", "y"),

  199.                                           pgenh("1", "c"), pgenh("2", "d")])

  200.         node40 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"),

  201.                                           pgens("f", "g")])

  202. 

  203.         node1.add("e", "f", showkey=True)

  204.         node2.add(2, "g", showkey=False)

  205.         node3.add("e", "foo|bar", showkey=True)

  206.         node4.add("e", "f", showkey=True, before="b")

  207.         node5.add("f", "g", showkey=True, before=" d     ")

  208.         node6.add("f", "g", showkey=True, before="b")

  209.         self.assertRaises(ValueError, node7.add, "e", "f", showkey=True,

  210.                           before="q")

  211.         node8.add("e", "f", showkey=True, before=node8p)

  212.         node9.add("e", "f", showkey=True, before=pgenh("1", "d"))

  213.         self.assertRaises(ValueError, node10.add, "e", "f", showkey=True,

  214.                           before=pgenh("1", "d"))

  215.         node11.add("d", "foo=bar", showkey=True)

  216.         node12.add("1", "foo=bar", showkey=False)

  217.         node13.add("h", "i", showkey=True)

  218.         node14.add("j", "k", showkey=True)

  219.         node15.add("h", "i", showkey=True)

  220.         node16.add("h", "i", showkey=True, preserve_spacing=False)

  221.         node17.add("h", "i", showkey=False)

  222.         node18.add("j", "k", showkey=False)

  223.         node19.add("h", "i", showkey=False)

  224.         node20.add("h", "i", showkey=False, preserve_spacing=False)

  225.         node21.add("2", "c")

  226.         node22.add("3", "c")

  227.         node23.add("c", "d")

  228.         node24.add("5", "f")

  229.         node25.add("3", "f")

  230.         node26.add("6", "f")

  231.         node27.add("c", "foo=bar")

  232.         node28.add("2", "foo=bar")

  233.         node29.add("b", "d")

  234.         node30.add("1", "foo=bar")

  235.         node31.add("1", "foo=bar", showkey=True)

  236.         node32.add("1", "foo=bar", showkey=False)

  237.         node33.add("d", "foo")

  238.         node34.add("f", "foo")

  239.         node35.add("f", "foo")

  240.         node36.add("d", "foo", preserve_spacing=False)

  241.         node37.add("b", "k")

  242.         node38.add("1", "e")

  243.         node39.add("1", "e")

  244.         node40.add("d", "h", before="b")

  245. 

  246.         self.assertEqual("{{a|b=c|d|e=f}}", node1)

  247.         self.assertEqual("{{a|b=c|d|g}}", node2)

  248.         self.assertEqual("{{a|b=c|d|e=foo&#124;bar}}", node3)

  249.         self.assertIsInstance(node3.params[2].value.get(1), HTMLEntity)

  250.         self.assertEqual("{{a|e=f|b=c|d}}", node4)

  251.         self.assertEqual("{{a|b=c|f=g|    d =e}}", node5)

  252.         self.assertEqual("{{a|b=c|b=d|f=g|b=e}}", node6)

  253.         self.assertEqual("{{a|b=c|d}}", node7)

  254.         self.assertEqual("{{a|b=c|e=f|d}}", node8)

  255.         self.assertEqual("{{a|b=c|e=f|d}}", node9)

  256.         self.assertEqual("{{a|b=c|e}}", node10)

  257.         self.assertEqual("{{a|b=c|d=foo=bar}}", node11)

  258.         self.assertEqual("{{a|b=c|foo&#61;bar}}", node12)

  259.         self.assertIsInstance(node12.params[1].value.get(1), HTMLEntity)

  260.         self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|\nh = i}}", node13)

  261.         self.assertEqual("{{a\n|b =c\n|d = e|f =g\n|h = i\n|j =k\n}}", node14)

  262.         self.assertEqual("{{a|b  = c\n|\nd  = e|\nf  =g |h  =i}}", node15)

  263.         self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|h=i}}", node16)

  264.         self.assertEqual("{{a|\nb = c|\nd = e|\nf = g| i}}", node17)

  265.         self.assertEqual("{{a\n|b =c\n|d = e|f =g\n|h = i\n|k\n}}", node18)

  266.         self.assertEqual("{{a|b  = c\n|\nd  = e|\nf  =g |i}}", node19)

  267.         self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|i}}", node20)

  268.         self.assertEqual("{{a|b|c}}", node21)

  269.         self.assertEqual("{{a|b|3=c}}", node22)

  270.         self.assertEqual("{{a|b|c=d}}", node23)

  271.         self.assertEqual("{{a|b|c|d|e|f}}", node24)

  272.         self.assertEqual("{{a|b|c|4=d|5=e|f}}", node25)

  273.         self.assertEqual("{{a|b|c|4=d|5=e|6=f}}", node26)

  274.         self.assertEqual("{{a|b|c=foo=bar}}", node27)

  275.         self.assertEqual("{{a|b|foo&#61;bar}}", node28)

  276.         self.assertIsInstance(node28.params[1].value.get(1), HTMLEntity)

  277.         self.assertEqual("{{a|b=d}}", node29)

  278.         self.assertEqual("{{a|foo&#61;bar}}", node30)

  279.         self.assertIsInstance(node30.params[0].value.get(1), HTMLEntity)

  280.         self.assertEqual("{{a|1=foo=bar}}", node31)

  281.         self.assertEqual("{{a|foo&#61;bar}}", node32)

  282.         self.assertIsInstance(node32.params[0].value.get(1), HTMLEntity)

  283.         self.assertEqual("{{a|\nb = c|\nd = foo|\nf = g}}", node33)

  284.         self.assertEqual("{{a\n|b =c\n|d = e|f =foo\n|h = i\n}}", node34)

  285.         self.assertEqual("{{a|b  = c\n|\nd  = e|\nf  =foo }}", node35)

  286.         self.assertEqual("{{a|\nb = c |\nd =foo|\nf = g }}", node36)

  287.         self.assertEqual("{{a|b=k|d=e|i=j}}", node37)

  288.         self.assertEqual("{{a|1=e|x=y|2=d}}", node38)

  289.         self.assertEqual("{{a|x=y|e|d}}", node39)

  290.         self.assertEqual("{{a|b=c|d=h|f=g}}", node40)

  291. 

  292.     def test_remove(self):

  293.         """test Template.remove()"""

  294.         node1 = Template(wraptext("foobar"))

  295.         node2 = Template(wraptext("foo"), [pgenh("1", "bar"),

  296.                                            pgens("abc", "def")])

  297.         node3 = Template(wraptext("foo"), [pgenh("1", "bar"),

  298.                                            pgens("abc", "def")])

  299.         node4 = Template(wraptext("foo"), [pgenh("1", "bar"),

  300.                                            pgenh("2", "baz")])

  301.         node5 = Template(wraptext("foo"), [

  302.             pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")])

  303.         node6 = Template(wraptext("foo"), [

  304.             pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")])

  305.         node7 = Template(wraptext("foo"), [

  306.             pgens("1  ", "a"), pgens("  1", "b"), pgens("2", "c")])

  307.         node8 = Template(wraptext("foo"), [

  308.             pgens("1  ", "a"), pgens("  1", "b"), pgens("2", "c")])

  309.         node9 = Template(wraptext("foo"), [

  310.             pgens("1  ", "a"), pgenh("1", "b"), pgenh("2", "c")])

  311.         node10 = Template(wraptext("foo"), [

  312.             pgens("1  ", "a"), pgenh("1", "b"), pgenh("2", "c")])

  313. 

  314.         node2.remove("1")

  315.         node2.remove("abc")

  316.         node3.remove(1, keep_field=True)

  317.         node3.remove("abc", keep_field=True)

  318.         node4.remove("1", keep_field=False)

  319.         node5.remove("a", keep_field=False)

  320.         node6.remove("a", keep_field=True)

  321.         node7.remove(1, keep_field=True)

  322.         node8.remove(1, keep_field=False)

  323.         node9.remove(1, keep_field=True)

  324.         node10.remove(1, keep_field=False)

  325. 

  326.         self.assertRaises(ValueError, node1.remove, 1)

  327.         self.assertRaises(ValueError, node1.remove, "a")

  328.         self.assertRaises(ValueError, node2.remove, "1")

  329.         self.assertEqual("{{foo}}", node2)

  330.         self.assertEqual("{{foo||abc=}}", node3)

  331.         self.assertEqual("{{foo||baz}}", node4)

  332.         self.assertEqual("{{foo|b=c}}", node5)

  333.         self.assertEqual("{{foo| a=|b=c}}", node6)

  334.         self.assertEqual("{{foo|1  =|2=c}}", node7)

  335.         self.assertEqual("{{foo|2=c}}", node8)

  336.         self.assertEqual("{{foo||c}}", node9)

  337.         self.assertEqual("{{foo||c}}", node10)

  338. 

  339. if __name__ == "__main__":

  340.     unittest.main(verbosity=2)