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

tests/test_parser.py

@@ -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)

tests/test_smart_list.py

@@ -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"""