Merge lp:~jamesh/storm/bug-331905-test-runner into lp:storm

[James Henstridge]

[James Henstridge (jamesh)]

Clean up the test harness a bit.

* Remove support for running the tests under py.test, as it appears to have broken a while back with no one noticing.
* Collect tests in the same way for both the pyunit and trial test runners. This should also allow Trial to handle the doctests.

[Jamu Kakar (jkakar)]

Thanks for this, +1!

review: Approve

[Thomas Herve (therve)]

One flake: test:25: 'new' imported but unused.

+1!

review: Approve

[lp:~jamesh/storm/bug-331905-test-runner]

331. By James Henstridge on 2009-11-09

Remove unneeded import of "new" module.

=== modified file 'test'
--- test	2009-03-05 21:53:12 +0000
+++ test	2009-11-09 03:29:09 +0000
@@ -22,7 +22,6 @@
 import optparse
 import unittest
 import doctest
-import new
 import sys
 import os
 
@@ -35,14 +34,12 @@
     @param testpaths: If provided, only tests in the given sequence will
                       be considered.  If not provided, all tests are
                       considered.
-    @return: (unittests, doctests) tuple, with lists of unittests and
-             doctests found, respectively.
+    @return: a test suite containing the requested tests.
     """
+    suite = unittest.TestSuite()
     topdir = os.path.abspath(os.path.dirname(__file__))
     testdir = os.path.dirname(tests.__file__)
     testpaths = set(testpaths)
-    unittests = []
-    doctests = []
     for root, dirnames, filenames in os.walk(testdir):
         for filename in filenames:
             filepath = os.path.join(root, filename)
@@ -62,17 +59,28 @@
                     continue
 
             if filename.endswith(".py"):
-                unittests.append(relpath)
-            elif relpath == os.path.join("tests", "zope", "README.txt"):
-                # Special case the inclusion of the Zope-dependent
-                # ZStorm doctest.
-                from tests.zope import has_zope
-                if has_zope:
-                    doctests.append(relpath)
+                modpath = relpath.replace(os.path.sep, ".")[:-3]
+                module = __import__(modpath, None, None, [""])
+                suite.addTest(
+                    unittest.defaultTestLoader.loadTestsFromModule(module))
             elif filename.endswith(".txt"):
-                doctests.append(relpath)
+                load_test = True
+                if relpath == os.path.join("tests", "zope", "README.txt"):
+                    # Special case the inclusion of the Zope-dependent
+                    # ZStorm doctest.
+                    from tests.zope import has_zope
+                    load_test = has_zope
+                if load_test:
+                    parent_path = os.path.dirname(relpath).replace(
+                        os.path.sep, ".")
+                    parent_module = __import__(parent_path, None, None, [""])
+                    suite.addTest(doctest.DocFileSuite(
+                            os.path.basename(relpath),
+                            module_relative=True,
+                            package=parent_module,
+                            optionflags=doctest.ELLIPSIS))
 
-    return unittests, doctests
+    return suite
 
 
 def parse_sys_argv():
@@ -85,27 +93,7 @@
             del sys.argv[i]
     return testpaths
 
-
-def test_with_trial():
-    from twisted.scripts import trial
-    unittests, doctests = find_tests(parse_sys_argv())
-    sys.argv.extend(unittests)
-    trial.run()
-
-
-def test_with_py_test():
-    import py
-    dirname = os.path.dirname(__file__)
-    unittests, doctests = find_tests(parse_sys_argv())
-    sys.argv.extend(unittests)
-    sys.argv.extend(doctests)
-    # For timestamp checking when looping:
-    sys.argv.append(os.path.join(os.path.dirname(__file__), "storm/"))
-    py.test.cmdline.main()
-
-
-def test_with_unittest():
-
+def test_with_runner(runner):
     usage = "test.py [options] [<test filename>, ...]"
 
     parser = optparse.OptionParser(usage=usage)
@@ -113,66 +101,25 @@
     parser.add_option('--verbose', action='store_true')
     opts, args = parser.parse_args()
 
-    runner = unittest.TextTestRunner()
-
     if opts.verbose:
         runner.verbosity = 2
 
-    loader = unittest.TestLoader()
-
-    unittests, doctests = find_tests(args)
-
-    class Summary:
-        def __init__(self):
-            self.total_failures = 0
-            self.total_errors = 0
-            self.total_tests = 0
-        def __call__(self, tests, failures, errors):
-            self.total_tests += tests
-            self.total_failures += failures
-            self.total_errors += errors
-            sys.stderr.write("(tests=%d, failures=%d, errors=%d)\n" %
-                             (tests, failures, errors))
-
-    unittest_summary = Summary()
-    doctest_summary = Summary()
-
-    if unittests:
-        sys.stderr.write("Running unittests...\n")
-        for relpath in unittests:
-            sys.stderr.write("[%s]\n" % relpath)
-            modpath = relpath.replace(os.path.sep, '.')[:-3]
-            module = __import__(modpath, None, None, [""])
-            test = loader.loadTestsFromModule(module)
-            result = runner.run(test)
-            unittest_summary(test.countTestCases(),
-                             len(result.failures), len(result.errors))
-            sys.stderr.write("\n")
-
-    if doctests:
-        sys.stderr.write("Running doctests...\n")
-        doctest_flags = doctest.ELLIPSIS
-        for relpath in doctests:
-            sys.stderr.write("[%s]\n" % relpath)
-            failures, total = doctest.testfile(relpath,
-                                               optionflags=doctest_flags)
-            doctest_summary(total, failures, 0)
-            sys.stderr.write("\n")
-
-    sys.stderr.write("Total test cases: %d\n" % unittest_summary.total_tests)
-    sys.stderr.write("Total doctests: %d\n" % doctest_summary.total_tests)
-    sys.stderr.write("Total failures: %d\n" %
-                     (unittest_summary.total_failures +
-                      doctest_summary.total_failures))
-    sys.stderr.write("Total errors: %d\n" % (unittest_summary.total_errors +
-                                             doctest_summary.total_errors))
-
-    failed = bool(unittest_summary.total_failures or
-                  unittest_summary.total_errors or
-                  doctest_summary.total_failures or
-                  doctest_summary.total_errors)
-
-    sys.exit(failed)
+    suite = find_tests(args)
+    result = runner.run(suite)
+    return not result.wasSuccessful()
+
+
+def test_with_trial():
+    from twisted.trial.reporter import TreeReporter
+    from twisted.trial.runner import TrialRunner
+    runner = TrialRunner(reporterFactory=TreeReporter, realTimeErrors=True)
+    return test_with_runner(runner)
+
+
+def test_with_unittest():
+    runner = unittest.TextTestRunner()
+    return test_with_runner(runner)
+
 
 if __name__ == "__main__":
     runner = os.environ.get("STORM_TEST_RUNNER")
@@ -181,6 +128,6 @@
     runner_func = globals().get("test_with_%s" % runner.replace(".", "_"))
     if not runner_func:
         sys.exit("Test runner not found: %s" % runner)
-    runner_func()
+    sys.exit(runner_func())
 
 # vim:ts=4:sw=4:et

=== removed file 'tests/conftest.py'
--- tests/conftest.py	2007-07-06 16:37:49 +0000
+++ tests/conftest.py	1970-01-01 00:00:00 +0000
@@ -1,133 +0,0 @@
-#
-# Copyright (c) 2006, 2007 Canonical
-#
-# Written by Gustavo Niemeyer <[e-mail]>
-#
-# This file is part of Storm Object Relational Mapper.
-#
-# Storm is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation; either version 2.1 of
-# the License, or (at your option) any later version.
-#
-# Storm is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-"""
-Machinery to make py.test interpret standard unittest.TestCase classes.
-"""
-from unittest import TestCase, TestResult
-import doctest
-import sys
-
-import py.test.collect
-import py.test.compat
-import py.test
-
-
-class PyTestResult(TestResult):
-    def addFailure(self, test, exc_info):
-        traceback = exc_info[2]
-        while traceback.tb_next:
-            traceback = traceback.tb_next
-        locals = traceback.tb_frame.f_locals
-        if "msg" in locals or "excClass" in locals:
-            locals["__tracebackhide__"] = True
-        msg = str(exc_info[1])
-        if not msg:
-            if "expr" in locals and "msg" in locals:
-                msg = repr(locals["expr"])
-            else:
-                msg = "!?"
-        raise py.test.Item.Failed, py.test.Item.Failed(msg=msg), exc_info[2]
-    addError = addFailure
-
-class PyTestCase(TestCase):
-    def __init__(self, methodName="setUp"):
-        super(PyTestCase, self).__init__(methodName)
-
-    class Function(py.test.Function):
-        def execute(self, target, *args):
-            __tracebackhide__ = True
-            self = target.im_self
-            self.__init__(target.__name__)
-            self.run(PyTestResult())
-
-class PyDocTest(py.test.collect.Module):
-    def __init__(self, fspath, parent=None):
-        super(PyDocTest, self).__init__(fspath.basename, parent)
-        self.fspath = fspath
-        self._obj = None
-
-    def run(self):
-        return [self.name]
-
-    def join(self, name):
-        return self.Function(name, parent=self, obj=self.fspath)
-
-    class Function(py.test.Function):
-        def getpathlineno(self):
-            code = py.code.Code(self.failed)
-            return code.path, code.firstlineno
-
-        def failed(self, msg):
-            raise self.Failed(msg)
-
-        def execute(self, fspath):
-            failures, total = doctest.testfile(str(fspath),
-                                               module_relative=False,
-                                               optionflags=doctest.ELLIPSIS)
-            if failures:
-                __tracebackhide__ = True
-                self.failed("%d doctest cases" % failures)
-
-class UnitTestModule(py.test.collect.Module):
-    def buildname2items(self):
-        d = {}
-        for name in dir(self.obj):
-            testclass = None
-            obj = getattr(self.obj, name)
-
-            try:
-                if issubclass(obj, (TestCase, PyTestCase)):
-                    testclass = obj
-            except TypeError:
-                pass
-
-            if testclass:
-                d[name] = self.Class(name, parent=self)
-                if not issubclass(testclass, PyTestCase):
-                    queue = [testclass]
-                    while queue:
-                        testclass = queue.pop(0)
-                        if TestCase in testclass.__bases__:
-                            bases = list(testclass.__bases__)
-                            bases[bases.index(TestCase)] = PyTestCase
-                            testclass.__bases__ = tuple(bases)
-                            break
-                        queue.extend(testclass.__bases__)
-        return d
-
-class UnitTestDirectory(py.test.collect.Directory):
-    def __init__(self, *args, **kwargs):
-        if getattr(self.__class__, "__first_run__", True):
-            self.__class__.__first_run__ = False
-        super(UnitTestDirectory, self).__init__(*args, **kwargs)
-
-    def filefilter(self, path):
-        return path.check(fnmatch="*.py") and path.basename != "conftest.py"
-
-    def makeitem(self, basename, filefilter=None, recfilter=None):
-        path = self.fspath.join(basename)
-        if path.check(fnmatch="*.txt"):
-            return PyDocTest(path, parent=self)
-        return super(UnitTestDirectory, self).makeitem(basename,
-                                                       filefilter, recfilter)
-
-Module = UnitTestModule
-Directory = UnitTestDirectory

=== modified file 'tests/helper.py'
--- tests/helper.py	2008-10-02 15:47:18 +0000
+++ tests/helper.py	2009-11-09 03:29:09 +0000
@@ -67,6 +67,9 @@
                 break
         is_supported = getattr(self, "is_supported", None)
         if is_supported is not None and not is_supported():
+            if hasattr(result, "addSkip"):
+                result.startTest(self)
+                result.addSkip(self, "Test not supported")
             return
         unittest.TestCase.run(self, result)