Procházet zdrojové kódy

Implement test_parser(). Clean up a few lambdas in TestSmartList.

tags/v0.2
Ben Kurtovic před 11 roky
rodič
revize
97a837c1e8
2 změnil soubory, kde provedl 65 přidání a 5 odebrání
  1. +61
    -1
      tests/test_parser.py
  2. +4
    -4
      tests/test_smart_list.py

+ 61
- 1
tests/test_parser.py Zobrazit soubor

@@ -23,8 +23,68 @@
from __future__ import unicode_literals
import unittest

from mwparserfromhell.compat import range
from mwparserfromhell.nodes import Template, Text, Wikilink
from mwparserfromhell.nodes.extras import Parameter
from mwparserfromhell.parser import Parser
from mwparserfromhell.smart_list import SmartList
from mwparserfromhell.wikicode import Wikicode

class TestParser(unittest.TestCase):
pass
"""Tests for the Parser class itself, which tokenizes and builds nodes."""

def assertNodesEqual(self, expected, actual):
"""Assert that two Nodes are the same type and have the same data."""
self.assertIs(type(expected), type(actual))
if isinstance(expected, Text):
self.assertEqual(expected.value, actual.value)
elif isinstance(expected, Template):
self.assertWikicodeEqual(expected.name, actual.name)
length = len(expected.params)
self.assertEqual(length, len(actual.params))
for i in range(length):
exp_param = expected.params[i]
act_param = actual.params[i]
self.assertWikicodeEqual(exp_param.name, act_param.name)
self.assertWikicodeEqual(exp_param.value, act_param.value)
self.assertIs(exp_param.showkey, act_param.showkey)
elif isinstance(expected, Wikilink):
self.assertWikicodeEqual(expected.title, actual.title)
if expected.text is not None:
self.assertWikicodeEqual(expected.text, actual.text)
else:
self.assertIs(None, actual.text)

def assertWikicodeEqual(self, expected, actual):
"""Assert that two Wikicode objects have the same data."""
self.assertIsInstance(actual, Wikicode)
length = len(expected.nodes)
self.assertEqual(length, len(actual.nodes))
for i in range(length):
self.assertNodesEqual(expected.get(i), actual.get(i))

def test_parser(self):
"""integration test for parsing overall"""
text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}"
wrap = lambda L: Wikicode(SmartList(L))
expected = wrap([
Text("this is text; "),
Template(wrap([Text("this")]), [
Parameter(wrap([Text("is")]), wrap([Text("a")])),
Parameter(wrap([Text("template")]), wrap([
Template(wrap([Text("with")]), [
Parameter(wrap([Text("1")]),
wrap([Wikilink(wrap([Text("links")]))]),
showkey=False),
Parameter(wrap([Text("2")]),
wrap([Text("in")]), showkey=False)
]),
Text("it")
]))
])
])
actual = Parser(text).parse()
self.assertWikicodeEqual(expected, actual)

if __name__ == "__main__":
unittest.main(verbosity=2)

+ 4
- 4
tests/test_smart_list.py Zobrazit soubor

@@ -288,19 +288,19 @@ class TestSmartList(unittest.TestCase):

def test_parent_get_set_del(self):
"""make sure SmartList's getitem/setitem/delitem work"""
self._test_get_set_del_item(lambda L: SmartList(L))
self._test_get_set_del_item(SmartList)

def test_parent_add(self):
"""make sure SmartList's add/radd/iadd work"""
self._test_add_radd_iadd(lambda L: SmartList(L))
self._test_add_radd_iadd(SmartList)

def test_parent_unaffected_magics(self):
"""sanity checks against SmartList features that were not modified"""
self._test_other_magic_methods(lambda L: SmartList(L))
self._test_other_magic_methods(SmartList)

def test_parent_methods(self):
"""make sure SmartList's non-magic methods work, like append()"""
self._test_list_methods(lambda L: SmartList(L))
self._test_list_methods(SmartList)

def test_child_get_set_del(self):
"""make sure _ListProxy's getitem/setitem/delitem work"""


Načítá se…
Zrušit
Uložit