bee_python 0.0.1

data/tools/common/common/pytest.py

@@ -0,0 +1,754 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common 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.
+#
+# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""pytest is a tool that eases test running and debugging.
+
+To be able to use pytest, you should either write tests using
+the logilab.common.testlib's framework or the unittest module of the
+Python's standard library.
+
+You can customize pytest's behaviour by defining a ``pytestconf.py`` file
+somewhere in your test directory. In this file, you can add options or
+change the way tests are run.
+
+To add command line options, you must define a ``update_parser`` function in
+your ``pytestconf.py`` file. The function must accept a single parameter
+that will be the OptionParser's instance to customize.
+
+If you wish to customize the tester, you'll have to define a class named
+``CustomPyTester``. This class should extend the default `PyTester` class
+defined in the pytest module. Take a look at the `PyTester` and `DjangoTester`
+classes for more information about what can be done.
+
+For instance, if you wish to add a custom -l option to specify a loglevel, you
+could define the following ``pytestconf.py`` file ::
+
+    import logging
+    from logilab.common.pytest import PyTester
+
+    def update_parser(parser):
+        parser.add_option('-l', '--loglevel', dest='loglevel', action='store',
+                          choices=('debug', 'info', 'warning', 'error', 'critical'),
+                          default='critical', help="the default log level possible choices are "
+                          "('debug', 'info', 'warning', 'error', 'critical')")
+        return parser
+
+
+    class CustomPyTester(PyTester):
+        def __init__(self, cvg, options):
+            super(CustomPyTester, self).__init__(cvg, options)
+            loglevel = options.loglevel.upper()
+            logger = logging.getLogger('erudi')
+            logger.setLevel(logging.getLevelName(loglevel))
+
+
+In your TestCase class you can then get the value of a specific option with
+the ``optval`` method::
+
+    class MyTestCase(TestCase):
+        def test_foo(self):
+            loglevel = self.optval('loglevel')
+            # ...
+
+
+You can also tag your tag your test for fine filtering
+
+With those tag::
+
+    from logilab.common.testlib import tag, TestCase
+
+    class Exemple(TestCase):
+
+        @tag('rouge', 'carre')
+        def toto(self):
+            pass
+
+        @tag('carre', 'vert')
+        def tata(self):
+            pass
+
+        @tag('rouge')
+        def titi(test):
+            pass
+
+you can filter the function with a simple python expression
+
+ * ``toto`` and ``titi`` match ``rouge``
+
+ * ``toto``, ``tata`` and ``titi``, match ``rouge or carre``
+
+ * ``tata`` and ``titi`` match``rouge ^ carre``
+
+ * ``titi`` match ``rouge and not carre``
+"""
+__docformat__ = "restructuredtext en"
+
+PYTEST_DOC = """%prog [OPTIONS] [testfile [testpattern]]
+
+examples:
+
+pytest path/to/mytests.py
+pytest path/to/mytests.py TheseTests
+pytest path/to/mytests.py TheseTests.test_thisone
+pytest path/to/mytests.py -m '(not long and database) or regr'
+
+pytest one (will run both test_thisone and test_thatone)
+pytest path/to/mytests.py -s not (will skip test_notthisone)
+
+pytest --coverage test_foo.py
+  (only if logilab.devtools is available)
+"""
+
+import os, sys, re
+import os.path as osp
+from time import time, clock
+import warnings
+
+from logilab.common.fileutils import abspath_listdir
+from logilab.common import testlib
+import doctest
+import unittest
+
+
+import imp
+
+import __builtin__
+
+
+try:
+    import django
+    from logilab.common.modutils import modpath_from_file, load_module_from_modpath
+    DJANGO_FOUND = True
+except ImportError:
+    DJANGO_FOUND = False
+
+CONF_FILE = 'pytestconf.py'
+
+## coverage hacks, do not read this, do not read this, do not read this
+
+# hey, but this is an aspect, right ?!!!
+class TraceController(object):
+    nesting = 0
+
+    def pause_tracing(cls):
+        if not cls.nesting:
+            cls.tracefunc = staticmethod(getattr(sys, '__settrace__', sys.settrace))
+            cls.oldtracer = getattr(sys, '__tracer__', None)
+            sys.__notrace__ = True
+            cls.tracefunc(None)
+        cls.nesting += 1
+    pause_tracing = classmethod(pause_tracing)
+
+    def resume_tracing(cls):
+        cls.nesting -= 1
+        assert cls.nesting >= 0
+        if not cls.nesting:
+            cls.tracefunc(cls.oldtracer)
+            delattr(sys, '__notrace__')
+    resume_tracing = classmethod(resume_tracing)
+
+
+pause_tracing = TraceController.pause_tracing
+resume_tracing = TraceController.resume_tracing
+
+
+def nocoverage(func):
+    if hasattr(func, 'uncovered'):
+        return func
+    func.uncovered = True
+    def not_covered(*args, **kwargs):
+        pause_tracing()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            resume_tracing()
+    not_covered.uncovered = True
+    return not_covered
+
+
+## end of coverage hacks
+
+
+# monkeypatch unittest and doctest (ouch !)
+unittest.TestCase = testlib.TestCase
+unittest.main = testlib.unittest_main
+unittest._TextTestResult = testlib.SkipAwareTestResult
+unittest.TextTestRunner = testlib.SkipAwareTextTestRunner
+unittest.TestLoader = testlib.NonStrictTestLoader
+unittest.TestProgram = testlib.SkipAwareTestProgram
+if sys.version_info >= (2, 4):
+    doctest.DocTestCase.__bases__ = (testlib.TestCase,)
+else:
+    unittest.FunctionTestCase.__bases__ = (testlib.TestCase,)
+
+
+
+TESTFILE_RE = re.compile("^((unit)?test.*|smoketest)\.py$")
+def this_is_a_testfile(filename):
+    """returns True if `filename` seems to be a test file"""
+    return TESTFILE_RE.match(osp.basename(filename))
+
+TESTDIR_RE = re.compile("^(unit)?tests?$")
+def this_is_a_testdir(dirpath):
+    """returns True if `filename` seems to be a test directory"""
+    return TESTDIR_RE.match(osp.basename(dirpath))
+
+
+def load_pytest_conf(path, parser):
+    """loads a ``pytestconf.py`` file and update default parser
+    and / or tester.
+    """
+    namespace = {}
+    execfile(path, namespace)
+    if 'update_parser' in namespace:
+        namespace['update_parser'](parser)
+    return namespace.get('CustomPyTester', PyTester)
+
+
+def project_root(parser, projdir=os.getcwd()):
+    """try to find project's root and add it to sys.path"""
+    curdir = osp.abspath(projdir)
+    previousdir = curdir
+    testercls = PyTester
+    conf_file_path = osp.join(curdir, CONF_FILE)
+    if osp.isfile(conf_file_path):
+        testercls = load_pytest_conf(conf_file_path, parser)
+    while this_is_a_testdir(curdir) or \
+              osp.isfile(osp.join(curdir, '__init__.py')):
+        newdir = osp.normpath(osp.join(curdir, os.pardir))
+        if newdir == curdir:
+            break
+        previousdir = curdir
+        curdir = newdir
+        conf_file_path = osp.join(curdir, CONF_FILE)
+        if osp.isfile(conf_file_path):
+            testercls = load_pytest_conf(conf_file_path, parser)
+    return previousdir, testercls
+
+
+class GlobalTestReport(object):
+    """this class holds global test statistics"""
+    def __init__(self):
+        self.ran = 0
+        self.skipped = 0
+        self.failures = 0
+        self.errors = 0
+        self.ttime = 0
+        self.ctime = 0
+        self.modulescount = 0
+        self.errmodules = []
+
+    def feed(self, filename, testresult, ttime, ctime):
+        """integrates new test information into internal statistics"""
+        ran = testresult.testsRun
+        self.ran += ran
+        self.skipped += len(getattr(testresult, 'skipped', ()))
+        self.failures += len(testresult.failures)
+        self.errors += len(testresult.errors)
+        self.ttime += ttime
+        self.ctime += ctime
+        self.modulescount += 1
+        if not testresult.wasSuccessful():
+            problems = len(testresult.failures) + len(testresult.errors)
+            self.errmodules.append((filename[:-3], problems, ran))
+
+
+    def failed_to_test_module(self, filename):
+        """called when the test module could not be imported by unittest
+        """
+        self.errors += 1
+        self.modulescount += 1
+        self.ran += 1
+        self.errmodules.append((filename[:-3], 1, 1))
+
+    def skip_module(self, filename):
+        self.modulescount += 1
+        self.ran += 1
+        self.errmodules.append((filename[:-3], 0, 0))
+
+    def __str__(self):
+        """this is just presentation stuff"""
+        line1 = ['Ran %s test cases in %.2fs (%.2fs CPU)'
+                 % (self.ran, self.ttime, self.ctime)]
+        if self.errors:
+            line1.append('%s errors' % self.errors)
+        if self.failures:
+            line1.append('%s failures' % self.failures)
+        if self.skipped:
+            line1.append('%s skipped' % self.skipped)
+        modulesok = self.modulescount - len(self.errmodules)
+        if self.errors or self.failures:
+            line2 = '%s modules OK (%s failed)' % (modulesok,
+                                                   len(self.errmodules))
+            descr = ', '.join(['%s [%s/%s]' % info for info in self.errmodules])
+            line3 = '\nfailures: %s' % descr
+        elif modulesok:
+            line2 = 'All %s modules OK' % modulesok
+            line3 = ''
+        else:
+            return ''
+        return '%s\n%s%s' % (', '.join(line1), line2, line3)
+
+
+
+def remove_local_modules_from_sys(testdir):
+    """remove all modules from cache that come from `testdir`
+
+    This is used to avoid strange side-effects when using the
+    testall() mode of pytest.
+    For instance, if we run pytest on this tree::
+
+      A/test/test_utils.py
+      B/test/test_utils.py
+
+    we **have** to clean sys.modules to make sure the correct test_utils
+    module is ran in B
+    """
+    for modname, mod in sys.modules.items():
+        if mod is None:
+            continue
+        if not hasattr(mod, '__file__'):
+            # this is the case of some built-in modules like sys, imp, marshal
+            continue
+        modfile = mod.__file__
+        # if modfile is not an absolute path, it was probably loaded locally
+        # during the tests
+        if not osp.isabs(modfile) or modfile.startswith(testdir):
+            del sys.modules[modname]
+
+
+
+class PyTester(object):
+    """encapsulates testrun logic"""
+
+    def __init__(self, cvg, options):
+        self.report = GlobalTestReport()
+        self.cvg = cvg
+        self.options = options
+        self.firstwrite = True
+        self._errcode = None
+
+    def show_report(self):
+        """prints the report and returns appropriate exitcode"""
+        # everything has been ran, print report
+        print "*" * 79
+        print self.report
+
+    def get_errcode(self):
+        # errcode set explicitly
+        if self._errcode is not None:
+            return self._errcode
+        return self.report.failures + self.report.errors
+
+    def set_errcode(self, errcode):
+        self._errcode = errcode
+    errcode = property(get_errcode, set_errcode)
+
+    def testall(self, exitfirst=False):
+        """walks through current working directory, finds something
+        which can be considered as a testdir and runs every test there
+        """
+        here = os.getcwd()
+        for dirname, dirs, _ in os.walk(here):
+            for skipped in ('CVS', '.svn', '.hg'):
+                if skipped in dirs:
+                    dirs.remove(skipped)
+            basename = osp.basename(dirname)
+            if this_is_a_testdir(basename):
+                print "going into", dirname
+                # we found a testdir, let's explore it !
+                if not self.testonedir(dirname, exitfirst):
+                    break
+                dirs[:] = []
+        if self.report.ran == 0:
+            print "no test dir found testing here:", here
+            # if no test was found during the visit, consider
+            # the local directory as a test directory even if
+            # it doesn't have a traditional test directory name
+            self.testonedir(here)
+
+    def testonedir(self, testdir, exitfirst=False):
+        """finds each testfile in the `testdir` and runs it
+
+        return true when all tests has been executed, false if exitfirst and
+        some test has failed.
+        """
+        for filename in abspath_listdir(testdir):
+            if this_is_a_testfile(filename):
+                if self.options.exitfirst and not self.options.restart:
+                    # overwrite restart file
+                    try:
+                        restartfile = open(testlib.FILE_RESTART, "w")
+                        restartfile.close()
+                    except Exception, e:
+                        print >> sys.__stderr__, "Error while overwriting \
+succeeded test file :", osp.join(os.getcwd(),testlib.FILE_RESTART)
+                        raise e
+                # run test and collect information
+                prog = self.testfile(filename, batchmode=True)
+                if exitfirst and (prog is None or not prog.result.wasSuccessful()):
+                    return False
+                self.firstwrite = True
+        # clean local modules
+        remove_local_modules_from_sys(testdir)
+        return True
+
+    def testfile(self, filename, batchmode=False):
+        """runs every test in `filename`
+
+        :param filename: an absolute path pointing to a unittest file
+        """
+        here = os.getcwd()
+        dirname = osp.dirname(filename)
+        if dirname:
+            os.chdir(dirname)
+        # overwrite restart file if it has not been done already
+        if self.options.exitfirst and not self.options.restart and self.firstwrite:
+            try:
+                restartfile = open(testlib.FILE_RESTART, "w")
+                restartfile.close()
+            except Exception, e:
+                print >> sys.__stderr__, "Error while overwriting \
+succeeded test file :", osp.join(os.getcwd(),testlib.FILE_RESTART)
+                raise e
+        modname = osp.basename(filename)[:-3]
+        try:
+            print >> sys.stderr, ('  %s  ' % osp.basename(filename)).center(70, '=')
+        except TypeError: # < py 2.4 bw compat
+            print >> sys.stderr, ('  %s  ' % osp.basename(filename)).center(70)
+        try:
+            tstart, cstart = time(), clock()
+            try:
+                testprog = testlib.unittest_main(modname, batchmode=batchmode, cvg=self.cvg,
+                                                 options=self.options, outstream=sys.stderr)
+            except KeyboardInterrupt:
+                raise
+            except SystemExit, exc:
+                self.errcode = exc.code
+                raise
+            except testlib.TestSkipped:
+                print "Module skipped:", filename
+                self.report.skip_module(filename)
+                return None
+            except Exception:
+                self.report.failed_to_test_module(filename)
+                print >> sys.stderr, 'unhandled exception occurred while testing', modname
+                import traceback
+                traceback.print_exc(file=sys.stderr)
+                return None
+
+            tend, cend = time(), clock()
+            ttime, ctime = (tend - tstart), (cend - cstart)
+            self.report.feed(filename, testprog.result, ttime, ctime)
+            return testprog
+        finally:
+            if dirname:
+                os.chdir(here)
+
+
+
+class DjangoTester(PyTester):
+
+    def load_django_settings(self, dirname):
+        """try to find project's setting and load it"""
+        curdir = osp.abspath(dirname)
+        previousdir = curdir
+        while not osp.isfile(osp.join(curdir, 'settings.py')) and \
+                  osp.isfile(osp.join(curdir, '__init__.py')):
+            newdir = osp.normpath(osp.join(curdir, os.pardir))
+            if newdir == curdir:
+                raise AssertionError('could not find settings.py')
+            previousdir = curdir
+            curdir = newdir
+        # late django initialization
+        settings = load_module_from_modpath(modpath_from_file(osp.join(curdir, 'settings.py')))
+        from django.core.management import setup_environ
+        setup_environ(settings)
+        settings.DEBUG = False
+        self.settings = settings
+        # add settings dir to pythonpath since it's the project's root
+        if curdir not in sys.path:
+            sys.path.insert(1, curdir)
+
+    def before_testfile(self):
+        # Those imports must be done **after** setup_environ was called
+        from django.test.utils import setup_test_environment
+        from django.test.utils import create_test_db
+        setup_test_environment()
+        create_test_db(verbosity=0)
+        self.dbname = self.settings.TEST_DATABASE_NAME
+
+
+    def after_testfile(self):
+        # Those imports must be done **after** setup_environ was called
+        from django.test.utils import teardown_test_environment
+        from django.test.utils import destroy_test_db
+        teardown_test_environment()
+        print 'destroying', self.dbname
+        destroy_test_db(self.dbname, verbosity=0)
+
+
+    def testall(self, exitfirst=False):
+        """walks through current working directory, finds something
+        which can be considered as a testdir and runs every test there
+        """
+        for dirname, dirs, _ in os.walk(os.getcwd()):
+            for skipped in ('CVS', '.svn', '.hg'):
+                if skipped in dirs:
+                    dirs.remove(skipped)
+            if 'tests.py' in files:
+                if not self.testonedir(dirname, exitfirst):
+                    break
+                dirs[:] = []
+            else:
+                basename = osp.basename(dirname)
+                if basename in ('test', 'tests'):
+                    print "going into", dirname
+                    # we found a testdir, let's explore it !
+                    if not self.testonedir(dirname, exitfirst):
+                        break
+                    dirs[:] = []
+
+
+    def testonedir(self, testdir, exitfirst=False):
+        """finds each testfile in the `testdir` and runs it
+
+        return true when all tests has been executed, false if exitfirst and
+        some test has failed.
+        """
+        # special django behaviour : if tests are splitted in several files,
+        # remove the main tests.py file and tests each test file separately
+        testfiles = [fpath for fpath in abspath_listdir(testdir)
+                     if this_is_a_testfile(fpath)]
+        if len(testfiles) > 1:
+            try:
+                testfiles.remove(osp.join(testdir, 'tests.py'))
+            except ValueError:
+                pass
+        for filename in testfiles:
+            # run test and collect information
+            prog = self.testfile(filename, batchmode=True)
+            if exitfirst and (prog is None or not prog.result.wasSuccessful()):
+                return False
+        # clean local modules
+        remove_local_modules_from_sys(testdir)
+        return True
+
+
+    def testfile(self, filename, batchmode=False):
+        """runs every test in `filename`
+
+        :param filename: an absolute path pointing to a unittest file
+        """
+        here = os.getcwd()
+        dirname = osp.dirname(filename)
+        if dirname:
+            os.chdir(dirname)
+        self.load_django_settings(dirname)
+        modname = osp.basename(filename)[:-3]
+        print >>sys.stderr, ('  %s  ' % osp.basename(filename)).center(70, '=')
+        try:
+            try:
+                tstart, cstart = time(), clock()
+                self.before_testfile()
+                testprog = testlib.unittest_main(modname, batchmode=batchmode, cvg=self.cvg)
+                tend, cend = time(), clock()
+                ttime, ctime = (tend - tstart), (cend - cstart)
+                self.report.feed(filename, testprog.result, ttime, ctime)
+                return testprog
+            except SystemExit:
+                raise
+            except Exception, exc:
+                import traceback
+                traceback.print_exc()
+                self.report.failed_to_test_module(filename)
+                print 'unhandled exception occurred while testing', modname
+                print 'error: %s' % exc
+                return None
+        finally:
+            self.after_testfile()
+            if dirname:
+                os.chdir(here)
+
+
+def make_parser():
+    """creates the OptionParser instance
+    """
+    from optparse import OptionParser
+    parser = OptionParser(usage=PYTEST_DOC)
+
+    parser.newargs = []
+    def rebuild_cmdline(option, opt, value, parser):
+        """carry the option to unittest_main"""
+        parser.newargs.append(opt)
+
+    def rebuild_and_store(option, opt, value, parser):
+        """carry the option to unittest_main and store
+        the value on current parser
+        """
+        parser.newargs.append(opt)
+        setattr(parser.values, option.dest, True)
+
+    def capture_and_rebuild(option, opt, value, parser):
+        warnings.simplefilter('ignore', DeprecationWarning)
+        rebuild_cmdline(option, opt, value, parser)
+
+    # pytest options
+    parser.add_option('-t', dest='testdir', default=None,
+                      help="directory where the tests will be found")
+    parser.add_option('-d', dest='dbc', default=False,
+                      action="store_true", help="enable design-by-contract")
+    # unittest_main options provided and passed through pytest
+    parser.add_option('-v', '--verbose', callback=rebuild_cmdline,
+                      action="callback", help="Verbose output")
+    parser.add_option('-i', '--pdb', callback=rebuild_and_store,
+                      dest="pdb", action="callback",
+                      help="Enable test failure inspection (conflicts with --coverage)")
+    parser.add_option('-x', '--exitfirst', callback=rebuild_and_store,
+                      dest="exitfirst", default=False,
+                      action="callback", help="Exit on first failure "
+                      "(only make sense when pytest run one test file)")
+    parser.add_option('-R', '--restart', callback=rebuild_and_store,
+                      dest="restart", default=False,
+                      action="callback",
+                      help="Restart tests from where it failed (implies exitfirst) "
+                        "(only make sense if tests previously ran with exitfirst only)")
+    parser.add_option('-c', '--capture', callback=capture_and_rebuild,
+                      action="callback",
+                      help="Captures and prints standard out/err only on errors "
+                      "(only make sense when pytest run one test file)")
+    parser.add_option('--color', callback=rebuild_cmdline,
+                      action="callback",
+                      help="colorize tracebacks")
+    parser.add_option('-p', '--printonly',
+                      # XXX: I wish I could use the callback action but it
+                      #      doesn't seem to be able to get the value
+                      #      associated to the option
+                      action="store", dest="printonly", default=None,
+                      help="Only prints lines matching specified pattern (implies capture) "
+                      "(only make sense when pytest run one test file)")
+    parser.add_option('-s', '--skip',
+                      # XXX: I wish I could use the callback action but it
+                      #      doesn't seem to be able to get the value
+                      #      associated to the option
+                      action="store", dest="skipped", default=None,
+                      help="test names matching this name will be skipped "
+                      "to skip several patterns, use commas")
+    parser.add_option('-q', '--quiet', callback=rebuild_cmdline,
+                      action="callback", help="Minimal output")
+    parser.add_option('-P', '--profile', default=None, dest='profile',
+                      help="Profile execution and store data in the given file")
+    parser.add_option('-m', '--match', default=None, dest='tags_pattern',
+                      help="only execute test whose tag match the current pattern")
+
+    try:
+        from logilab.devtools.lib.coverage import Coverage
+        parser.add_option('--coverage', dest="coverage", default=False,
+                          action="store_true",
+                          help="run tests with pycoverage (conflicts with --pdb)")
+    except ImportError:
+        pass
+
+    if DJANGO_FOUND:
+        parser.add_option('-J', '--django', dest='django', default=False,
+                          action="store_true",
+                          help='use pytest for django test cases')
+    return parser
+
+
+def parseargs(parser):
+    """Parse the command line and return (options processed), (options to pass to
+    unittest_main()), (explicitfile or None).
+    """
+    # parse the command line
+    options, args = parser.parse_args()
+    if options.pdb and getattr(options, 'coverage', False):
+        parser.error("'pdb' and 'coverage' options are exclusive")
+    filenames = [arg for arg in args if arg.endswith('.py')]
+    if filenames:
+        if len(filenames) > 1:
+            parser.error("only one filename is acceptable")
+        explicitfile = filenames[0]
+        args.remove(explicitfile)
+    else:
+        explicitfile = None
+    # someone wants DBC
+    testlib.ENABLE_DBC = options.dbc
+    newargs = parser.newargs
+    if options.printonly:
+        newargs.extend(['--printonly', options.printonly])
+    if options.skipped:
+        newargs.extend(['--skip', options.skipped])
+    # restart implies exitfirst
+    if options.restart:
+        options.exitfirst = True
+    # append additional args to the new sys.argv and let unittest_main
+    # do the rest
+    newargs += args
+    return options, explicitfile
+
+
+
+def run():
+    parser = make_parser()
+    rootdir, testercls = project_root(parser)
+    options, explicitfile = parseargs(parser)
+    # mock a new command line
+    sys.argv[1:] = parser.newargs
+    covermode = getattr(options, 'coverage', None)
+    cvg = None
+    if not '' in sys.path:
+        sys.path.insert(0, '')
+    if covermode:
+        # control_import_coverage(rootdir)
+        from logilab.devtools.lib.coverage import Coverage
+        cvg = Coverage([rootdir])
+        cvg.erase()
+        cvg.start()
+    if DJANGO_FOUND and options.django:
+        tester = DjangoTester(cvg, options)
+    else:
+        tester = testercls(cvg, options)
+    if explicitfile:
+        cmd, args = tester.testfile, (explicitfile,)
+    elif options.testdir:
+        cmd, args = tester.testonedir, (options.testdir, options.exitfirst)
+    else:
+        cmd, args = tester.testall, (options.exitfirst,)
+    try:
+        try:
+            if options.profile:
+                import hotshot
+                prof = hotshot.Profile(options.profile)
+                prof.runcall(cmd, *args)
+                prof.close()
+                print 'profile data saved in', options.profile
+            else:
+                cmd(*args)
+        except SystemExit:
+            raise
+        except:
+            import traceback
+            traceback.print_exc()
+    finally:
+        if covermode:
+            cvg.stop()
+            cvg.save()
+        tester.show_report()
+        if covermode:
+            print 'coverage information stored, use it with pycoverage -ra'
+        sys.exit(tester.errcode)