Revert "Revert "pylint: upgrade to 1.3.1""

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 74 matching lines @@
         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``
 """
+
+from __future__ import print_function
+
 __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)
 """
 
 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 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.compat import any
 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
@@ skipping 61 matching lines @@
 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)
+    exec(open(path, 'rb').read(), 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"""
     previousdir = curdir = osp.abspath(projdir)
     testercls = PyTester
     conf_file_path = osp.join(curdir, CONF_FILE)
@@ skipping 82 matching lines @@
     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():
+    for modname, mod in list(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
+        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 STD_BLACKLIST:
                 if skipped in dirs:
                     dirs.remove(skipped)
             basename = osp.basename(dirname)
             if this_is_a_testdir(basename):
-                print "going into", dirname
+                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
+            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(FILE_RESTART, "w")
                         restartfile.close()
-                    except Exception, e:
-                        print >> sys.__stderr__, "Error while overwriting \
-succeeded test file :", osp.join(os.getcwd(), FILE_RESTART)
-                        raise e
+                    except Exception:
+                        print("Error while overwriting succeeded test file :",
+                              osp.join(os.getcwd(), FILE_RESTART),
+                              file=sys.__stderr__)
+                        raise
                 # 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(FILE_RESTART, "w")
                 restartfile.close()
-            except Exception, e:
-                print >> sys.__stderr__, "Error while overwriting \
-succeeded test file :", osp.join(os.getcwd(), FILE_RESTART)
-                raise e
+            except Exception:
+                print("Error while overwriting succeeded test file :",
+                      osp.join(os.getcwd(), FILE_RESTART), file=sys.__stderr__)
+                raise
         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)
+        print(('  %s  ' % osp.basename(filename)).center(70, '='),
+              file=sys.__stderr__)
         try:
             tstart, cstart = time(), clock()
             try:
                 testprog = SkipAwareTestProgram(modname, batchmode=batchmode, cvg=self.cvg,
                                                  options=self.options, outstream=sys.stderr)
             except KeyboardInterrupt:
                 raise
-            except SystemExit, exc:
+            except SystemExit as exc:
                 self.errcode = exc.code
                 raise
             except testlib.SkipTest:
-                print "Module skipped:", filename
+                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
+                print('unhandled exception occurred while testing', modname,
+                      file=sys.stderr)
                 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:
@@ skipping 30 matching lines @@
         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
+        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, files 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
+                    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.
@@ skipping 20 matching lines @@
         """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, '=')
+        print(('  %s  ' % osp.basename(filename)).center(70, '='),
+              file=sys.stderr)
         try:
             try:
                 tstart, cstart = time(), clock()
                 self.before_testfile()
                 testprog = SkipAwareTestProgram(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:
+            except Exception as exc:
                 import traceback
                 traceback.print_exc()
                 self.report.failed_to_test_module(filename)
-                print 'unhandled exception occurred while testing', modname
-                print 'error: %s' % exc
+                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
     """
@@ skipping 19 matching lines @@
     # 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)")
+                      help="Enable test failure inspection")
     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('--color', callback=rebuild_cmdline,
                       action="callback",
                       help="colorize tracebacks")
     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.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
+                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)
 
 class SkipAwareTestProgram(unittest.TestProgram):
     # XXX: don't try to stay close to unittest.py, use optparse
     USAGE = """\
 Usage: %(progName)s [options] [test] [...]
 
 Options:
   -h, --help       Show this message
   -v, --verbose    Verbose output
@@ skipping 71 matching lines @@
                     self.test = self.module.suite()
                 else:
                     self.test = self.testLoader.loadTestsFromModule(self.module)
                 return
             if len(args) > 0:
                 self.test_pattern = args[0]
                 self.testNames = args
             else:
                 self.testNames = (self.defaultTest, )
             self.createTests()
-        except getopt.error, msg:
+        except getopt.error as msg:
             self.usageExit(msg)
 
     def runTests(self):
         if self.profile_name:
             import cProfile
             cProfile.runctx('self._runTests()', globals(), locals(), self.profile_name )
         else:
             return self._runTests()
 
     def _runTests(self):
@@ skipping 28 matching lines @@
         if getattr(self.options, 'restart', False):
             # retrieve succeeded tests from FILE_RESTART
             try:
                 restartfile = open(FILE_RESTART, 'r')
                 try:
                     succeededtests = list(elem.rstrip('\n\r') for elem in
                                           restartfile.readlines())
                     removeSucceededTests(self.test, succeededtests)
                 finally:
                     restartfile.close()
-            except Exception, ex:
+            except Exception as ex:
                 raise Exception("Error while reading succeeded tests into %s: %s"
                                 % (osp.join(os.getcwd(), FILE_RESTART), ex))
 
         result = self.testRunner.run(self.test)
         # help garbage collection: we want TestSuite, which hold refs to every
         # executed TestCase, to be gc'ed
         del self.test
         if getattr(result, "debuggers", None) and \
            getattr(self, "pdbmode", None):
             start_interactive_mode(result)
@@ skipping 21 matching lines @@
 
     def _this_is_skipped(self, testedname):
         return any([(pat in testedname) for pat in self.skipped_patterns])
 
     def _runcondition(self, test, skipgenerator=True):
         if isinstance(test, testlib.InnerTest):
             testname = test.name
         else:
             if isinstance(test, testlib.TestCase):
                 meth = test._get_test_method()
-                func = meth.im_func
-                testname = '%s.%s' % (meth.im_class.__name__, func.__name__)
+                testname = '%s.%s' % (test.__name__, meth.__name__)
             elif isinstance(test, types.FunctionType):
                 func = test
                 testname = func.__name__
             elif isinstance(test, types.MethodType):
-                func = test.im_func
-                testname = '%s.%s' % (test.im_class.__name__, func.__name__)
+                cls = test.__self__.__class__
+                testname = '%s.%s' % (cls.__name__, test.__name__)
             else:
                 return True # Not sure when this happens
-            if testlib.is_generator(test) and skipgenerator:
+            if isgeneratorfunction(test) and skipgenerator:
                 return self.does_match_tags(test) # Let inner tests decide at run time
         if self._this_is_skipped(testname):
             return False # this was explicitly skipped
         if self.test_pattern is not None:
             try:
                 classpattern, testpattern = self.test_pattern.split('.')
                 klass, name = testname.split('.')
                 if classpattern not in klass or testpattern not in name:
                     return False
             except ValueError:
@@ skipping 87 matching lines @@
     # and to provide callable capability
     def loadTestsFromNames(self, names, module=None):
         suites = []
         for name in names:
             suites.extend(self.loadTestsFromName(name, module))
         return self.suiteClass(suites)
 
     def _collect_tests(self, module):
         tests = {}
         for obj in vars(module).values():
-            if (issubclass(type(obj), (types.ClassType, type)) and
-                 issubclass(obj, unittest.TestCase)):
+            if isclass(obj) and issubclass(obj, unittest.TestCase):
                 classname = obj.__name__
                 if classname[0] == '_' or self._this_is_skipped(classname):
                     continue
                 methodnames = []
                 # obj is a TestCase class
                 for attrname in dir(obj):
                     if attrname.startswith(self.testMethodPrefix):
                         attr = getattr(obj, attrname)
                         if callable(attr):
                             methodnames.append(attrname)
@@ skipping 128 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