Test suites are implemented by the :class:`TestSuite` class. This class allows
individual tests and test suites to be aggregated; when the suite is executed,
-all tests added directly to the suite and in "child" test suites are run. A
-:class:`ClassTestSuite` contains the test cases of a class.
+all tests added directly to the suite and in "child" test suites are run.
A test runner is an object that provides a single method,
:meth:`~TestRunner.run`, which accepts a :class:`TestCase` or :class:`TestSuite`
test suites that will be used to build the suite initially. Additional methods
are provided to add test cases and suites to the collection later on.
- :class:`TestSuite` (including :class:`ClassTestSuite`) objects behave much
- like :class:`TestCase` objects, except they do not actually implement a test.
- Instead, they are used to aggregate tests into groups of tests that should be
- run together. Some additional methods are available to add tests to
- :class:`TestSuite` instances:
+ :class:`TestSuite` objects behave much like :class:`TestCase` objects, except
+ they do not actually implement a test. Instead, they are used to aggregate
+ tests into groups of tests that should be run together. Some additional
+ methods are available to add tests to :class:`TestSuite` instances:
.. method:: TestSuite.addTest(test)
is invoked by a :class:`TestRunner` rather than by the end-user test harness.
-.. class:: ClassTestSuite(tests, collected_from)
-
- This subclass of :class:`TestSuite` repesents an aggregation of individuals
- tests from one :class:`TestCase` class. *tests* is an iterable of
- :class:`TestCase` instances created from the class. *collected_from* is the
- class they came from.
-
-
Loading and running tests
~~~~~~~~~~~~~~~~~~~~~~~~~
This affects all the :meth:`loadTestsFrom\*` methods.
- .. attribute:: classSuiteClass
-
- Callable object that constructs a test suite for the tests cases from one
- class. The default value is :class:`ClassTestSuite`.
-
-
.. class:: TestResult
This class is used to compile information about which tests have succeeded
# List subclass we can add attributes to.
class MyClassSuite(list):
- def __init__(self, tests, klass):
+ def __init__(self, tests):
super(MyClassSuite, self).__init__(tests)
tests = [Foo('test_1'), Foo('test_2')]
loader = unittest.TestLoader()
- loader.classSuiteClass = MyClassSuite
+ loader.suiteClass = list
self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
# It is implicit in the documentation for TestLoader.suiteClass that
def foo_bar(self): pass
m.Foo = Foo
- tests = [unittest.ClassTestSuite([Foo('test_1'), Foo('test_2')], Foo)]
+ tests = [[Foo('test_1'), Foo('test_2')]]
loader = unittest.TestLoader()
loader.suiteClass = list
tests = [Foo('test_1'), Foo('test_2')]
loader = unittest.TestLoader()
- loader.classSuiteClass = MyClassSuite
+ loader.suiteClass = list
self.assertEqual(loader.loadTestsFromName('Foo', m), tests)
# It is implicit in the documentation for TestLoader.suiteClass that
def foo_bar(self): pass
m.Foo = Foo
- tests = [unittest.ClassTestSuite([Foo('test_1'), Foo('test_2')], Foo)]
+ tests = [[Foo('test_1'), Foo('test_2')]]
loader = unittest.TestLoader()
loader.suiteClass = list
def test_dont_skip(self): pass
test_do_skip = Foo("test_skip")
test_dont_skip = Foo("test_dont_skip")
- suite = unittest.ClassTestSuite([test_do_skip, test_dont_skip], Foo)
+ suite = unittest.TestSuite([test_do_skip, test_dont_skip])
events = []
result = LoggingResult(events)
suite.run(result)
record.append(1)
record = []
result = unittest.TestResult()
- suite = unittest.ClassTestSuite([Foo("test_1")], Foo)
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
suite.run(result)
- self.assertEqual(result.skipped, [(suite, "testing")])
+ self.assertEqual(result.skipped, [(test, "testing")])
self.assertEqual(record, [])
def test_expected_failure(self):
##############################################################################
# Exported classes and functions
##############################################################################
-__all__ = ['TestResult', 'TestCase', 'TestSuite', 'ClassTestSuite',
+__all__ = ['TestResult', 'TestCase', 'TestSuite',
'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main',
'defaultTestLoader', 'SkipTest', 'skip', 'skipIf', 'skipUnless',
'expectedFailure']
self._result = result
result.startTest(self)
+ if getattr(self.__class__, "__unittest_skip__", False):
+ # If the whole class was skipped.
+ try:
+ result.addSkip(self, self.__class__.__unittest_skip_why__)
+ finally:
+ result.stopTest(self)
+ return
testMethod = getattr(self, self._testMethodName)
try:
success = False
test.debug()
-class ClassTestSuite(TestSuite):
- """
- Suite of tests derived from a single TestCase class.
- """
-
- def __init__(self, tests, class_collected_from):
- super(ClassTestSuite, self).__init__(tests)
- self.collected_from = class_collected_from
-
- def id(self):
- module = getattr(self.collected_from, "__module__", None)
- if module is not None:
- return "{0}.{1}".format(module, self.collected_from.__name__)
- return self.collected_from.__name__
-
- def run(self, result):
- if getattr(self.collected_from, "__unittest_skip__", False):
- # ClassTestSuite result pretends to be a TestCase enough to be
- # reported.
- result.startTest(self)
- try:
- result.addSkip(self, self.collected_from.__unittest_skip_why__)
- finally:
- result.stopTest(self)
- else:
- result = super(ClassTestSuite, self).run(result)
- return result
-
- shortDescription = id
-
-
class FunctionTestCase(TestCase):
"""A test case that wraps a test function.
testMethodPrefix = 'test'
sortTestMethodsUsing = staticmethod(three_way_cmp)
suiteClass = TestSuite
- classSuiteClass = ClassTestSuite
def loadTestsFromTestCase(self, testCaseClass):
"""Return a suite of all tests cases contained in testCaseClass"""
testCaseNames = self.getTestCaseNames(testCaseClass)
if not testCaseNames and hasattr(testCaseClass, 'runTest'):
testCaseNames = ['runTest']
- suite = self.classSuiteClass(map(testCaseClass, testCaseNames),
- testCaseClass)
+ suite = self.suiteClass(map(testCaseClass, testCaseNames))
return suite
def loadTestsFromModule(self, module):
Library
-------
+- In unittest, using a skipping decorator on a class is now equivalent to
+ skipping every test on the class. The ClassTestSuite class has been removed.
+
- Issue #6050: Don't fail extracting a directory from a zipfile if
the directory already exists.
projects / python / commitdiff