| import sys |
| import textwrap |
| from StringIO import StringIO |
| from test import test_support |
| |
| import traceback |
| 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) |
| self.assertIsNone(result._stdout_buffer) |
| self.assertIsNone(result._stderr_buffer) |
| |
| |
| # "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 |
| self.buffer = 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')) |
| |
| |
| class MockTraceback(object): |
| @staticmethod |
| def format_exception(*_): |
| return ['A traceback'] |
| |
| def restore_traceback(): |
| unittest.result.traceback = traceback |
| |
| |
| class TestOutputBuffering(unittest.TestCase): |
| |
| def setUp(self): |
| self._real_out = sys.stdout |
| self._real_err = sys.stderr |
| |
| def tearDown(self): |
| sys.stdout = self._real_out |
| sys.stderr = self._real_err |
| |
| def testBufferOutputOff(self): |
| real_out = self._real_out |
| real_err = self._real_err |
| |
| result = unittest.TestResult() |
| self.assertFalse(result.buffer) |
| |
| self.assertIs(real_out, sys.stdout) |
| self.assertIs(real_err, sys.stderr) |
| |
| result.startTest(self) |
| |
| self.assertIs(real_out, sys.stdout) |
| self.assertIs(real_err, sys.stderr) |
| |
| def testBufferOutputStartTestAddSuccess(self): |
| real_out = self._real_out |
| real_err = self._real_err |
| |
| result = unittest.TestResult() |
| self.assertFalse(result.buffer) |
| |
| result.buffer = True |
| |
| self.assertIs(real_out, sys.stdout) |
| self.assertIs(real_err, sys.stderr) |
| |
| result.startTest(self) |
| |
| self.assertIsNot(real_out, sys.stdout) |
| self.assertIsNot(real_err, sys.stderr) |
| self.assertIsInstance(sys.stdout, StringIO) |
| self.assertIsInstance(sys.stderr, StringIO) |
| self.assertIsNot(sys.stdout, sys.stderr) |
| |
| out_stream = sys.stdout |
| err_stream = sys.stderr |
| |
| result._original_stdout = StringIO() |
| result._original_stderr = StringIO() |
| |
| print 'foo' |
| print >> sys.stderr, 'bar' |
| |
| self.assertEqual(out_stream.getvalue(), 'foo\n') |
| self.assertEqual(err_stream.getvalue(), 'bar\n') |
| |
| self.assertEqual(result._original_stdout.getvalue(), '') |
| self.assertEqual(result._original_stderr.getvalue(), '') |
| |
| result.addSuccess(self) |
| result.stopTest(self) |
| |
| self.assertIs(sys.stdout, result._original_stdout) |
| self.assertIs(sys.stderr, result._original_stderr) |
| |
| self.assertEqual(result._original_stdout.getvalue(), '') |
| self.assertEqual(result._original_stderr.getvalue(), '') |
| |
| self.assertEqual(out_stream.getvalue(), '') |
| self.assertEqual(err_stream.getvalue(), '') |
| |
| |
| def getStartedResult(self): |
| result = unittest.TestResult() |
| result.buffer = True |
| result.startTest(self) |
| return result |
| |
| def testBufferOutputAddErrorOrFailure(self): |
| unittest.result.traceback = MockTraceback |
| self.addCleanup(restore_traceback) |
| |
| for message_attr, add_attr, include_error in [ |
| ('errors', 'addError', True), |
| ('failures', 'addFailure', False), |
| ('errors', 'addError', True), |
| ('failures', 'addFailure', False) |
| ]: |
| result = self.getStartedResult() |
| buffered_out = sys.stdout |
| buffered_err = sys.stderr |
| result._original_stdout = StringIO() |
| result._original_stderr = StringIO() |
| |
| print >> sys.stdout, 'foo' |
| if include_error: |
| print >> sys.stderr, 'bar' |
| |
| |
| addFunction = getattr(result, add_attr) |
| addFunction(self, (None, None, None)) |
| result.stopTest(self) |
| |
| result_list = getattr(result, message_attr) |
| self.assertEqual(len(result_list), 1) |
| |
| test, message = result_list[0] |
| expectedOutMessage = textwrap.dedent(""" |
| Stdout: |
| foo |
| """) |
| expectedErrMessage = '' |
| if include_error: |
| expectedErrMessage = textwrap.dedent(""" |
| Stderr: |
| bar |
| """) |
| expectedFullMessage = 'A traceback%s%s' % (expectedOutMessage, expectedErrMessage) |
| |
| self.assertIs(test, self) |
| self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage) |
| self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage) |
| self.assertMultiLineEqual(message, expectedFullMessage) |
| |
| def testBufferSetupClass(self): |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| 1//0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| self.assertEqual(len(result.errors), 1) |
| |
| def testBufferTearDownClass(self): |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def tearDownClass(cls): |
| 1//0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| self.assertEqual(len(result.errors), 1) |
| |
| def testBufferSetUpModule(self): |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def setUpModule(): |
| 1//0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| self.assertEqual(len(result.errors), 1) |
| |
| def testBufferTearDownModule(self): |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def tearDownModule(): |
| 1//0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| self.assertEqual(len(result.errors), 1) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
