Use py.test to generate tests from the data files themselves.

gsnedders · gsnedders · commit 1830d671d977 · 2015-12-03T03:29:18.000Z
diff --git a/.pytest.expect b/.pytest.expect
diff --git a/html5lib/tests/conftest.py b/html5lib/tests/conftest.py
@@ -0,0 +1,21 @@
+import os.path
+
+from .tree_construction import TreeConstructionFile
+
+_dir = os.path.abspath(os.path.dirname(__file__))
+_testdata = os.path.join(_dir, "testdata")
+_tree_construction = os.path.join(_testdata, "tree-construction")
+
+
+def pytest_collectstart():
+    """check to see if the git submodule has been init'd"""
+    pass
+
+
+def pytest_collect_file(path, parent):
+    dir = os.path.abspath(path.dirname)
+    if dir == _tree_construction:
+        if path.basename == "template.dat":
+            return
+        if path.ext == ".dat":
+            return TreeConstructionFile(path, parent)
diff --git a/html5lib/tests/support.py b/html5lib/tests/support.py
@@ -38,7 +38,7 @@
 try:
     import lxml.etree as lxml  # flake8: noqa
 except ImportError:
-    pass
+    treeTypes['lxml'] = None
 else:
     treeTypes['lxml'] = treebuilders.getTreeBuilder("lxml")
 
@@ -65,9 +65,6 @@ def __init__(self, filename, newTestHeading="data", encoding="utf8"):
         self.encoding = encoding
         self.newTestHeading = newTestHeading
 
-    def __del__(self):
-        self.f.close()
-
     def __iter__(self):
         data = DefaultDict(None)
         key = None
diff --git a/html5lib/tests/test_parser.py b/html5lib/tests/test_parser.py
diff --git a/html5lib/tests/tree_construction.py b/html5lib/tests/tree_construction.py
@@ -0,0 +1,94 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import warnings
+import re
+
+import pytest
+
+from .support import TestData, convert, convertExpected, treeTypes
+from html5lib import html5parser, constants
+
+
+class TreeConstructionFile(pytest.File):
+    def collect(self):
+        tests = TestData(str(self.fspath), "data")
+        for i, test in enumerate(tests):
+            for treeName, treeClass in sorted(treeTypes.items()):
+                for namespaceHTMLElements in (True, False):
+                    if namespaceHTMLElements:
+                        nodeid = "%d::%s::namespaced" % (i, treeName)
+                    else:
+                        nodeid = "%d::%s::void-namespace" % (i, treeName)
+                    item = ParserTest(nodeid, self,
+                                      test, treeClass, namespaceHTMLElements)
+                    item.add_marker(getattr(pytest.mark, treeName))
+                    if namespaceHTMLElements:
+                        item.add_marker(pytest.mark.namespaced)
+                    if treeClass is None:
+                        item.add_marker(pytest.mark.skipif(True, reason="Treebuilder not loaded"))
+                    yield item
+
+
+def convertTreeDump(data):
+    return "\n".join(convert(3)(data).split("\n")[1:])
+
+namespaceExpected = re.compile(r"^(\s*)<(\S+)>", re.M).sub
+
+
+class ParserTest(pytest.Item):
+    def __init__(self, name, parent, test, treeClass, namespaceHTMLElements):
+        super(ParserTest, self).__init__(name, parent)
+        self.obj = lambda: 1  # this is to hack around skipif needing a function!
+        self.test = test
+        self.treeClass = treeClass
+        self.namespaceHTMLElements = namespaceHTMLElements
+
+    def runtest(self):
+        p = html5parser.HTMLParser(tree=self.treeClass,
+                                   namespaceHTMLElements=self.namespaceHTMLElements)
+
+        input = self.test['data']
+        fragmentContainer = self.test['document-fragment']
+        expected = self.test['document']
+        expectedErrors = self.test['errors'].split("\n") if self.test['errors'] else []
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            try:
+                if fragmentContainer:
+                    document = p.parseFragment(input, fragmentContainer)
+                else:
+                    document = p.parse(input)
+            except constants.DataLossWarning:
+                pytest.skip("data loss warning")
+
+        output = convertTreeDump(p.tree.testSerializer(document))
+
+        expected = convertExpected(expected)
+        if self.namespaceHTMLElements:
+            expected = namespaceExpected(r"\1<html \2>", expected)
+
+        errorMsg = "\n".join(["\n\nInput:", input, "\nExpected:", expected,
+                              "\nReceived:", output])
+        assert expected == output, errorMsg
+
+        errStr = []
+        for (line, col), errorcode, datavars in p.errors:
+            assert isinstance(datavars, dict), "%s, %s" % (errorcode, repr(datavars))
+            errStr.append("Line: %i Col: %i %s" % (line, col,
+                                                   constants.E[errorcode] % datavars))
+
+        errorMsg2 = "\n".join(["\n\nInput:", input,
+                               "\nExpected errors (" + str(len(expectedErrors)) + "):\n" + "\n".join(expectedErrors),
+                               "\nActual errors (" + str(len(p.errors)) + "):\n" + "\n".join(errStr)])
+        if False:  # we're currently not testing parse errors
+            assert len(p.errors) == len(expectedErrors), errorMsg2
+
+    def repr_failure(self, excinfo):
+        traceback = excinfo.traceback
+        ntraceback = traceback.cut(path=__file__)
+        excinfo.traceback = ntraceback.filter()
+
+        return excinfo.getrepr(funcargs=True,
+                               showlocals=False,
+                               style="short", tbfilter=False)
diff --git a/pytest.ini b/pytest.ini
@@ -1,2 +1,2 @@
 [pytest]
-addopts = -rXw -p no:doctest
+addopts = -rXw -p no:doctest

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`[pytest]`
`2`		`-addopts = -rXw -p no:doctest`
	`2`	`+addopts = -rXw -p no:doctest`