home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Bureautique / OpenOffice / Apache_OpenOffice_4.1.1_Win_x86_install_fr.exe / openoffice1.cab / suite.py < prev    next >
Text File  |  2014-07-29  |  10KB  |  304 lines
  1. """TestSuite"""
  2.  
  3. import sys
  4.  
  5. from . import case
  6. from . import util
  7.  
  8. __unittest = True
  9.  
  10.  
  11. def _call_if_exists(parent, attr):
  12.     func = getattr(parent, attr, lambda: None)
  13.     func()
  14.  
  15.  
  16. class BaseTestSuite(object):
  17.     """A simple test suite that doesn't provide class or module shared fixtures.
  18.     """
  19.     def __init__(self, tests=()):
  20.         self._tests = []
  21.         self.addTests(tests)
  22.  
  23.     def __repr__(self):
  24.         return "<%s tests=%s>" % (util.strclass(self.__class__), list(self))
  25.  
  26.     def __eq__(self, other):
  27.         if not isinstance(other, self.__class__):
  28.             return NotImplemented
  29.         return list(self) == list(other)
  30.  
  31.     def __ne__(self, other):
  32.         return not self == other
  33.  
  34.     # Can't guarantee hash invariant, so flag as unhashable
  35.     __hash__ = None
  36.  
  37.     def __iter__(self):
  38.         return iter(self._tests)
  39.  
  40.     def countTestCases(self):
  41.         cases = 0
  42.         for test in self:
  43.             cases += test.countTestCases()
  44.         return cases
  45.  
  46.     def addTest(self, test):
  47.         # sanity checks
  48.         if not hasattr(test, '__call__'):
  49.             raise TypeError("{} is not callable".format(repr(test)))
  50.         if isinstance(test, type) and issubclass(test,
  51.                                                  (case.TestCase, TestSuite)):
  52.             raise TypeError("TestCases and TestSuites must be instantiated "
  53.                             "before passing them to addTest()")
  54.         self._tests.append(test)
  55.  
  56.     def addTests(self, tests):
  57.         if isinstance(tests, basestring):
  58.             raise TypeError("tests must be an iterable of tests, not a string")
  59.         for test in tests:
  60.             self.addTest(test)
  61.  
  62.     def run(self, result):
  63.         for test in self:
  64.             if result.shouldStop:
  65.                 break
  66.             test(result)
  67.         return result
  68.  
  69.     def __call__(self, *args, **kwds):
  70.         return self.run(*args, **kwds)
  71.  
  72.     def debug(self):
  73.         """Run the tests without collecting errors in a TestResult"""
  74.         for test in self:
  75.             test.debug()
  76.  
  77.  
  78. class TestSuite(BaseTestSuite):
  79.     """A test suite is a composite test consisting of a number of TestCases.
  80.  
  81.     For use, create an instance of TestSuite, then add test case instances.
  82.     When all tests have been added, the suite can be passed to a test
  83.     runner, such as TextTestRunner. It will run the individual test cases
  84.     in the order in which they were added, aggregating the results. When
  85.     subclassing, do not forget to call the base class constructor.
  86.     """
  87.  
  88.     def run(self, result, debug=False):
  89.         topLevel = False
  90.         if getattr(result, '_testRunEntered', False) is False:
  91.             result._testRunEntered = topLevel = True
  92.  
  93.         for test in self:
  94.             if result.shouldStop:
  95.                 break
  96.  
  97.             if _isnotsuite(test):
  98.                 self._tearDownPreviousClass(test, result)
  99.                 self._handleModuleFixture(test, result)
  100.                 self._handleClassSetUp(test, result)
  101.                 result._previousTestClass = test.__class__
  102.  
  103.                 if (getattr(test.__class__, '_classSetupFailed', False) or
  104.                     getattr(result, '_moduleSetUpFailed', False)):
  105.                     continue
  106.  
  107.             if not debug:
  108.                 test(result)
  109.             else:
  110.                 test.debug()
  111.  
  112.         if topLevel:
  113.             self._tearDownPreviousClass(None, result)
  114.             self._handleModuleTearDown(result)
  115.             result._testRunEntered = False
  116.         return result
  117.  
  118.     def debug(self):
  119.         """Run the tests without collecting errors in a TestResult"""
  120.         debug = _DebugResult()
  121.         self.run(debug, True)
  122.  
  123.     ################################
  124.  
  125.     def _handleClassSetUp(self, test, result):
  126.         previousClass = getattr(result, '_previousTestClass', None)
  127.         currentClass = test.__class__
  128.         if currentClass == previousClass:
  129.             return
  130.         if result._moduleSetUpFailed:
  131.             return
  132.         if getattr(currentClass, "__unittest_skip__", False):
  133.             return
  134.  
  135.         try:
  136.             currentClass._classSetupFailed = False
  137.         except TypeError:
  138.             # test may actually be a function
  139.             # so its class will be a builtin-type
  140.             pass
  141.  
  142.         setUpClass = getattr(currentClass, 'setUpClass', None)
  143.         if setUpClass is not None:
  144.             _call_if_exists(result, '_setupStdout')
  145.             try:
  146.                 setUpClass()
  147.             except Exception as e:
  148.                 if isinstance(result, _DebugResult):
  149.                     raise
  150.                 currentClass._classSetupFailed = True
  151.                 className = util.strclass(currentClass)
  152.                 errorName = 'setUpClass (%s)' % className
  153.                 self._addClassOrModuleLevelException(result, e, errorName)
  154.             finally:
  155.                 _call_if_exists(result, '_restoreStdout')
  156.  
  157.     def _get_previous_module(self, result):
  158.         previousModule = None
  159.         previousClass = getattr(result, '_previousTestClass', None)
  160.         if previousClass is not None:
  161.             previousModule = previousClass.__module__
  162.         return previousModule
  163.  
  164.  
  165.     def _handleModuleFixture(self, test, result):
  166.         previousModule = self._get_previous_module(result)
  167.         currentModule = test.__class__.__module__
  168.         if currentModule == previousModule:
  169.             return
  170.  
  171.         self._handleModuleTearDown(result)
  172.  
  173.         result._moduleSetUpFailed = False
  174.         try:
  175.             module = sys.modules[currentModule]
  176.         except KeyError:
  177.             return
  178.         setUpModule = getattr(module, 'setUpModule', None)
  179.         if setUpModule is not None:
  180.             _call_if_exists(result, '_setupStdout')
  181.             try:
  182.                 setUpModule()
  183.             except Exception, e:
  184.                 if isinstance(result, _DebugResult):
  185.                     raise
  186.                 result._moduleSetUpFailed = True
  187.                 errorName = 'setUpModule (%s)' % currentModule
  188.                 self._addClassOrModuleLevelException(result, e, errorName)
  189.             finally:
  190.                 _call_if_exists(result, '_restoreStdout')
  191.  
  192.     def _addClassOrModuleLevelException(self, result, exception, errorName):
  193.         error = _ErrorHolder(errorName)
  194.         addSkip = getattr(result, 'addSkip', None)
  195.         if addSkip is not None and isinstance(exception, case.SkipTest):
  196.             addSkip(error, str(exception))
  197.         else:
  198.             result.addError(error, sys.exc_info())
  199.  
  200.     def _handleModuleTearDown(self, result):
  201.         previousModule = self._get_previous_module(result)
  202.         if previousModule is None:
  203.             return
  204.         if result._moduleSetUpFailed:
  205.             return
  206.  
  207.         try:
  208.             module = sys.modules[previousModule]
  209.         except KeyError:
  210.             return
  211.  
  212.         tearDownModule = getattr(module, 'tearDownModule', None)
  213.         if tearDownModule is not None:
  214.             _call_if_exists(result, '_setupStdout')
  215.             try:
  216.                 tearDownModule()
  217.             except Exception as e:
  218.                 if isinstance(result, _DebugResult):
  219.                     raise
  220.                 errorName = 'tearDownModule (%s)' % previousModule
  221.                 self._addClassOrModuleLevelException(result, e, errorName)
  222.             finally:
  223.                 _call_if_exists(result, '_restoreStdout')
  224.  
  225.     def _tearDownPreviousClass(self, test, result):
  226.         previousClass = getattr(result, '_previousTestClass', None)
  227.         currentClass = test.__class__
  228.         if currentClass == previousClass:
  229.             return
  230.         if getattr(previousClass, '_classSetupFailed', False):
  231.             return
  232.         if getattr(result, '_moduleSetUpFailed', False):
  233.             return
  234.         if getattr(previousClass, "__unittest_skip__", False):
  235.             return
  236.  
  237.         tearDownClass = getattr(previousClass, 'tearDownClass', None)
  238.         if tearDownClass is not None:
  239.             _call_if_exists(result, '_setupStdout')
  240.             try:
  241.                 tearDownClass()
  242.             except Exception, e:
  243.                 if isinstance(result, _DebugResult):
  244.                     raise
  245.                 className = util.strclass(previousClass)
  246.                 errorName = 'tearDownClass (%s)' % className
  247.                 self._addClassOrModuleLevelException(result, e, errorName)
  248.             finally:
  249.                 _call_if_exists(result, '_restoreStdout')
  250.  
  251.  
  252. class _ErrorHolder(object):
  253.     """
  254.     Placeholder for a TestCase inside a result. As far as a TestResult
  255.     is concerned, this looks exactly like a unit test. Used to insert
  256.     arbitrary errors into a test suite run.
  257.     """
  258.     # Inspired by the ErrorHolder from Twisted:
  259.     # http://twistedmatrix.com/trac/browser/trunk/twisted/trial/runner.py
  260.  
  261.     # attribute used by TestResult._exc_info_to_string
  262.     failureException = None
  263.  
  264.     def __init__(self, description):
  265.         self.description = description
  266.  
  267.     def id(self):
  268.         return self.description
  269.  
  270.     def shortDescription(self):
  271.         return None
  272.  
  273.     def __repr__(self):
  274.         return "<ErrorHolder description=%r>" % (self.description,)
  275.  
  276.     def __str__(self):
  277.         return self.id()
  278.  
  279.     def run(self, result):
  280.         # could call result.addError(...) - but this test-like object
  281.         # shouldn't be run anyway
  282.         pass
  283.  
  284.     def __call__(self, result):
  285.         return self.run(result)
  286.  
  287.     def countTestCases(self):
  288.         return 0
  289.  
  290. def _isnotsuite(test):
  291.     "A crude way to tell apart testcases and suites with duck-typing"
  292.     try:
  293.         iter(test)
  294.     except TypeError:
  295.         return True
  296.     return False
  297.  
  298.  
  299. class _DebugResult(object):
  300.     "Used by the TestSuite to hold previous class when running in debug."
  301.     _previousTestClass = None
  302.     _moduleSetUpFailed = False
  303.     shouldStop = False
  304.