292 lines
9.6 KiB
Python
292 lines
9.6 KiB
Python
|
import unittest
|
||
|
|
|
||
|
|
from .support import LoggingResult, TestEquality
|
||
|
|
|
||
|
|
|
||
|
|
### Support code for Test_TestSuite
|
||
|
|
################################################################
|
||
|
|
|
||
|
|
class Test(object):
|
||
|
|
class Foo(unittest.TestCase):
|
||
|
|
def test_1(self): pass
|
||
|
|
def test_2(self): pass
|
||
|
|
def test_3(self): pass
|
||
|
|
def runTest(self): pass
|
||
|
|
|
||
|
|
def _mk_TestSuite(*names):
|
||
|
|
return unittest.TestSuite(Test.Foo(n) for n in names)
|
||
|
|
|
||
|
|
################################################################
|
||
|
|
|
||
|
|
|
||
|
|
class Test_TestSuite(unittest.TestCase, TestEquality):
|
||
|
|
|
||
|
|
### Set up attributes needed by inherited tests
|
||
|
|
################################################################
|
||
|
|
|
||
|
|
# Used by TestEquality.test_eq
|
||
|
|
eq_pairs = [(unittest.TestSuite(), unittest.TestSuite())
|
||
|
|
,(unittest.TestSuite(), unittest.TestSuite([]))
|
||
|
|
,(_mk_TestSuite('test_1'), _mk_TestSuite('test_1'))]
|
||
|
|
|
||
|
|
# Used by TestEquality.test_ne
|
||
|
|
ne_pairs = [(unittest.TestSuite(), _mk_TestSuite('test_1'))
|
||
|
|
,(unittest.TestSuite([]), _mk_TestSuite('test_1'))
|
||
|
|
,(_mk_TestSuite('test_1', 'test_2'), _mk_TestSuite('test_1', 'test_3'))
|
||
|
|
,(_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))]
|
||
|
|
|
||
|
|
################################################################
|
||
|
|
### /Set up attributes needed by inherited tests
|
||
|
|
|
||
|
|
### Tests for TestSuite.__init__
|
||
|
|
################################################################
|
||
|
|
|
||
|
|
# "class TestSuite([tests])"
|
||
|
|
#
|
||
|
|
# The tests iterable should be optional
|
||
|
|
def test_init__tests_optional(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 0)
|
||
|
|
|
||
|
|
# "class TestSuite([tests])"
|
||
|
|
# ...
|
||
|
|
# "If tests is given, it must be an iterable of individual test cases
|
||
|
|
# or other test suites that will be used to build the suite initially"
|
||
|
|
#
|
||
|
|
# TestSuite should deal with empty tests iterables by allowing the
|
||
|
|
# creation of an empty suite
|
||
|
|
def test_init__empty_tests(self):
|
||
|
|
suite = unittest.TestSuite([])
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 0)
|
||
|
|
|
||
|
|
# "class TestSuite([tests])"
|
||
|
|
# ...
|
||
|
|
# "If tests is given, it must be an iterable of individual test cases
|
||
|
|
# or other test suites that will be used to build the suite initially"
|
||
|
|
#
|
||
|
|
# TestSuite should allow any iterable to provide tests
|
||
|
|
def test_init__tests_from_any_iterable(self):
|
||
|
|
def tests():
|
||
|
|
yield unittest.FunctionTestCase(lambda: None)
|
||
|
|
yield unittest.FunctionTestCase(lambda: None)
|
||
|
|
|
||
|
|
suite_1 = unittest.TestSuite(tests())
|
||
|
|
self.assertEqual(suite_1.countTestCases(), 2)
|
||
|
|
|
||
|
|
suite_2 = unittest.TestSuite(suite_1)
|
||
|
|
self.assertEqual(suite_2.countTestCases(), 2)
|
||
|
|
|
||
|
|
suite_3 = unittest.TestSuite(set(suite_1))
|
||
|
|
self.assertEqual(suite_3.countTestCases(), 2)
|
||
|
|
|
||
|
|
# "class TestSuite([tests])"
|
||
|
|
# ...
|
||
|
|
# "If tests is given, it must be an iterable of individual test cases
|
||
|
|
# or other test suites that will be used to build the suite initially"
|
||
|
|
#
|
||
|
|
# Does TestSuite() also allow other TestSuite() instances to be present
|
||
|
|
# in the tests iterable?
|
||
|
|
def test_init__TestSuite_instances_in_tests(self):
|
||
|
|
def tests():
|
||
|
|
ftc = unittest.FunctionTestCase(lambda: None)
|
||
|
|
yield unittest.TestSuite([ftc])
|
||
|
|
yield unittest.FunctionTestCase(lambda: None)
|
||
|
|
|
||
|
|
suite = unittest.TestSuite(tests())
|
||
|
|
self.assertEqual(suite.countTestCases(), 2)
|
||
|
|
|
||
|
|
################################################################
|
||
|
|
### /Tests for TestSuite.__init__
|
||
|
|
|
||
|
|
# Container types should support the iter protocol
|
||
|
|
def test_iter(self):
|
||
|
|
test1 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
test2 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
suite = unittest.TestSuite((test1, test2))
|
||
|
|
|
||
|
|
self.assertEqual(list(suite), [test1, test2])
|
||
|
|
|
||
|
|
# "Return the number of tests represented by the this test object.
|
||
|
|
# ...this method is also implemented by the TestSuite class, which can
|
||
|
|
# return larger [greater than 1] values"
|
||
|
|
#
|
||
|
|
# Presumably an empty TestSuite returns 0?
|
||
|
|
def test_countTestCases_zero_simple(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 0)
|
||
|
|
|
||
|
|
# "Return the number of tests represented by the this test object.
|
||
|
|
# ...this method is also implemented by the TestSuite class, which can
|
||
|
|
# return larger [greater than 1] values"
|
||
|
|
#
|
||
|
|
# Presumably an empty TestSuite (even if it contains other empty
|
||
|
|
# TestSuite instances) returns 0?
|
||
|
|
def test_countTestCases_zero_nested(self):
|
||
|
|
class Test1(unittest.TestCase):
|
||
|
|
def test(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
suite = unittest.TestSuite([unittest.TestSuite()])
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 0)
|
||
|
|
|
||
|
|
# "Return the number of tests represented by the this test object.
|
||
|
|
# ...this method is also implemented by the TestSuite class, which can
|
||
|
|
# return larger [greater than 1] values"
|
||
|
|
def test_countTestCases_simple(self):
|
||
|
|
test1 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
test2 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
suite = unittest.TestSuite((test1, test2))
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 2)
|
||
|
|
|
||
|
|
# "Return the number of tests represented by the this test object.
|
||
|
|
# ...this method is also implemented by the TestSuite class, which can
|
||
|
|
# return larger [greater than 1] values"
|
||
|
|
#
|
||
|
|
# Make sure this holds for nested TestSuite instances, too
|
||
|
|
def test_countTestCases_nested(self):
|
||
|
|
class Test1(unittest.TestCase):
|
||
|
|
def test1(self): pass
|
||
|
|
def test2(self): pass
|
||
|
|
|
||
|
|
test2 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
test3 = unittest.FunctionTestCase(lambda: None)
|
||
|
|
child = unittest.TestSuite((Test1('test2'), test2))
|
||
|
|
parent = unittest.TestSuite((test3, child, Test1('test1')))
|
||
|
|
|
||
|
|
self.assertEqual(parent.countTestCases(), 4)
|
||
|
|
|
||
|
|
# "Run the tests associated with this suite, collecting the result into
|
||
|
|
# the test result object passed as result."
|
||
|
|
#
|
||
|
|
# And if there are no tests? What then?
|
||
|
|
def test_run__empty_suite(self):
|
||
|
|
events = []
|
||
|
|
result = LoggingResult(events)
|
||
|
|
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
suite.run(result)
|
||
|
|
|
||
|
|
self.assertEqual(events, [])
|
||
|
|
|
||
|
|
# "Note that unlike TestCase.run(), TestSuite.run() requires the
|
||
|
|
# "result object to be passed in."
|
||
|
|
def test_run__requires_result(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
try:
|
||
|
|
suite.run()
|
||
|
|
except TypeError:
|
||
|
|
pass
|
||
|
|
else:
|
||
|
|
self.fail("Failed to raise TypeError")
|
||
|
|
|
||
|
|
# "Run the tests associated with this suite, collecting the result into
|
||
|
|
# the test result object passed as result."
|
||
|
|
def test_run(self):
|
||
|
|
events = []
|
||
|
|
result = LoggingResult(events)
|
||
|
|
|
||
|
|
class LoggingCase(unittest.TestCase):
|
||
|
|
def run(self, result):
|
||
|
|
events.append('run %s' % self._testMethodName)
|
||
|
|
|
||
|
|
def test1(self): pass
|
||
|
|
def test2(self): pass
|
||
|
|
|
||
|
|
tests = [LoggingCase('test1'), LoggingCase('test2')]
|
||
|
|
|
||
|
|
unittest.TestSuite(tests).run(result)
|
||
|
|
|
||
|
|
self.assertEqual(events, ['run test1', 'run test2'])
|
||
|
|
|
||
|
|
# "Add a TestCase ... to the suite"
|
||
|
|
def test_addTest__TestCase(self):
|
||
|
|
class Foo(unittest.TestCase):
|
||
|
|
def test(self): pass
|
||
|
|
|
||
|
|
test = Foo('test')
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
suite.addTest(test)
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 1)
|
||
|
|
self.assertEqual(list(suite), [test])
|
||
|
|
|
||
|
|
# "Add a ... TestSuite to the suite"
|
||
|
|
def test_addTest__TestSuite(self):
|
||
|
|
class Foo(unittest.TestCase):
|
||
|
|
def test(self): pass
|
||
|
|
|
||
|
|
suite_2 = unittest.TestSuite([Foo('test')])
|
||
|
|
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
suite.addTest(suite_2)
|
||
|
|
|
||
|
|
self.assertEqual(suite.countTestCases(), 1)
|
||
|
|
self.assertEqual(list(suite), [suite_2])
|
||
|
|
|
||
|
|
# "Add all the tests from an iterable of TestCase and TestSuite
|
||
|
|
# instances to this test suite."
|
||
|
|
#
|
||
|
|
# "This is equivalent to iterating over tests, calling addTest() for
|
||
|
|
# each element"
|
||
|
|
def test_addTests(self):
|
||
|
|
class Foo(unittest.TestCase):
|
||
|
|
def test_1(self): pass
|
||
|
|
def test_2(self): pass
|
||
|
|
|
||
|
|
test_1 = Foo('test_1')
|
||
|
|
test_2 = Foo('test_2')
|
||
|
|
inner_suite = unittest.TestSuite([test_2])
|
||
|
|
|
||
|
|
def gen():
|
||
|
|
yield test_1
|
||
|
|
yield test_2
|
||
|
|
yield inner_suite
|
||
|
|
|
||
|
|
suite_1 = unittest.TestSuite()
|
||
|
|
suite_1.addTests(gen())
|
||
|
|
|
||
|
|
self.assertEqual(list(suite_1), list(gen()))
|
||
|
|
|
||
|
|
# "This is equivalent to iterating over tests, calling addTest() for
|
||
|
|
# each element"
|
||
|
|
suite_2 = unittest.TestSuite()
|
||
|
|
for t in gen():
|
||
|
|
suite_2.addTest(t)
|
||
|
|
|
||
|
|
self.assertEqual(suite_1, suite_2)
|
||
|
|
|
||
|
|
# "Add all the tests from an iterable of TestCase and TestSuite
|
||
|
|
# instances to this test suite."
|
||
|
|
#
|
||
|
|
# What happens if it doesn't get an iterable?
|
||
|
|
def test_addTest__noniterable(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
|
||
|
|
try:
|
||
|
|
suite.addTests(5)
|
||
|
|
except TypeError:
|
||
|
|
pass
|
||
|
|
else:
|
||
|
|
self.fail("Failed to raise TypeError")
|
||
|
|
|
||
|
|
def test_addTest__noncallable(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
self.assertRaises(TypeError, suite.addTest, 5)
|
||
|
|
|
||
|
|
def test_addTest__casesuiteclass(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
self.assertRaises(TypeError, suite.addTest, Test_TestSuite)
|
||
|
|
self.assertRaises(TypeError, suite.addTest, unittest.TestSuite)
|
||
|
|
|
||
|
|
def test_addTests__string(self):
|
||
|
|
suite = unittest.TestSuite()
|
||
|
|
self.assertRaises(TypeError, suite.addTests, "foo")
|