pylint: upgrade to 1.4.0

third_party/logilab/common/pytest.py

 # copyright 2003-2011 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.
 #
@@ skipping 101 matching lines @@
 
 ENABLE_DBC = False
 FILE_RESTART = ".pytest.restart"
 
 import os, sys, re
 import os.path as osp
 from time import time, clock
 import warnings
 import types
 from inspect import isgeneratorfunction, isclass
+from contextlib import contextmanager
 
 from logilab.common.fileutils import abspath_listdir
 from logilab.common import textutils
 from logilab.common import testlib, STD_BLACKLIST
 # use the same unittest module as testlib
 from logilab.common.testlib import unittest, start_interactive_mode
+from logilab.common.deprecation import deprecated
 import doctest
 
 import unittest as unittest_legacy
 if not getattr(unittest_legacy, "__package__", None):
     try:
         import unittest2.suite as unittest_suite
     except ImportError:
         sys.exit("You have to install python-unittest2 to use this module")
 else:
     import unittest.suite as unittest_suite
 
 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
+## coverage pausing tools
 
-# hey, but this is an aspect, right ?!!!
+@contextmanager
+def replace_trace(trace=None):
+    """A context manager that temporary replaces the trace function"""
+    oldtrace = sys.gettrace()
+    sys.settrace(trace)
+    try:
+        yield
+    finally:
+        # specific hack to work around a bug in pycoverage, see
+        # https://bitbucket.org/ned/coveragepy/issue/123
+        if (oldtrace is not None and not callable(oldtrace) and
+            hasattr(oldtrace, 'pytrace')):
+            oldtrace = oldtrace.pytrace
+        sys.settrace(oldtrace)
+
+
+def pause_trace():
+    """A context manager that temporary pauses any tracing"""
+    return replace_trace()
+
 class TraceController(object):
-    nesting = 0
+    ctx_stack = []
 
+    @classmethod
+    @deprecated('[lgc 0.63.1] Use the pause_trace() context manager')
     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)
+        cls.ctx_stack.append(pause_trace())
+        cls.ctx_stack[-1].__enter__()
 
+    @classmethod
+    @deprecated('[lgc 0.63.1] Use the pause_trace() context manager')
     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)
+        cls.ctx_stack.pop().__exit__(None, None, None)
 
 
 pause_tracing = TraceController.pause_tracing
 resume_tracing = TraceController.resume_tracing
 
 
 def nocoverage(func):
+    """Function decorator that pauses tracing functions"""
     if hasattr(func, 'uncovered'):
         return func
     func.uncovered = True
+
     def not_covered(*args, **kwargs):
-        pause_tracing()
-        try:
+        with pause_trace():
             return func(*args, **kwargs)
-        finally:
-            resume_tracing()
     not_covered.uncovered = True
     return not_covered
 
-
-## end of coverage hacks
+## end of coverage pausing tools
 
 
 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"""
@@ skipping 874 matching lines @@
         """Return a sorted sequence of method names found within testCaseClass
         """
         is_skipped = self._this_is_skipped
         classname = testCaseClass.__name__
         if classname[0] == '_' or is_skipped(classname):
             return []
         testnames = super(NonStrictTestLoader, self).getTestCaseNames(
                 testCaseClass)
         return [testname for testname in testnames if not is_skipped(testname)]
 
+
+# The 2 functions below are modified versions of the TestSuite.run method
+# that is provided with unittest2 for python 2.6, in unittest2/suite.py
+# It is used to monkeypatch the original implementation to support
+# extra runcondition and options arguments (see in testlib.py)
+
 def _ts_run(self, result, runcondition=None, options=None):
-    self._wrapped_run(result,runcondition=runcondition, options=options)
+    self._wrapped_run(result, runcondition=runcondition, options=options)
     self._tearDownPreviousClass(None, result)
     self._handleModuleTearDown(result)
     return result
 
 def _ts_wrapped_run(self, result, debug=False, runcondition=None, options=None):
     for test in self:
         if result.shouldStop:
             break
         if unittest_suite._isnotsuite(test):
             self._tearDownPreviousClass(test, result)
             self._handleModuleFixture(test, result)
             self._handleClassSetUp(test, result)
             result._previousTestClass = test.__class__
-            if (getattr(test.__class__, '_classSetupFailed', False) or 
+            if (getattr(test.__class__, '_classSetupFailed', False) or
                 getattr(result, '_moduleSetUpFailed', False)):
                 continue
 
+        # --- modifications to deal with _wrapped_run ---
+        # original code is:
+        #
+        # if not debug:
+        #     test(result)
+        # else:
+        #     test.debug()
         if hasattr(test, '_wrapped_run'):
             try:
                 test._wrapped_run(result, debug, runcondition=runcondition, options=options)
             except TypeError:
                 test._wrapped_run(result, debug)
         elif not debug:
             try:
                 test(result, runcondition, options)
             except TypeError:
                 test(result)
         else:
             test.debug()
+        # --- end of modifications to deal with _wrapped_run ---
+    return result
+
+if sys.version_info >= (2, 7):
+    # The function below implements a modified version of the
+    # TestSuite.run method that is provided with python 2.7, in
+    # unittest/suite.py
+    def _ts_run(self, result, debug=False, runcondition=None, options=None):
+        topLevel = False
+        if getattr(result, '_testRunEntered', False) is False:
+            result._testRunEntered = topLevel = True
+
+        self._wrapped_run(result, debug, runcondition, options)
+
+        if topLevel:
+            self._tearDownPreviousClass(None, result)
+            self._handleModuleTearDown(result)
+            result._testRunEntered = False
+        return result
 
 
 def enable_dbc(*args):
     """
     Without arguments, return True if contracts can be enabled and should be
     enabled (see option -d), return False otherwise.
 
     With arguments, return False if contracts can't or shouldn't be enabled,
     otherwise weave ContractAspect with items passed as arguments.
     """
@@ skipping 19 matching lines @@
 
 if sys.version_info >= (2, 4):
     doctest.DocTestCase.__bases__ = (testlib.TestCase,)
     # XXX check python2.6 compatibility
     #doctest.DocTestCase._cleanups = []
     #doctest.DocTestCase._out = []
 else:
     unittest.FunctionTestCase.__bases__ = (testlib.TestCase,)
 unittest.TestSuite.run = _ts_run
 unittest.TestSuite._wrapped_run = _ts_wrapped_run