Turn unittest tests into a package
This commit is contained in:
Michael Foord
parent
fbe519975b
commit
35b3792ed3
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,35 @@
|
|||
"""Test suite for distutils.
|
||||
|
||||
This test suite consists of a collection of test modules in the
|
||||
distutils.tests package. Each test module has a name starting with
|
||||
'test' and contains a function test_suite(). The function is expected
|
||||
to return an initialized unittest.TestSuite instance.
|
||||
|
||||
Tests for the command classes in the distutils.command package are
|
||||
included in distutils.tests as well, instead of using a separate
|
||||
distutils.command.tests package, since command identification is done
|
||||
by import rather than matching pre-defined names.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
here = os.path.dirname(__file__)
|
||||
loader = unittest.defaultTestLoader
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
for fn in os.listdir(here):
|
||||
if fn.startswith("test") and fn.endswith(".py"):
|
||||
modname = "unittest.test." + fn[:-3]
|
||||
__import__(modname)
|
||||
module = sys.modules[modname]
|
||||
suite.addTest(loader.loadTestsFromModule(module))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(defaultTest="test_suite")
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
import unittest
|
||||
|
||||
|
||||
class TestHashing(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __hash__ implementation
|
||||
def test_hash(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
try:
|
||||
if not hash(obj_1) == hash(obj_2):
|
||||
self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception, e:
|
||||
self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
|
||||
|
||||
for obj_1, obj_2 in self.ne_pairs:
|
||||
try:
|
||||
if hash(obj_1) == hash(obj_2):
|
||||
self.fail("%s and %s hash equal, but shouldn't" %
|
||||
(obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception, e:
|
||||
self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
|
||||
|
||||
|
||||
class TestEquality(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __eq__ implementation
|
||||
def test_eq(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
self.assertEqual(obj_1, obj_2)
|
||||
self.assertEqual(obj_2, obj_1)
|
||||
|
||||
# Check for a valid __ne__ implementation
|
||||
def test_ne(self):
|
||||
for obj_1, obj_2 in self.ne_pairs:
|
||||
self.assertNotEqual(obj_1, obj_2)
|
||||
self.assertNotEqual(obj_2, obj_1)
|
||||
|
||||
|
||||
class LoggingResult(unittest.TestResult):
|
||||
def __init__(self, log):
|
||||
self._events = log
|
||||
super(LoggingResult, self).__init__()
|
||||
|
||||
def startTest(self, test):
|
||||
self._events.append('startTest')
|
||||
super(LoggingResult, self).startTest(test)
|
||||
|
||||
def startTestRun(self):
|
||||
self._events.append('startTestRun')
|
||||
super(LoggingResult, self).startTestRun()
|
||||
|
||||
def stopTest(self, test):
|
||||
self._events.append('stopTest')
|
||||
super(LoggingResult, self).stopTest(test)
|
||||
|
||||
def stopTestRun(self):
|
||||
self._events.append('stopTestRun')
|
||||
super(LoggingResult, self).stopTestRun()
|
||||
|
||||
def addFailure(self, *args):
|
||||
self._events.append('addFailure')
|
||||
super(LoggingResult, self).addFailure(*args)
|
||||
|
||||
def addSuccess(self, *args):
|
||||
self._events.append('addSuccess')
|
||||
super(LoggingResult, self).addSuccess(*args)
|
||||
|
||||
def addError(self, *args):
|
||||
self._events.append('addError')
|
||||
super(LoggingResult, self).addError(*args)
|
||||
|
||||
def addSkip(self, *args):
|
||||
self._events.append('addSkip')
|
||||
super(LoggingResult, self).addSkip(*args)
|
||||
|
||||
def addExpectedFailure(self, *args):
|
||||
self._events.append('addExpectedFailure')
|
||||
super(LoggingResult, self).addExpectedFailure(*args)
|
||||
|
||||
def addUnexpectedSuccess(self, *args):
|
||||
self._events.append('addUnexpectedSuccess')
|
||||
super(LoggingResult, self).addUnexpectedSuccess(*args)
|
||||
|
||||
|
||||
class ResultWithNoStartTestRunStopTestRun(object):
|
||||
"""An object honouring TestResult before startTestRun/stopTestRun."""
|
||||
|
||||
def __init__(self):
|
||||
self.failures = []
|
||||
self.errors = []
|
||||
self.testsRun = 0
|
||||
self.skipped = []
|
||||
self.expectedFailures = []
|
||||
self.unexpectedSuccesses = []
|
||||
self.shouldStop = False
|
||||
|
||||
def startTest(self, test):
|
||||
pass
|
||||
|
||||
def stopTest(self, test):
|
||||
pass
|
||||
|
||||
def addError(self, test):
|
||||
pass
|
||||
|
||||
def addFailure(self, test):
|
||||
pass
|
||||
|
||||
def addSuccess(self, test):
|
||||
pass
|
||||
|
||||
def wasSuccessful(self):
|
||||
return True
|
||||
|
|
@ -0,0 +1,258 @@
|
|||
import unittest
|
||||
|
||||
|
||||
class Test_Assertions(unittest.TestCase):
|
||||
def test_AlmostEqual(self):
|
||||
self.assertAlmostEqual(1.00000001, 1.0)
|
||||
self.assertNotAlmostEqual(1.0000001, 1.0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 1.0000001, 1.0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertNotAlmostEqual, 1.00000001, 1.0)
|
||||
|
||||
self.assertAlmostEqual(1.1, 1.0, places=0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 1.1, 1.0, places=1)
|
||||
|
||||
self.assertAlmostEqual(0, .1+.1j, places=0)
|
||||
self.assertNotAlmostEqual(0, .1+.1j, places=1)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 0, .1+.1j, places=1)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertNotAlmostEqual, 0, .1+.1j, places=0)
|
||||
|
||||
self.assertAlmostEqual(float('inf'), float('inf'))
|
||||
self.assertRaises(self.failureException, self.assertNotAlmostEqual,
|
||||
float('inf'), float('inf'))
|
||||
|
||||
|
||||
def test_assertRaises(self):
|
||||
def _raise(e):
|
||||
raise e
|
||||
self.assertRaises(KeyError, _raise, KeyError)
|
||||
self.assertRaises(KeyError, _raise, KeyError("key"))
|
||||
try:
|
||||
self.assertRaises(KeyError, lambda: None)
|
||||
except self.failureException as e:
|
||||
self.assertIn("KeyError not raised", e.args)
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
try:
|
||||
self.assertRaises(KeyError, _raise, ValueError)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self.fail("assertRaises() didn't let exception pass through")
|
||||
with self.assertRaises(KeyError) as cm:
|
||||
try:
|
||||
raise KeyError
|
||||
except Exception, e:
|
||||
raise
|
||||
self.assertIs(cm.exception, e)
|
||||
|
||||
with self.assertRaises(KeyError):
|
||||
raise KeyError("key")
|
||||
try:
|
||||
with self.assertRaises(KeyError):
|
||||
pass
|
||||
except self.failureException as e:
|
||||
self.assertIn("KeyError not raised", e.args)
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
try:
|
||||
with self.assertRaises(KeyError):
|
||||
raise ValueError
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self.fail("assertRaises() didn't let exception pass through")
|
||||
|
||||
|
||||
class TestLongMessage(unittest.TestCase):
|
||||
"""Test that the individual asserts honour longMessage.
|
||||
This actually tests all the message behaviour for
|
||||
asserts that use longMessage."""
|
||||
|
||||
def setUp(self):
|
||||
class TestableTestFalse(unittest.TestCase):
|
||||
longMessage = False
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
class TestableTestTrue(unittest.TestCase):
|
||||
longMessage = True
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
self.testableTrue = TestableTestTrue('testTest')
|
||||
self.testableFalse = TestableTestFalse('testTest')
|
||||
|
||||
def testDefault(self):
|
||||
self.assertFalse(unittest.TestCase.longMessage)
|
||||
|
||||
def test_formatMsg(self):
|
||||
self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo")
|
||||
self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo")
|
||||
|
||||
self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
|
||||
self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
|
||||
|
||||
# This blows up if _formatMessage uses string concatenation
|
||||
self.testableTrue._formatMessage(object(), 'foo')
|
||||
|
||||
def test_formatMessage_unicode_error(self):
|
||||
one = ''.join(chr(i) for i in range(255))
|
||||
# this used to cause a UnicodeDecodeError constructing msg
|
||||
self.testableTrue._formatMessage(one, u'\uFFFD')
|
||||
|
||||
def assertMessages(self, methodName, args, errors):
|
||||
def getMethod(i):
|
||||
useTestableFalse = i < 2
|
||||
if useTestableFalse:
|
||||
test = self.testableFalse
|
||||
else:
|
||||
test = self.testableTrue
|
||||
return getattr(test, methodName)
|
||||
|
||||
for i, expected_regexp in enumerate(errors):
|
||||
testMethod = getMethod(i)
|
||||
kwargs = {}
|
||||
withMsg = i % 2
|
||||
if withMsg:
|
||||
kwargs = {"msg": "oops"}
|
||||
|
||||
with self.assertRaisesRegexp(self.failureException,
|
||||
expected_regexp=expected_regexp):
|
||||
testMethod(*args, **kwargs)
|
||||
|
||||
def testAssertTrue(self):
|
||||
self.assertMessages('assertTrue', (False,),
|
||||
["^False is not True$", "^oops$", "^False is not True$",
|
||||
"^False is not True : oops$"])
|
||||
|
||||
def testAssertFalse(self):
|
||||
self.assertMessages('assertFalse', (True,),
|
||||
["^True is not False$", "^oops$", "^True is not False$",
|
||||
"^True is not False : oops$"])
|
||||
|
||||
def testNotEqual(self):
|
||||
self.assertMessages('assertNotEqual', (1, 1),
|
||||
["^1 == 1$", "^oops$", "^1 == 1$",
|
||||
"^1 == 1 : oops$"])
|
||||
|
||||
def testAlmostEqual(self):
|
||||
self.assertMessages('assertAlmostEqual', (1, 2),
|
||||
["^1 != 2 within 7 places$", "^oops$",
|
||||
"^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])
|
||||
|
||||
def testNotAlmostEqual(self):
|
||||
self.assertMessages('assertNotAlmostEqual', (1, 1),
|
||||
["^1 == 1 within 7 places$", "^oops$",
|
||||
"^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])
|
||||
|
||||
def test_baseAssertEqual(self):
|
||||
self.assertMessages('_baseAssertEqual', (1, 2),
|
||||
["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
|
||||
|
||||
def testAssertSequenceEqual(self):
|
||||
# Error messages are multiline so not testing on full message
|
||||
# assertTupleEqual and assertListEqual delegate to this method
|
||||
self.assertMessages('assertSequenceEqual', ([], [None]),
|
||||
["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
|
||||
r"\+ \[None\] : oops$"])
|
||||
|
||||
def testAssertSetEqual(self):
|
||||
self.assertMessages('assertSetEqual', (set(), set([None])),
|
||||
["None$", "^oops$", "None$",
|
||||
"None : oops$"])
|
||||
|
||||
def testAssertIn(self):
|
||||
self.assertMessages('assertIn', (None, []),
|
||||
['^None not found in \[\]$', "^oops$",
|
||||
'^None not found in \[\]$',
|
||||
'^None not found in \[\] : oops$'])
|
||||
|
||||
def testAssertNotIn(self):
|
||||
self.assertMessages('assertNotIn', (None, [None]),
|
||||
['^None unexpectedly found in \[None\]$', "^oops$",
|
||||
'^None unexpectedly found in \[None\]$',
|
||||
'^None unexpectedly found in \[None\] : oops$'])
|
||||
|
||||
def testAssertDictEqual(self):
|
||||
self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
|
||||
[r"\+ \{'key': 'value'\}$", "^oops$",
|
||||
"\+ \{'key': 'value'\}$",
|
||||
"\+ \{'key': 'value'\} : oops$"])
|
||||
|
||||
def testAssertDictContainsSubset(self):
|
||||
self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
|
||||
["^Missing: 'key'$", "^oops$",
|
||||
"^Missing: 'key'$",
|
||||
"^Missing: 'key' : oops$"])
|
||||
|
||||
def testAssertItemsEqual(self):
|
||||
self.assertMessages('assertItemsEqual', ([], [None]),
|
||||
[r"\[None\]$", "^oops$",
|
||||
r"\[None\]$",
|
||||
r"\[None\] : oops$"])
|
||||
|
||||
def testAssertMultiLineEqual(self):
|
||||
self.assertMessages('assertMultiLineEqual', ("", "foo"),
|
||||
[r"\+ foo$", "^oops$",
|
||||
r"\+ foo$",
|
||||
r"\+ foo : oops$"])
|
||||
|
||||
def testAssertLess(self):
|
||||
self.assertMessages('assertLess', (2, 1),
|
||||
["^2 not less than 1$", "^oops$",
|
||||
"^2 not less than 1$", "^2 not less than 1 : oops$"])
|
||||
|
||||
def testAssertLessEqual(self):
|
||||
self.assertMessages('assertLessEqual', (2, 1),
|
||||
["^2 not less than or equal to 1$", "^oops$",
|
||||
"^2 not less than or equal to 1$",
|
||||
"^2 not less than or equal to 1 : oops$"])
|
||||
|
||||
def testAssertGreater(self):
|
||||
self.assertMessages('assertGreater', (1, 2),
|
||||
["^1 not greater than 2$", "^oops$",
|
||||
"^1 not greater than 2$",
|
||||
"^1 not greater than 2 : oops$"])
|
||||
|
||||
def testAssertGreaterEqual(self):
|
||||
self.assertMessages('assertGreaterEqual', (1, 2),
|
||||
["^1 not greater than or equal to 2$", "^oops$",
|
||||
"^1 not greater than or equal to 2$",
|
||||
"^1 not greater than or equal to 2 : oops$"])
|
||||
|
||||
def testAssertIsNone(self):
|
||||
self.assertMessages('assertIsNone', ('not None',),
|
||||
["^'not None' is not None$", "^oops$",
|
||||
"^'not None' is not None$",
|
||||
"^'not None' is not None : oops$"])
|
||||
|
||||
def testAssertIsNotNone(self):
|
||||
self.assertMessages('assertIsNotNone', (None,),
|
||||
["^unexpectedly None$", "^oops$",
|
||||
"^unexpectedly None$",
|
||||
"^unexpectedly None : oops$"])
|
||||
|
||||
def testAssertIs(self):
|
||||
self.assertMessages('assertIs', (None, 'foo'),
|
||||
["^None is not 'foo'$", "^oops$",
|
||||
"^None is not 'foo'$",
|
||||
"^None is not 'foo' : oops$"])
|
||||
|
||||
def testAssertIsNot(self):
|
||||
self.assertMessages('assertIsNot', (None, None),
|
||||
["^unexpectedly identical: None$", "^oops$",
|
||||
"^unexpectedly identical: None$",
|
||||
"^unexpectedly identical: None : oops$"])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,907 @@
|
|||
import re
|
||||
import sys
|
||||
|
||||
from copy import deepcopy
|
||||
from test import test_support
|
||||
|
||||
import unittest
|
||||
|
||||
from .support import (
|
||||
TestEquality, TestHashing, LoggingResult, ResultWithNoStartTestRunStopTestRun
|
||||
)
|
||||
|
||||
|
||||
class Test(object):
|
||||
"Keep these TestCase classes out of the main namespace"
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self): pass
|
||||
def test1(self): pass
|
||||
|
||||
class Bar(Foo):
|
||||
def test2(self): pass
|
||||
|
||||
class LoggingTestCase(unittest.TestCase):
|
||||
"""A test case which logs its calls."""
|
||||
|
||||
def __init__(self, events):
|
||||
super(Test.LoggingTestCase, self).__init__('test')
|
||||
self.events = events
|
||||
|
||||
def setUp(self):
|
||||
self.events.append('setUp')
|
||||
|
||||
def test(self):
|
||||
self.events.append('test')
|
||||
|
||||
def tearDown(self):
|
||||
self.events.append('tearDown')
|
||||
|
||||
|
||||
class Test_TestCase(unittest.TestCase, TestEquality, TestHashing):
|
||||
|
||||
### Set up attributes used by inherited tests
|
||||
################################################################
|
||||
|
||||
# Used by TestHashing.test_hash and TestEquality.test_eq
|
||||
eq_pairs = [(Test.Foo('test1'), Test.Foo('test1'))]
|
||||
|
||||
# Used by TestEquality.test_ne
|
||||
ne_pairs = [(Test.Foo('test1'), Test.Foo('runTest'))
|
||||
,(Test.Foo('test1'), Test.Bar('test1'))
|
||||
,(Test.Foo('test1'), Test.Bar('test2'))]
|
||||
|
||||
################################################################
|
||||
### /Set up attributes used by inherited tests
|
||||
|
||||
|
||||
# "class TestCase([methodName])"
|
||||
# ...
|
||||
# "Each instance of TestCase will run a single test method: the
|
||||
# method named methodName."
|
||||
# ...
|
||||
# "methodName defaults to "runTest"."
|
||||
#
|
||||
# Make sure it really is optional, and that it defaults to the proper
|
||||
# thing.
|
||||
def test_init__no_test_name(self):
|
||||
class Test(unittest.TestCase):
|
||||
def runTest(self): raise TypeError()
|
||||
def test(self): pass
|
||||
|
||||
self.assertEqual(Test().id()[-13:], '.Test.runTest')
|
||||
|
||||
# "class TestCase([methodName])"
|
||||
# ...
|
||||
# "Each instance of TestCase will run a single test method: the
|
||||
# method named methodName."
|
||||
def test_init__test_name__valid(self):
|
||||
class Test(unittest.TestCase):
|
||||
def runTest(self): raise TypeError()
|
||||
def test(self): pass
|
||||
|
||||
self.assertEqual(Test('test').id()[-10:], '.Test.test')
|
||||
|
||||
# "class TestCase([methodName])"
|
||||
# ...
|
||||
# "Each instance of TestCase will run a single test method: the
|
||||
# method named methodName."
|
||||
def test_init__test_name__invalid(self):
|
||||
class Test(unittest.TestCase):
|
||||
def runTest(self): raise TypeError()
|
||||
def test(self): pass
|
||||
|
||||
try:
|
||||
Test('testfoo')
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self.fail("Failed to raise ValueError")
|
||||
|
||||
# "Return the number of tests represented by the this test object. For
|
||||
# TestCase instances, this will always be 1"
|
||||
def test_countTestCases(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self): pass
|
||||
|
||||
self.assertEqual(Foo('test').countTestCases(), 1)
|
||||
|
||||
# "Return the default type of test result object to be used to run this
|
||||
# test. For TestCase instances, this will always be
|
||||
# unittest.TestResult; subclasses of TestCase should
|
||||
# override this as necessary."
|
||||
def test_defaultTestResult(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
result = Foo().defaultTestResult()
|
||||
self.assertEqual(type(result), unittest.TestResult)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if setUp() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_setUp(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def setUp(self):
|
||||
super(Foo, self).setUp()
|
||||
raise RuntimeError('raised by Foo.setUp')
|
||||
|
||||
Foo(events).run(result)
|
||||
expected = ['startTest', 'setUp', 'addError', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "With a temporary result stopTestRun is called when setUp errors.
|
||||
def test_run_call_order__error_in_setUp_default_result(self):
|
||||
events = []
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def defaultTestResult(self):
|
||||
return LoggingResult(self.events)
|
||||
|
||||
def setUp(self):
|
||||
super(Foo, self).setUp()
|
||||
raise RuntimeError('raised by Foo.setUp')
|
||||
|
||||
Foo(events).run()
|
||||
expected = ['startTestRun', 'startTest', 'setUp', 'addError',
|
||||
'stopTest', 'stopTestRun']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test raises
|
||||
# an error (as opposed to a failure).
|
||||
def test_run_call_order__error_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def test(self):
|
||||
super(Foo, self).test()
|
||||
raise RuntimeError('raised by Foo.test')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
|
||||
'stopTest']
|
||||
Foo(events).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "With a default result, an error in the test still results in stopTestRun
|
||||
# being called."
|
||||
def test_run_call_order__error_in_test_default_result(self):
|
||||
events = []
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def defaultTestResult(self):
|
||||
return LoggingResult(self.events)
|
||||
|
||||
def test(self):
|
||||
super(Foo, self).test()
|
||||
raise RuntimeError('raised by Foo.test')
|
||||
|
||||
expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addError',
|
||||
'tearDown', 'stopTest', 'stopTestRun']
|
||||
Foo(events).run()
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test signals
|
||||
# a failure (as opposed to an error).
|
||||
def test_run_call_order__failure_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def test(self):
|
||||
super(Foo, self).test()
|
||||
self.fail('raised by Foo.test')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
|
||||
'stopTest']
|
||||
Foo(events).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a test fails with a default result stopTestRun is still called."
|
||||
def test_run_call_order__failure_in_test_default_result(self):
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def defaultTestResult(self):
|
||||
return LoggingResult(self.events)
|
||||
def test(self):
|
||||
super(Foo, self).test()
|
||||
self.fail('raised by Foo.test')
|
||||
|
||||
expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addFailure',
|
||||
'tearDown', 'stopTest', 'stopTestRun']
|
||||
events = []
|
||||
Foo(events).run()
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if tearDown() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_tearDown(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def tearDown(self):
|
||||
super(Foo, self).tearDown()
|
||||
raise RuntimeError('raised by Foo.tearDown')
|
||||
|
||||
Foo(events).run(result)
|
||||
expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
|
||||
'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When tearDown errors with a default result stopTestRun is still called."
|
||||
def test_run_call_order__error_in_tearDown_default_result(self):
|
||||
|
||||
class Foo(Test.LoggingTestCase):
|
||||
def defaultTestResult(self):
|
||||
return LoggingResult(self.events)
|
||||
def tearDown(self):
|
||||
super(Foo, self).tearDown()
|
||||
raise RuntimeError('raised by Foo.tearDown')
|
||||
|
||||
events = []
|
||||
Foo(events).run()
|
||||
expected = ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown',
|
||||
'addError', 'stopTest', 'stopTestRun']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "TestCase.run() still works when the defaultTestResult is a TestResult
|
||||
# that does not support startTestRun and stopTestRun.
|
||||
def test_run_call_order_default_result(self):
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def defaultTestResult(self):
|
||||
return ResultWithNoStartTestRunStopTestRun()
|
||||
def test(self):
|
||||
pass
|
||||
|
||||
Foo('test').run()
|
||||
|
||||
# "This class attribute gives the exception raised by the test() method.
|
||||
# If a test framework needs to use a specialized exception, possibly to
|
||||
# carry additional information, it must subclass this exception in
|
||||
# order to ``play fair'' with the framework. The initial value of this
|
||||
# attribute is AssertionError"
|
||||
def test_failureException__default(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self):
|
||||
pass
|
||||
|
||||
self.assertTrue(Foo('test').failureException is AssertionError)
|
||||
|
||||
# "This class attribute gives the exception raised by the test() method.
|
||||
# If a test framework needs to use a specialized exception, possibly to
|
||||
# carry additional information, it must subclass this exception in
|
||||
# order to ``play fair'' with the framework."
|
||||
#
|
||||
# Make sure TestCase.run() respects the designated failureException
|
||||
def test_failureException__subclassing__explicit_raise(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self):
|
||||
raise RuntimeError()
|
||||
|
||||
failureException = RuntimeError
|
||||
|
||||
self.assertTrue(Foo('test').failureException is RuntimeError)
|
||||
|
||||
|
||||
Foo('test').run(result)
|
||||
expected = ['startTest', 'addFailure', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "This class attribute gives the exception raised by the test() method.
|
||||
# If a test framework needs to use a specialized exception, possibly to
|
||||
# carry additional information, it must subclass this exception in
|
||||
# order to ``play fair'' with the framework."
|
||||
#
|
||||
# Make sure TestCase.run() respects the designated failureException
|
||||
def test_failureException__subclassing__implicit_raise(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self):
|
||||
self.fail("foo")
|
||||
|
||||
failureException = RuntimeError
|
||||
|
||||
self.assertTrue(Foo('test').failureException is RuntimeError)
|
||||
|
||||
|
||||
Foo('test').run(result)
|
||||
expected = ['startTest', 'addFailure', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "The default implementation does nothing."
|
||||
def test_setUp(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
# ... and nothing should happen
|
||||
Foo().setUp()
|
||||
|
||||
# "The default implementation does nothing."
|
||||
def test_tearDown(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
# ... and nothing should happen
|
||||
Foo().tearDown()
|
||||
|
||||
# "Return a string identifying the specific test case."
|
||||
#
|
||||
# Because of the vague nature of the docs, I'm not going to lock this
|
||||
# test down too much. Really all that can be asserted is that the id()
|
||||
# will be a string (either 8-byte or unicode -- again, because the docs
|
||||
# just say "string")
|
||||
def test_id(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
self.assertIsInstance(Foo().id(), basestring)
|
||||
|
||||
# "If result is omitted or None, a temporary result object is created
|
||||
# and used, but is not made available to the caller. As TestCase owns the
|
||||
# temporary result startTestRun and stopTestRun are called.
|
||||
|
||||
def test_run__uses_defaultTestResult(self):
|
||||
events = []
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self):
|
||||
events.append('test')
|
||||
|
||||
def defaultTestResult(self):
|
||||
return LoggingResult(events)
|
||||
|
||||
# Make run() find a result object on its own
|
||||
Foo('test').run()
|
||||
|
||||
expected = ['startTestRun', 'startTest', 'test', 'addSuccess',
|
||||
'stopTest', 'stopTestRun']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
def testShortDescriptionWithoutDocstring(self):
|
||||
self.assertIsNone(self.shortDescription())
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testShortDescriptionWithOneLineDocstring(self):
|
||||
"""Tests shortDescription() for a method with a docstring."""
|
||||
self.assertEqual(
|
||||
self.shortDescription(),
|
||||
'Tests shortDescription() for a method with a docstring.')
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testShortDescriptionWithMultiLineDocstring(self):
|
||||
"""Tests shortDescription() for a method with a longer docstring.
|
||||
|
||||
This method ensures that only the first line of a docstring is
|
||||
returned used in the short description, no matter how long the
|
||||
whole thing is.
|
||||
"""
|
||||
self.assertEqual(
|
||||
self.shortDescription(),
|
||||
'Tests shortDescription() for a method with a longer '
|
||||
'docstring.')
|
||||
|
||||
def testAddTypeEqualityFunc(self):
|
||||
class SadSnake(object):
|
||||
"""Dummy class for test_addTypeEqualityFunc."""
|
||||
s1, s2 = SadSnake(), SadSnake()
|
||||
self.assertNotEqual(s1, s2)
|
||||
def AllSnakesCreatedEqual(a, b, msg=None):
|
||||
return type(a) is type(b) is SadSnake
|
||||
self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
|
||||
self.assertEqual(s1, s2)
|
||||
# No this doesn't clean up and remove the SadSnake equality func
|
||||
# from this TestCase instance but since its a local nothing else
|
||||
# will ever notice that.
|
||||
|
||||
def testAssertIs(self):
|
||||
thing = object()
|
||||
self.assertIs(thing, thing)
|
||||
self.assertRaises(self.failureException, self.assertIs, thing, object())
|
||||
|
||||
def testAssertIsNot(self):
|
||||
thing = object()
|
||||
self.assertIsNot(thing, object())
|
||||
self.assertRaises(self.failureException, self.assertIsNot, thing, thing)
|
||||
|
||||
def testAssertIsInstance(self):
|
||||
thing = []
|
||||
self.assertIsInstance(thing, list)
|
||||
self.assertRaises(self.failureException, self.assertIsInstance,
|
||||
thing, dict)
|
||||
|
||||
def testAssertNotIsInstance(self):
|
||||
thing = []
|
||||
self.assertNotIsInstance(thing, dict)
|
||||
self.assertRaises(self.failureException, self.assertNotIsInstance,
|
||||
thing, list)
|
||||
|
||||
def testAssertIn(self):
|
||||
animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
|
||||
|
||||
self.assertIn('a', 'abc')
|
||||
self.assertIn(2, [1, 2, 3])
|
||||
self.assertIn('monkey', animals)
|
||||
|
||||
self.assertNotIn('d', 'abc')
|
||||
self.assertNotIn(0, [1, 2, 3])
|
||||
self.assertNotIn('otter', animals)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
|
||||
self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
|
||||
self.assertRaises(self.failureException, self.assertIn, 'elephant',
|
||||
animals)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3])
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 'cow',
|
||||
animals)
|
||||
|
||||
def testAssertDictContainsSubset(self):
|
||||
self.assertDictContainsSubset({}, {})
|
||||
self.assertDictContainsSubset({}, {'a': 1})
|
||||
self.assertDictContainsSubset({'a': 1}, {'a': 1})
|
||||
self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
|
||||
self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
|
||||
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({1: "one"}, {})
|
||||
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({'a': 2}, {'a': 1})
|
||||
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({'c': 1}, {'a': 1})
|
||||
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
|
||||
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
|
||||
|
||||
with test_support.check_warnings(("", UnicodeWarning)):
|
||||
one = ''.join(chr(i) for i in range(255))
|
||||
# this used to cause a UnicodeDecodeError constructing the failure msg
|
||||
with self.assertRaises(self.failureException):
|
||||
self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'})
|
||||
|
||||
def testAssertEqual(self):
|
||||
equal_pairs = [
|
||||
((), ()),
|
||||
({}, {}),
|
||||
([], []),
|
||||
(set(), set()),
|
||||
(frozenset(), frozenset())]
|
||||
for a, b in equal_pairs:
|
||||
# This mess of try excepts is to test the assertEqual behavior
|
||||
# itself.
|
||||
try:
|
||||
self.assertEqual(a, b)
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) failed' % (a, b))
|
||||
try:
|
||||
self.assertEqual(a, b, msg='foo')
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
|
||||
try:
|
||||
self.assertEqual(a, b, 'foo')
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) with third parameter failed' %
|
||||
(a, b))
|
||||
|
||||
unequal_pairs = [
|
||||
((), []),
|
||||
({}, set()),
|
||||
(set([4,1]), frozenset([4,2])),
|
||||
(frozenset([4,5]), set([2,3])),
|
||||
(set([3,4]), set([5,4]))]
|
||||
for a, b in unequal_pairs:
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b)
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b,
|
||||
'foo')
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b,
|
||||
msg='foo')
|
||||
|
||||
def testEquality(self):
|
||||
self.assertListEqual([], [])
|
||||
self.assertTupleEqual((), ())
|
||||
self.assertSequenceEqual([], ())
|
||||
|
||||
a = [0, 'a', []]
|
||||
b = []
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertListEqual, a, b)
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertListEqual, tuple(a), tuple(b))
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertSequenceEqual, a, tuple(b))
|
||||
|
||||
b.extend(a)
|
||||
self.assertListEqual(a, b)
|
||||
self.assertTupleEqual(tuple(a), tuple(b))
|
||||
self.assertSequenceEqual(a, tuple(b))
|
||||
self.assertSequenceEqual(tuple(a), b)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertListEqual,
|
||||
a, tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual,
|
||||
tuple(a), b)
|
||||
self.assertRaises(self.failureException, self.assertListEqual, None, b)
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual, None,
|
||||
tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertSequenceEqual,
|
||||
None, tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertSequenceEqual,
|
||||
1, 1)
|
||||
|
||||
self.assertDictEqual({}, {})
|
||||
|
||||
c = { 'x': 1 }
|
||||
d = {}
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictEqual, c, d)
|
||||
|
||||
d.update(c)
|
||||
self.assertDictEqual(c, d)
|
||||
|
||||
d['x'] = 0
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictEqual, c, d, 'These are unequal')
|
||||
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, None, d)
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, [], d)
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
|
||||
|
||||
def testAssertItemsEqual(self):
|
||||
a = object()
|
||||
self.assertItemsEqual([1, 2, 3], [3, 2, 1])
|
||||
self.assertItemsEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
|
||||
self.assertItemsEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2))
|
||||
self.assertItemsEqual([1, "2", "a", "a"], ["a", "2", True, "a"])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[1, 2] + [3] * 100, [1] * 100 + [2, 3])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[1, "2", "a", "a"], ["a", "2", True, 1])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[10], [10, 11])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[10, 11], [10])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[10, 11, 10], [10, 11])
|
||||
|
||||
# Test that sequences of unhashable objects can be tested for sameness:
|
||||
self.assertItemsEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]])
|
||||
with test_support.check_warnings(quiet=True) as w:
|
||||
# hashable types, but not orderable
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[], [divmod, 'x', 1, 5j, 2j, frozenset()])
|
||||
# comparing dicts raises a py3k warning
|
||||
self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
|
||||
# comparing heterogenous non-hashable sequences raises a py3k warning
|
||||
self.assertItemsEqual([1, 'x', divmod, []], [divmod, [], 'x', 1])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[], [divmod, [], 'x', 1, 5j, 2j, set()])
|
||||
# fail the test if warnings are not silenced
|
||||
if w.warnings:
|
||||
self.fail('assertItemsEqual raised a warning: ' +
|
||||
str(w.warnings[0]))
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[[1]], [[2]])
|
||||
|
||||
# Same elements, but not same sequence length
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[1, 1, 2], [2, 1])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[1, 1, "2", "a", "a"], ["2", "2", True, "a"])
|
||||
self.assertRaises(self.failureException, self.assertItemsEqual,
|
||||
[1, {'b': 2}, None, True], [{'b': 2}, True, None])
|
||||
|
||||
|
||||
def testAssertSetEqual(self):
|
||||
set1 = set()
|
||||
set2 = set()
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, None, set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, None)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set()
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set(['a'])
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set(['a', 'b'])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = frozenset(['a', 'b'])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a', 'b'])
|
||||
set2 = frozenset(['a', 'b'])
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
set1 = set()
|
||||
set2 = "foo"
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set2, set1)
|
||||
|
||||
# make sure any string formatting is tuple-safe
|
||||
set1 = set([(0, 1), (2, 3)])
|
||||
set2 = set([(4, 5)])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
def testInequality(self):
|
||||
# Try ints
|
||||
self.assertGreater(2, 1)
|
||||
self.assertGreaterEqual(2, 1)
|
||||
self.assertGreaterEqual(1, 1)
|
||||
self.assertLess(1, 2)
|
||||
self.assertLessEqual(1, 2)
|
||||
self.assertLessEqual(1, 1)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1, 2)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
|
||||
self.assertRaises(self.failureException, self.assertLess, 2, 1)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
|
||||
|
||||
# Try Floats
|
||||
self.assertGreater(1.1, 1.0)
|
||||
self.assertGreaterEqual(1.1, 1.0)
|
||||
self.assertGreaterEqual(1.0, 1.0)
|
||||
self.assertLess(1.0, 1.1)
|
||||
self.assertLessEqual(1.0, 1.1)
|
||||
self.assertLessEqual(1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0)
|
||||
|
||||
# Try Strings
|
||||
self.assertGreater('bug', 'ant')
|
||||
self.assertGreaterEqual('bug', 'ant')
|
||||
self.assertGreaterEqual('ant', 'ant')
|
||||
self.assertLess('ant', 'bug')
|
||||
self.assertLessEqual('ant', 'bug')
|
||||
self.assertLessEqual('ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant')
|
||||
|
||||
# Try Unicode
|
||||
self.assertGreater(u'bug', u'ant')
|
||||
self.assertGreaterEqual(u'bug', u'ant')
|
||||
self.assertGreaterEqual(u'ant', u'ant')
|
||||
self.assertLess(u'ant', u'bug')
|
||||
self.assertLessEqual(u'ant', u'bug')
|
||||
self.assertLessEqual(u'ant', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, u'ant', u'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, u'ant', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant',
|
||||
u'bug')
|
||||
self.assertRaises(self.failureException, self.assertLess, u'bug', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, u'ant', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, u'bug', u'ant')
|
||||
|
||||
# Try Mixed String/Unicode
|
||||
self.assertGreater('bug', u'ant')
|
||||
self.assertGreater(u'bug', 'ant')
|
||||
self.assertGreaterEqual('bug', u'ant')
|
||||
self.assertGreaterEqual(u'bug', 'ant')
|
||||
self.assertGreaterEqual('ant', u'ant')
|
||||
self.assertGreaterEqual(u'ant', 'ant')
|
||||
self.assertLess('ant', u'bug')
|
||||
self.assertLess(u'ant', 'bug')
|
||||
self.assertLessEqual('ant', u'bug')
|
||||
self.assertLessEqual(u'ant', 'bug')
|
||||
self.assertLessEqual('ant', u'ant')
|
||||
self.assertLessEqual(u'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', u'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, u'ant', 'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, u'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant',
|
||||
u'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant',
|
||||
'bug')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, u'bug', 'ant')
|
||||
|
||||
def testAssertMultiLineEqual(self):
|
||||
sample_text = b"""\
|
||||
http://www.python.org/doc/2.3/lib/module-unittest.html
|
||||
test case
|
||||
A test case is the smallest unit of testing. [...]
|
||||
"""
|
||||
revised_sample_text = b"""\
|
||||
http://www.python.org/doc/2.4.1/lib/module-unittest.html
|
||||
test case
|
||||
A test case is the smallest unit of testing. [...] You may provide your
|
||||
own implementation that does not subclass from TestCase, of course.
|
||||
"""
|
||||
sample_text_error = b"""
|
||||
- http://www.python.org/doc/2.3/lib/module-unittest.html
|
||||
? ^
|
||||
+ http://www.python.org/doc/2.4.1/lib/module-unittest.html
|
||||
? ^^^
|
||||
test case
|
||||
- A test case is the smallest unit of testing. [...]
|
||||
+ A test case is the smallest unit of testing. [...] You may provide your
|
||||
? +++++++++++++++++++++
|
||||
+ own implementation that does not subclass from TestCase, of course.
|
||||
"""
|
||||
|
||||
for type_changer in (lambda x: x, lambda x: x.decode('utf8')):
|
||||
try:
|
||||
self.assertMultiLineEqual(type_changer(sample_text),
|
||||
type_changer(revised_sample_text))
|
||||
except self.failureException, e:
|
||||
# assertMultiLineEqual is hooked up as the default for
|
||||
# unicode strings - so we can't use it for this check
|
||||
self.assertTrue(sample_text_error == str(e).encode('utf8'))
|
||||
|
||||
def testAssertIsNone(self):
|
||||
self.assertIsNone(None)
|
||||
self.assertRaises(self.failureException, self.assertIsNone, False)
|
||||
self.assertIsNotNone('DjZoPloGears on Rails')
|
||||
self.assertRaises(self.failureException, self.assertIsNotNone, None)
|
||||
|
||||
def testAssertRegexpMatches(self):
|
||||
self.assertRegexpMatches('asdfabasdf', r'ab+')
|
||||
self.assertRaises(self.failureException, self.assertRegexpMatches,
|
||||
'saaas', r'aaaa')
|
||||
|
||||
def testAssertRaisesRegexp(self):
|
||||
class ExceptionMock(Exception):
|
||||
pass
|
||||
|
||||
def Stub():
|
||||
raise ExceptionMock('We expect')
|
||||
|
||||
self.assertRaisesRegexp(ExceptionMock, re.compile('expect$'), Stub)
|
||||
self.assertRaisesRegexp(ExceptionMock, 'expect$', Stub)
|
||||
self.assertRaisesRegexp(ExceptionMock, u'expect$', Stub)
|
||||
|
||||
def testAssertNotRaisesRegexp(self):
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException, '^Exception not raised$',
|
||||
self.assertRaisesRegexp, Exception, re.compile('x'),
|
||||
lambda: None)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException, '^Exception not raised$',
|
||||
self.assertRaisesRegexp, Exception, 'x',
|
||||
lambda: None)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException, '^Exception not raised$',
|
||||
self.assertRaisesRegexp, Exception, u'x',
|
||||
lambda: None)
|
||||
|
||||
def testAssertRaisesRegexpMismatch(self):
|
||||
def Stub():
|
||||
raise Exception('Unexpected')
|
||||
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException,
|
||||
r'"\^Expected\$" does not match "Unexpected"',
|
||||
self.assertRaisesRegexp, Exception, '^Expected$',
|
||||
Stub)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException,
|
||||
r'"\^Expected\$" does not match "Unexpected"',
|
||||
self.assertRaisesRegexp, Exception, u'^Expected$',
|
||||
Stub)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException,
|
||||
r'"\^Expected\$" does not match "Unexpected"',
|
||||
self.assertRaisesRegexp, Exception,
|
||||
re.compile('^Expected$'), Stub)
|
||||
|
||||
def testAssertRaisesExcValue(self):
|
||||
class ExceptionMock(Exception):
|
||||
pass
|
||||
|
||||
def Stub(foo):
|
||||
raise ExceptionMock(foo)
|
||||
v = "particular value"
|
||||
|
||||
ctx = self.assertRaises(ExceptionMock)
|
||||
with ctx:
|
||||
Stub(v)
|
||||
e = ctx.exception
|
||||
self.assertIsInstance(e, ExceptionMock)
|
||||
self.assertEqual(e.args[0], v)
|
||||
|
||||
def testSynonymAssertMethodNames(self):
|
||||
"""Test undocumented method name synonyms.
|
||||
|
||||
Please do not use these methods names in your own code.
|
||||
|
||||
This test confirms their continued existence and functionality
|
||||
in order to avoid breaking existing code.
|
||||
"""
|
||||
self.assertNotEquals(3, 5)
|
||||
self.assertEquals(3, 3)
|
||||
self.assertAlmostEquals(2.0, 2.0)
|
||||
self.assertNotAlmostEquals(3.0, 5.0)
|
||||
self.assert_(True)
|
||||
|
||||
def testPendingDeprecationMethodNames(self):
|
||||
"""Test fail* methods pending deprecation, they will warn in 3.2.
|
||||
|
||||
Do not use these methods. They will go away in 3.3.
|
||||
"""
|
||||
with test_support.check_warnings():
|
||||
self.failIfEqual(3, 5)
|
||||
self.failUnlessEqual(3, 3)
|
||||
self.failUnlessAlmostEqual(2.0, 2.0)
|
||||
self.failIfAlmostEqual(3.0, 5.0)
|
||||
self.failUnless(True)
|
||||
self.failUnlessRaises(TypeError, lambda _: 3.14 + u'spam')
|
||||
self.failIf(False)
|
||||
|
||||
def testDeepcopy(self):
|
||||
# Issue: 5660
|
||||
class TestableTest(unittest.TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
|
||||
# This shouldn't blow up
|
||||
deepcopy(test)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,293 @@
|
|||
import os
|
||||
import sys
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
class TestDiscovery(unittest.TestCase):
|
||||
|
||||
# Heavily mocked tests so I can avoid hitting the filesystem
|
||||
def test_get_name_from_path(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
loader._top_level_dir = '/foo'
|
||||
name = loader._get_name_from_path('/foo/bar/baz.py')
|
||||
self.assertEqual(name, 'bar.baz')
|
||||
|
||||
if not __debug__:
|
||||
# asserts are off
|
||||
return
|
||||
|
||||
with self.assertRaises(AssertionError):
|
||||
loader._get_name_from_path('/bar/baz.py')
|
||||
|
||||
def test_find_tests(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_listdir = os.listdir
|
||||
def restore_listdir():
|
||||
os.listdir = original_listdir
|
||||
original_isfile = os.path.isfile
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
original_isdir = os.path.isdir
|
||||
def restore_isdir():
|
||||
os.path.isdir = original_isdir
|
||||
|
||||
path_lists = [['test1.py', 'test2.py', 'not_a_test.py', 'test_dir',
|
||||
'test.foo', 'test-not-a-module.py', 'another_dir'],
|
||||
['test3.py', 'test4.py', ]]
|
||||
os.listdir = lambda path: path_lists.pop(0)
|
||||
self.addCleanup(restore_listdir)
|
||||
|
||||
def isdir(path):
|
||||
return path.endswith('dir')
|
||||
os.path.isdir = isdir
|
||||
self.addCleanup(restore_isdir)
|
||||
|
||||
def isfile(path):
|
||||
# another_dir is not a package and so shouldn't be recursed into
|
||||
return not path.endswith('dir') and not 'another_dir' in path
|
||||
os.path.isfile = isfile
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
loader._get_module_from_name = lambda path: path + ' module'
|
||||
loader.loadTestsFromModule = lambda module: module + ' tests'
|
||||
|
||||
loader._top_level_dir = '/foo'
|
||||
suite = list(loader._find_tests('/foo', 'test*.py'))
|
||||
|
||||
expected = [name + ' module tests' for name in
|
||||
('test1', 'test2')]
|
||||
expected.extend([('test_dir.%s' % name) + ' module tests' for name in
|
||||
('test3', 'test4')])
|
||||
self.assertEqual(suite, expected)
|
||||
|
||||
def test_find_tests_with_package(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_listdir = os.listdir
|
||||
def restore_listdir():
|
||||
os.listdir = original_listdir
|
||||
original_isfile = os.path.isfile
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
original_isdir = os.path.isdir
|
||||
def restore_isdir():
|
||||
os.path.isdir = original_isdir
|
||||
|
||||
directories = ['a_directory', 'test_directory', 'test_directory2']
|
||||
path_lists = [directories, [], [], []]
|
||||
os.listdir = lambda path: path_lists.pop(0)
|
||||
self.addCleanup(restore_listdir)
|
||||
|
||||
os.path.isdir = lambda path: True
|
||||
self.addCleanup(restore_isdir)
|
||||
|
||||
os.path.isfile = lambda path: os.path.basename(path) not in directories
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
class Module(object):
|
||||
paths = []
|
||||
load_tests_args = []
|
||||
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.paths.append(path)
|
||||
if os.path.basename(path) == 'test_directory':
|
||||
def load_tests(loader, tests, pattern):
|
||||
self.load_tests_args.append((loader, tests, pattern))
|
||||
return 'load_tests'
|
||||
self.load_tests = load_tests
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.path == other.path
|
||||
|
||||
# Silence py3k warning
|
||||
__hash__ = None
|
||||
|
||||
loader._get_module_from_name = lambda name: Module(name)
|
||||
def loadTestsFromModule(module, use_load_tests):
|
||||
if use_load_tests:
|
||||
raise self.failureException('use_load_tests should be False for packages')
|
||||
return module.path + ' module tests'
|
||||
loader.loadTestsFromModule = loadTestsFromModule
|
||||
|
||||
loader._top_level_dir = '/foo'
|
||||
# this time no '.py' on the pattern so that it can match
|
||||
# a test package
|
||||
suite = list(loader._find_tests('/foo', 'test*'))
|
||||
|
||||
# We should have loaded tests from the test_directory package by calling load_tests
|
||||
# and directly from the test_directory2 package
|
||||
self.assertEqual(suite,
|
||||
['load_tests', 'test_directory2' + ' module tests'])
|
||||
self.assertEqual(Module.paths, ['test_directory', 'test_directory2'])
|
||||
|
||||
# load_tests should have been called once with loader, tests and pattern
|
||||
self.assertEqual(Module.load_tests_args,
|
||||
[(loader, 'test_directory' + ' module tests', 'test*')])
|
||||
|
||||
def test_discover(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_isfile = os.path.isfile
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
|
||||
os.path.isfile = lambda path: False
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
orig_sys_path = sys.path[:]
|
||||
def restore_path():
|
||||
sys.path[:] = orig_sys_path
|
||||
self.addCleanup(restore_path)
|
||||
|
||||
full_path = os.path.abspath(os.path.normpath('/foo'))
|
||||
with self.assertRaises(ImportError):
|
||||
loader.discover('/foo/bar', top_level_dir='/foo')
|
||||
|
||||
self.assertEqual(loader._top_level_dir, full_path)
|
||||
self.assertIn(full_path, sys.path)
|
||||
|
||||
os.path.isfile = lambda path: True
|
||||
_find_tests_args = []
|
||||
def _find_tests(start_dir, pattern):
|
||||
_find_tests_args.append((start_dir, pattern))
|
||||
return ['tests']
|
||||
loader._find_tests = _find_tests
|
||||
loader.suiteClass = str
|
||||
|
||||
suite = loader.discover('/foo/bar/baz', 'pattern', '/foo/bar')
|
||||
|
||||
top_level_dir = os.path.abspath(os.path.normpath('/foo/bar'))
|
||||
start_dir = os.path.abspath(os.path.normpath('/foo/bar/baz'))
|
||||
self.assertEqual(suite, "['tests']")
|
||||
self.assertEqual(loader._top_level_dir, top_level_dir)
|
||||
self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
|
||||
self.assertIn(top_level_dir, sys.path)
|
||||
|
||||
def test_discover_with_modules_that_fail_to_import(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
listdir = os.listdir
|
||||
os.listdir = lambda _: ['test_this_does_not_exist.py']
|
||||
isfile = os.path.isfile
|
||||
os.path.isfile = lambda _: True
|
||||
orig_sys_path = sys.path[:]
|
||||
def restore():
|
||||
os.path.isfile = isfile
|
||||
os.listdir = listdir
|
||||
sys.path[:] = orig_sys_path
|
||||
self.addCleanup(restore)
|
||||
|
||||
suite = loader.discover('.')
|
||||
self.assertIn(os.getcwd(), sys.path)
|
||||
self.assertEqual(suite.countTestCases(), 1)
|
||||
test = list(list(suite)[0])[0] # extract test from suite
|
||||
|
||||
with self.assertRaises(ImportError):
|
||||
test.test_this_does_not_exist()
|
||||
|
||||
def test_command_line_handling_parseArgs(self):
|
||||
# Haha - take that uninstantiable class
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
|
||||
args = []
|
||||
def do_discovery(argv):
|
||||
args.extend(argv)
|
||||
program._do_discovery = do_discovery
|
||||
program.parseArgs(['something', 'discover'])
|
||||
self.assertEqual(args, [])
|
||||
|
||||
program.parseArgs(['something', 'discover', 'foo', 'bar'])
|
||||
self.assertEqual(args, ['foo', 'bar'])
|
||||
|
||||
def test_command_line_handling_do_discovery_too_many_arguments(self):
|
||||
class Stop(Exception):
|
||||
pass
|
||||
def usageExit():
|
||||
raise Stop
|
||||
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program.usageExit = usageExit
|
||||
|
||||
with self.assertRaises(Stop):
|
||||
# too many args
|
||||
program._do_discovery(['one', 'two', 'three', 'four'])
|
||||
|
||||
|
||||
def test_command_line_handling_do_discovery_calls_loader(self):
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
|
||||
class Loader(object):
|
||||
args = []
|
||||
def discover(self, start_dir, pattern, top_level_dir):
|
||||
self.args.append((start_dir, pattern, top_level_dir))
|
||||
return 'tests'
|
||||
|
||||
program._do_discovery(['-v'], Loader=Loader)
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['--verbose'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery([], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish', 'eggs'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish', 'eggs', 'ham'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', 'ham')])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-s', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-t', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', 'fish')])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-p', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'fish', None)])
|
||||
self.assertFalse(program.failfast)
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-p', 'eggs', '-s', 'fish', '-v', '-f'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', None)])
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
self.assertTrue(program.failfast)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
import unittest
|
||||
|
||||
from .support import LoggingResult
|
||||
|
||||
|
||||
class Test_FunctionTestCase(unittest.TestCase):
|
||||
|
||||
# "Return the number of tests represented by the this test object. For
|
||||
# TestCase instances, this will always be 1"
|
||||
def test_countTestCases(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertEqual(test.countTestCases(), 1)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if setUp() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_setUp(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
raise RuntimeError('raised by setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'addError', 'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test raises
|
||||
# an error (as opposed to a failure).
|
||||
def test_run_call_order__error_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
raise RuntimeError('raised by test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test signals
|
||||
# a failure (as opposed to an error).
|
||||
def test_run_call_order__failure_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
self.fail('raised by test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if tearDown() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_tearDown(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
raise RuntimeError('raised by tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "Return a string identifying the specific test case."
|
||||
#
|
||||
# Because of the vague nature of the docs, I'm not going to lock this
|
||||
# test down too much. Really all that can be asserted is that the id()
|
||||
# will be a string (either 8-byte or unicode -- again, because the docs
|
||||
# just say "string")
|
||||
def test_id(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertIsInstance(test.id(), basestring)
|
||||
|
||||
# "Returns a one-line description of the test, or None if no description
|
||||
# has been provided. The default implementation of this method returns
|
||||
# the first line of the test method's docstring, if available, or None."
|
||||
def test_shortDescription__no_docstring(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertEqual(test.shortDescription(), None)
|
||||
|
||||
# "Returns a one-line description of the test, or None if no description
|
||||
# has been provided. The default implementation of this method returns
|
||||
# the first line of the test method's docstring, if available, or None."
|
||||
def test_shortDescription__singleline_docstring(self):
|
||||
desc = "this tests foo"
|
||||
test = unittest.FunctionTestCase(lambda: None, description=desc)
|
||||
|
||||
self.assertEqual(test.shortDescription(), "this tests foo")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,78 @@
|
|||
from cStringIO import StringIO
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
class Test_TestProgram(unittest.TestCase):
|
||||
|
||||
# Horrible white box test
|
||||
def testNoExit(self):
|
||||
result = object()
|
||||
test = object()
|
||||
|
||||
class FakeRunner(object):
|
||||
def run(self, test):
|
||||
self.test = test
|
||||
return result
|
||||
|
||||
runner = FakeRunner()
|
||||
|
||||
oldParseArgs = unittest.TestProgram.parseArgs
|
||||
def restoreParseArgs():
|
||||
unittest.TestProgram.parseArgs = oldParseArgs
|
||||
unittest.TestProgram.parseArgs = lambda *args: None
|
||||
self.addCleanup(restoreParseArgs)
|
||||
|
||||
def removeTest():
|
||||
del unittest.TestProgram.test
|
||||
unittest.TestProgram.test = test
|
||||
self.addCleanup(removeTest)
|
||||
|
||||
program = unittest.TestProgram(testRunner=runner, exit=False, verbosity=2)
|
||||
|
||||
self.assertEqual(program.result, result)
|
||||
self.assertEqual(runner.test, test)
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
|
||||
class FooBar(unittest.TestCase):
|
||||
def testPass(self):
|
||||
assert True
|
||||
def testFail(self):
|
||||
assert False
|
||||
|
||||
class FooBarLoader(unittest.TestLoader):
|
||||
"""Test loader that returns a suite containing FooBar."""
|
||||
def loadTestsFromModule(self, module):
|
||||
return self.suiteClass(
|
||||
[self.loadTestsFromTestCase(Test_TestProgram.FooBar)])
|
||||
|
||||
|
||||
def test_NonExit(self):
|
||||
program = unittest.main(exit=False,
|
||||
argv=["foobar"],
|
||||
testRunner=unittest.TextTestRunner(stream=StringIO()),
|
||||
testLoader=self.FooBarLoader())
|
||||
self.assertTrue(hasattr(program, 'result'))
|
||||
|
||||
|
||||
def test_Exit(self):
|
||||
self.assertRaises(
|
||||
SystemExit,
|
||||
unittest.main,
|
||||
argv=["foobar"],
|
||||
testRunner=unittest.TextTestRunner(stream=StringIO()),
|
||||
exit=True,
|
||||
testLoader=self.FooBarLoader())
|
||||
|
||||
|
||||
def test_ExitAsDefault(self):
|
||||
self.assertRaises(
|
||||
SystemExit,
|
||||
unittest.main,
|
||||
argv=["foobar"],
|
||||
testRunner=unittest.TextTestRunner(stream=StringIO()),
|
||||
testLoader=self.FooBarLoader())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,359 @@
|
|||
import sys
|
||||
from cStringIO import StringIO
|
||||
from test import test_support
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
class Test_TestResult(unittest.TestCase):
|
||||
# Note: there are not separate tests for TestResult.wasSuccessful(),
|
||||
# TestResult.errors, TestResult.failures, TestResult.testsRun or
|
||||
# TestResult.shouldStop because these only have meaning in terms of
|
||||
# other TestResult methods.
|
||||
#
|
||||
# Accordingly, tests for the aforenamed attributes are incorporated
|
||||
# in with the tests for the defining methods.
|
||||
################################################################
|
||||
|
||||
def test_init(self):
|
||||
result = unittest.TestResult()
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
# "This method can be called to signal that the set of tests being
|
||||
# run should be aborted by setting the TestResult's shouldStop
|
||||
# attribute to True."
|
||||
def test_stop(self):
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.stop()
|
||||
|
||||
self.assertEqual(result.shouldStop, True)
|
||||
|
||||
# "Called when the test case test is about to be run. The default
|
||||
# implementation simply increments the instance's testsRun counter."
|
||||
def test_startTest(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
result.stopTest(test)
|
||||
|
||||
# "Called after the test case test has been executed, regardless of
|
||||
# the outcome. The default implementation does nothing."
|
||||
def test_stopTest(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
result.stopTest(test)
|
||||
|
||||
# Same tests as above; make sure nothing has changed
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
# "Called before and after tests are run. The default implementation does nothing."
|
||||
def test_startTestRun_stopTestRun(self):
|
||||
result = unittest.TestResult()
|
||||
result.startTestRun()
|
||||
result.stopTestRun()
|
||||
|
||||
# "addSuccess(test)"
|
||||
# ...
|
||||
# "Called when the test case test succeeds"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addSuccess(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addSuccess(test)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
# "addFailure(test, err)"
|
||||
# ...
|
||||
# "Called when the test case test signals a failure. err is a tuple of
|
||||
# the form returned by sys.exc_info(): (type, value, traceback)"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addFailure(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
try:
|
||||
test.fail("foo")
|
||||
except:
|
||||
exc_info_tuple = sys.exc_info()
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addFailure(test, exc_info_tuple)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertFalse(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 1)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
test_case, formatted_exc = result.failures[0]
|
||||
self.assertTrue(test_case is test)
|
||||
self.assertIsInstance(formatted_exc, str)
|
||||
|
||||
# "addError(test, err)"
|
||||
# ...
|
||||
# "Called when the test case test raises an unexpected exception err
|
||||
# is a tuple of the form returned by sys.exc_info():
|
||||
# (type, value, traceback)"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addError(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
try:
|
||||
raise TypeError()
|
||||
except:
|
||||
exc_info_tuple = sys.exc_info()
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addError(test, exc_info_tuple)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertFalse(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
test_case, formatted_exc = result.errors[0]
|
||||
self.assertTrue(test_case is test)
|
||||
self.assertIsInstance(formatted_exc, str)
|
||||
|
||||
def testGetDescriptionWithoutDocstring(self):
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
'testGetDescriptionWithoutDocstring (' + __name__ +
|
||||
'.Test_TestResult)')
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testGetDescriptionWithOneLineDocstring(self):
|
||||
"""Tests getDescription() for a method with a docstring."""
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
('testGetDescriptionWithOneLineDocstring '
|
||||
'(' + __name__ + '.Test_TestResult)\n'
|
||||
'Tests getDescription() for a method with a docstring.'))
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testGetDescriptionWithMultiLineDocstring(self):
|
||||
"""Tests getDescription() for a method with a longer docstring.
|
||||
The second line of the docstring.
|
||||
"""
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
('testGetDescriptionWithMultiLineDocstring '
|
||||
'(' + __name__ + '.Test_TestResult)\n'
|
||||
'Tests getDescription() for a method with a longer '
|
||||
'docstring.'))
|
||||
|
||||
def testStackFrameTrimming(self):
|
||||
class Frame(object):
|
||||
class tb_frame(object):
|
||||
f_globals = {}
|
||||
result = unittest.TestResult()
|
||||
self.assertFalse(result._is_relevant_tb_level(Frame))
|
||||
|
||||
Frame.tb_frame.f_globals['__unittest'] = True
|
||||
self.assertTrue(result._is_relevant_tb_level(Frame))
|
||||
|
||||
def testFailFast(self):
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addError(None, None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addFailure(None, None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addUnexpectedSuccess(None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
def testFailFastSetByRunner(self):
|
||||
runner = unittest.TextTestRunner(stream=StringIO(), failfast=True)
|
||||
def test(result):
|
||||
self.assertTrue(result.failfast)
|
||||
runner.run(test)
|
||||
|
||||
|
||||
classDict = dict(unittest.TestResult.__dict__)
|
||||
for m in ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess',
|
||||
'__init__'):
|
||||
del classDict[m]
|
||||
|
||||
def __init__(self, stream=None, descriptions=None, verbosity=None):
|
||||
self.failures = []
|
||||
self.errors = []
|
||||
self.testsRun = 0
|
||||
self.shouldStop = False
|
||||
classDict['__init__'] = __init__
|
||||
OldResult = type('OldResult', (object,), classDict)
|
||||
|
||||
class Test_OldTestResult(unittest.TestCase):
|
||||
|
||||
def assertOldResultWarning(self, test, failures):
|
||||
with test_support.check_warnings(("TestResult has no add.+ method,",
|
||||
RuntimeWarning)):
|
||||
result = OldResult()
|
||||
test.run(result)
|
||||
self.assertEqual(len(result.failures), failures)
|
||||
|
||||
def testOldTestResult(self):
|
||||
class Test(unittest.TestCase):
|
||||
def testSkip(self):
|
||||
self.skipTest('foobar')
|
||||
@unittest.expectedFailure
|
||||
def testExpectedFail(self):
|
||||
raise TypeError
|
||||
@unittest.expectedFailure
|
||||
def testUnexpectedSuccess(self):
|
||||
pass
|
||||
|
||||
for test_name, should_pass in (('testSkip', True),
|
||||
('testExpectedFail', True),
|
||||
('testUnexpectedSuccess', False)):
|
||||
test = Test(test_name)
|
||||
self.assertOldResultWarning(test, int(not should_pass))
|
||||
|
||||
def testOldTestTesultSetup(self):
|
||||
class Test(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.skipTest('no reason')
|
||||
def testFoo(self):
|
||||
pass
|
||||
self.assertOldResultWarning(Test('testFoo'), 0)
|
||||
|
||||
def testOldTestResultClass(self):
|
||||
@unittest.skip('no reason')
|
||||
class Test(unittest.TestCase):
|
||||
def testFoo(self):
|
||||
pass
|
||||
self.assertOldResultWarning(Test('testFoo'), 0)
|
||||
|
||||
def testOldResultWithRunner(self):
|
||||
class Test(unittest.TestCase):
|
||||
def testFoo(self):
|
||||
pass
|
||||
runner = unittest.TextTestRunner(resultclass=OldResult,
|
||||
stream=StringIO())
|
||||
# This will raise an exception if TextTestRunner can't handle old
|
||||
# test result objects
|
||||
runner.run(Test('testFoo'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,182 @@
|
|||
import unittest
|
||||
|
||||
from cStringIO import StringIO
|
||||
import pickle
|
||||
|
||||
from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun
|
||||
|
||||
|
||||
class TestCleanUp(unittest.TestCase):
|
||||
|
||||
def testCleanUp(self):
|
||||
class TestableTest(unittest.TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
self.assertEqual(test._cleanups, [])
|
||||
|
||||
cleanups = []
|
||||
|
||||
def cleanup1(*args, **kwargs):
|
||||
cleanups.append((1, args, kwargs))
|
||||
|
||||
def cleanup2(*args, **kwargs):
|
||||
cleanups.append((2, args, kwargs))
|
||||
|
||||
test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
self.assertEqual(test._cleanups,
|
||||
[(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),
|
||||
(cleanup2, (), {})])
|
||||
|
||||
result = test.doCleanups()
|
||||
self.assertTrue(result)
|
||||
|
||||
self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3),
|
||||
dict(four='hello', five='goodbye'))])
|
||||
|
||||
def testCleanUpWithErrors(self):
|
||||
class TestableTest(unittest.TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
class MockResult(object):
|
||||
errors = []
|
||||
def addError(self, test, exc_info):
|
||||
self.errors.append((test, exc_info))
|
||||
|
||||
result = MockResult()
|
||||
test = TestableTest('testNothing')
|
||||
test._resultForDoCleanups = result
|
||||
|
||||
exc1 = Exception('foo')
|
||||
exc2 = Exception('bar')
|
||||
def cleanup1():
|
||||
raise exc1
|
||||
|
||||
def cleanup2():
|
||||
raise exc2
|
||||
|
||||
test.addCleanup(cleanup1)
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
self.assertFalse(test.doCleanups())
|
||||
|
||||
(test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors)
|
||||
self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))
|
||||
self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))
|
||||
|
||||
def testCleanupInRun(self):
|
||||
blowUp = False
|
||||
ordering = []
|
||||
|
||||
class TestableTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
ordering.append('setUp')
|
||||
if blowUp:
|
||||
raise Exception('foo')
|
||||
|
||||
def testNothing(self):
|
||||
ordering.append('test')
|
||||
|
||||
def tearDown(self):
|
||||
ordering.append('tearDown')
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
|
||||
def cleanup1():
|
||||
ordering.append('cleanup1')
|
||||
def cleanup2():
|
||||
ordering.append('cleanup2')
|
||||
test.addCleanup(cleanup1)
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
def success(some_test):
|
||||
self.assertEqual(some_test, test)
|
||||
ordering.append('success')
|
||||
|
||||
result = unittest.TestResult()
|
||||
result.addSuccess = success
|
||||
|
||||
test.run(result)
|
||||
self.assertEqual(ordering, ['setUp', 'test', 'tearDown',
|
||||
'cleanup2', 'cleanup1', 'success'])
|
||||
|
||||
blowUp = True
|
||||
ordering = []
|
||||
test = TestableTest('testNothing')
|
||||
test.addCleanup(cleanup1)
|
||||
test.run(result)
|
||||
self.assertEqual(ordering, ['setUp', 'cleanup1'])
|
||||
|
||||
|
||||
class Test_TextTestRunner(unittest.TestCase):
|
||||
"""Tests for TextTestRunner."""
|
||||
|
||||
def test_works_with_result_without_startTestRun_stopTestRun(self):
|
||||
class OldTextResult(ResultWithNoStartTestRunStopTestRun):
|
||||
separator2 = ''
|
||||
def printErrors(self):
|
||||
pass
|
||||
|
||||
class Runner(unittest.TextTestRunner):
|
||||
def __init__(self):
|
||||
super(Runner, self).__init__(StringIO())
|
||||
|
||||
def _makeResult(self):
|
||||
return OldTextResult()
|
||||
|
||||
runner = Runner()
|
||||
runner.run(unittest.TestSuite())
|
||||
|
||||
def test_startTestRun_stopTestRun_called(self):
|
||||
class LoggingTextResult(LoggingResult):
|
||||
separator2 = ''
|
||||
def printErrors(self):
|
||||
pass
|
||||
|
||||
class LoggingRunner(unittest.TextTestRunner):
|
||||
def __init__(self, events):
|
||||
super(LoggingRunner, self).__init__(StringIO())
|
||||
self._events = events
|
||||
|
||||
def _makeResult(self):
|
||||
return LoggingTextResult(self._events)
|
||||
|
||||
events = []
|
||||
runner = LoggingRunner(events)
|
||||
runner.run(unittest.TestSuite())
|
||||
expected = ['startTestRun', 'stopTestRun']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
def test_pickle_unpickle(self):
|
||||
# Issue #7197: a TextTestRunner should be (un)pickleable. This is
|
||||
# required by test_multiprocessing under Windows (in verbose mode).
|
||||
from StringIO import StringIO as PickleableIO
|
||||
# cStringIO objects are not pickleable, but StringIO objects are.
|
||||
stream = PickleableIO("foo")
|
||||
runner = unittest.TextTestRunner(stream)
|
||||
for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
|
||||
s = pickle.dumps(runner, protocol=protocol)
|
||||
obj = pickle.loads(s)
|
||||
# StringIO objects never compare equal, a cheap test instead.
|
||||
self.assertEqual(obj.stream.getvalue(), stream.getvalue())
|
||||
|
||||
def test_resultclass(self):
|
||||
def MockResultClass(*args):
|
||||
return args
|
||||
STREAM = object()
|
||||
DESCRIPTIONS = object()
|
||||
VERBOSITY = object()
|
||||
runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,
|
||||
resultclass=MockResultClass)
|
||||
self.assertEqual(runner.resultclass, MockResultClass)
|
||||
|
||||
expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
|
||||
self.assertEqual(runner._makeResult(), expectedresult)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,405 @@
|
|||
import sys
|
||||
|
||||
from cStringIO import StringIO
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
def resultFactory(*_):
|
||||
return unittest.TestResult()
|
||||
|
||||
|
||||
class TestSetups(unittest.TestCase):
|
||||
|
||||
def getRunner(self):
|
||||
return unittest.TextTestRunner(resultclass=resultFactory,
|
||||
stream=StringIO())
|
||||
def runTests(self, *cases):
|
||||
suite = unittest.TestSuite()
|
||||
for case in cases:
|
||||
tests = unittest.defaultTestLoader.loadTestsFromTestCase(case)
|
||||
suite.addTests(tests)
|
||||
|
||||
runner = self.getRunner()
|
||||
|
||||
# creating a nested suite exposes some potential bugs
|
||||
realSuite = unittest.TestSuite()
|
||||
realSuite.addTest(suite)
|
||||
# adding empty suites to the end exposes potential bugs
|
||||
suite.addTest(unittest.TestSuite())
|
||||
realSuite.addTest(unittest.TestSuite())
|
||||
return runner.run(realSuite)
|
||||
|
||||
def test_setup_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
setUpCalled = 0
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.setUpCalled += 1
|
||||
unittest.TestCase.setUpClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test)
|
||||
|
||||
self.assertEqual(Test.setUpCalled, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_teardown_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test)
|
||||
|
||||
self.assertEqual(Test.tearDownCalled, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_teardown_class_two_classes(self):
|
||||
class Test(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test2.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
|
||||
self.assertEqual(Test.tearDownCalled, 1)
|
||||
self.assertEqual(Test2.tearDownCalled, 1)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_setupclass(self):
|
||||
class BrokenTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(BrokenTest)
|
||||
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error),
|
||||
'classSetUp (%s.BrokenTest)' % __name__)
|
||||
|
||||
def test_error_in_teardown_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
tornDown = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown += 1
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
tornDown = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test2.tornDown += 1
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertEqual(len(result.errors), 2)
|
||||
self.assertEqual(Test.tornDown, 1)
|
||||
self.assertEqual(Test2.tornDown, 1)
|
||||
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error),
|
||||
'classTearDown (%s.Test)' % __name__)
|
||||
|
||||
def test_class_not_torndown_when_setup_fails(self):
|
||||
class Test(unittest.TestCase):
|
||||
tornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
raise TypeError
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown = True
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
|
||||
self.runTests(Test)
|
||||
self.assertFalse(Test.tornDown)
|
||||
|
||||
def test_class_not_setup_or_torndown_when_skipped(self):
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
tornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
|
||||
Test = unittest.skip("hop")(Test)
|
||||
self.runTests(Test)
|
||||
self.assertFalse(Test.classSetUp)
|
||||
self.assertFalse(Test.tornDown)
|
||||
|
||||
def test_setup_teardown_order_with_pathological_suite(self):
|
||||
results = []
|
||||
|
||||
class Module1(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
results.append('Module1.setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
results.append('Module1.tearDownModule')
|
||||
|
||||
class Module2(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
results.append('Module2.setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
results.append('Module2.tearDownModule')
|
||||
|
||||
class Test1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 1')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 1')
|
||||
def testOne(self):
|
||||
results.append('Test1.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test1.testTwo')
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 2')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 2')
|
||||
def testOne(self):
|
||||
results.append('Test2.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test2.testTwo')
|
||||
|
||||
class Test3(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 3')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 3')
|
||||
def testOne(self):
|
||||
results.append('Test3.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test3.testTwo')
|
||||
|
||||
Test1.__module__ = Test2.__module__ = 'Module'
|
||||
Test3.__module__ = 'Module2'
|
||||
sys.modules['Module'] = Module1
|
||||
sys.modules['Module2'] = Module2
|
||||
|
||||
first = unittest.TestSuite((Test1('testOne'),))
|
||||
second = unittest.TestSuite((Test1('testTwo'),))
|
||||
third = unittest.TestSuite((Test2('testOne'),))
|
||||
fourth = unittest.TestSuite((Test2('testTwo'),))
|
||||
fifth = unittest.TestSuite((Test3('testOne'),))
|
||||
sixth = unittest.TestSuite((Test3('testTwo'),))
|
||||
suite = unittest.TestSuite((first, second, third, fourth, fifth, sixth))
|
||||
|
||||
runner = self.getRunner()
|
||||
result = runner.run(suite)
|
||||
self.assertEqual(result.testsRun, 6)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
self.assertEqual(results,
|
||||
['Module1.setUpModule', 'setup 1',
|
||||
'Test1.testOne', 'Test1.testTwo', 'teardown 1',
|
||||
'setup 2', 'Test2.testOne', 'Test2.testTwo',
|
||||
'teardown 2', 'Module1.tearDownModule',
|
||||
'Module2.setUpModule', 'setup 3',
|
||||
'Test3.testOne', 'Test3.testTwo',
|
||||
'teardown 3', 'Module2.tearDownModule'])
|
||||
|
||||
def test_setup_module(self):
|
||||
class Module(object):
|
||||
moduleSetup = 0
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
Module.moduleSetup += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(Module.moduleSetup, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_setup_module(self):
|
||||
class Module(object):
|
||||
moduleSetup = 0
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
Module.moduleSetup += 1
|
||||
raise TypeError('foo')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
classTornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.classTornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
Test2.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(Module.moduleSetup, 1)
|
||||
self.assertEqual(Module.moduleTornDown, 0)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertFalse(Test.classSetUp)
|
||||
self.assertFalse(Test.classTornDown)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error), 'setUpModule (Module)')
|
||||
|
||||
def test_testcase_with_missing_module(self):
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules.pop('Module', None)
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
|
||||
def test_teardown_module(self):
|
||||
class Module(object):
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(Module.moduleTornDown, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_teardown_module(self):
|
||||
class Module(object):
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
raise TypeError('foo')
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
classTornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.classTornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
Test2.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(Module.moduleTornDown, 1)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertTrue(Test.classSetUp)
|
||||
self.assertTrue(Test.classTornDown)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error), 'tearDownModule (Module)')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
import unittest
|
||||
|
||||
from .support import LoggingResult
|
||||
|
||||
|
||||
class Test_TestSkipping(unittest.TestCase):
|
||||
|
||||
def test_skipping(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_skip_me(self):
|
||||
self.skipTest("skip")
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_skip_me")
|
||||
test.run(result)
|
||||
self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
|
||||
self.assertEqual(result.skipped, [(test, "skip")])
|
||||
|
||||
# Try letting setUp skip the test now.
|
||||
class Foo(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.skipTest("testing")
|
||||
def test_nothing(self): pass
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_nothing")
|
||||
test.run(result)
|
||||
self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
|
||||
def test_skipping_decorators(self):
|
||||
op_table = ((unittest.skipUnless, False, True),
|
||||
(unittest.skipIf, True, False))
|
||||
for deco, do_skip, dont_skip in op_table:
|
||||
class Foo(unittest.TestCase):
|
||||
@deco(do_skip, "testing")
|
||||
def test_skip(self): pass
|
||||
|
||||
@deco(dont_skip, "testing")
|
||||
def test_dont_skip(self): pass
|
||||
test_do_skip = Foo("test_skip")
|
||||
test_dont_skip = Foo("test_dont_skip")
|
||||
suite = unittest.TestSuite([test_do_skip, test_dont_skip])
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
suite.run(result)
|
||||
self.assertEqual(len(result.skipped), 1)
|
||||
expected = ['startTest', 'addSkip', 'stopTest',
|
||||
'startTest', 'addSuccess', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(result.skipped, [(test_do_skip, "testing")])
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_skip_class(self):
|
||||
@unittest.skip("testing")
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
record.append(1)
|
||||
record = []
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertEqual(record, [])
|
||||
|
||||
def test_expected_failure(self):
|
||||
class Foo(unittest.TestCase):
|
||||
@unittest.expectedFailure
|
||||
def test_die(self):
|
||||
self.fail("help me!")
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_die")
|
||||
test.run(result)
|
||||
self.assertEqual(events,
|
||||
['startTest', 'addExpectedFailure', 'stopTest'])
|
||||
self.assertEqual(result.expectedFailures[0][0], test)
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_unexpected_success(self):
|
||||
class Foo(unittest.TestCase):
|
||||
@unittest.expectedFailure
|
||||
def test_die(self):
|
||||
pass
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_die")
|
||||
test.run(result)
|
||||
self.assertEqual(events,
|
||||
['startTest', 'addUnexpectedSuccess', 'stopTest'])
|
||||
self.assertFalse(result.failures)
|
||||
self.assertEqual(result.unexpectedSuccesses, [test])
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_skip_doesnt_run_setup(self):
|
||||
class Foo(unittest.TestCase):
|
||||
wasSetUp = False
|
||||
wasTornDown = False
|
||||
def setUp(self):
|
||||
Foo.wasSetUp = True
|
||||
def tornDown(self):
|
||||
Foo.wasTornDown = True
|
||||
@unittest.skip('testing')
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertFalse(Foo.wasSetUp)
|
||||
self.assertFalse(Foo.wasTornDown)
|
||||
|
||||
def test_decorated_skip(self):
|
||||
def decorator(func):
|
||||
def inner(*a):
|
||||
return func(*a)
|
||||
return inner
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
@decorator
|
||||
@unittest.skip('testing')
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,295 @@
|
|||
import unittest
|
||||
|
||||
from .support import LoggingResult, TestEquality
|
||||
|
||||
|
||||
### Support code for Test_TestSuite
|
||||
################################################################
|
||||
|
||||
# This will be loaded as a test - problem?
|
||||
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(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")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Loading…
Reference in New Issue