| import io |
| import sys |
| import textwrap |
| |
| from test.support import warnings_helper, captured_stdout, captured_stderr |
| |
| import traceback |
| import unittest |
| from unittest.util import strclass |
| |
| |
| class MockTraceback(object): |
| class TracebackException: |
| def __init__(self, *args, **kwargs): |
| self.capture_locals = kwargs.get('capture_locals', False) |
| def format(self): |
| result = ['A traceback'] |
| if self.capture_locals: |
| result.append('locals') |
| return result |
| |
| def restore_traceback(): |
| unittest.result.traceback = traceback |
| |
| |
| def bad_cleanup1(): |
| print('do cleanup1') |
| raise TypeError('bad cleanup1') |
| |
| |
| def bad_cleanup2(): |
| print('do cleanup2') |
| raise ValueError('bad cleanup2') |
| |
| |
| class BufferedWriter: |
| def __init__(self): |
| self.result = '' |
| self.buffer = '' |
| |
| def write(self, arg): |
| self.buffer += arg |
| |
| def flush(self): |
| self.result += self.buffer |
| self.buffer = '' |
| |
| def getvalue(self): |
| return self.result |
| |
| |
| 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.assertIs(test_case, test) |
| self.assertIsInstance(formatted_exc, str) |
| |
| def test_addFailure_filter_traceback_frames(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| pass |
| |
| test = Foo('test_1') |
| def get_exc_info(): |
| try: |
| test.fail("foo") |
| except: |
| return sys.exc_info() |
| |
| exc_info_tuple = get_exc_info() |
| |
| full_exc = traceback.format_exception(*exc_info_tuple) |
| |
| result = unittest.TestResult() |
| result.startTest(test) |
| result.addFailure(test, exc_info_tuple) |
| result.stopTest(test) |
| |
| formatted_exc = result.failures[0][1] |
| dropped = [l for l in full_exc if l not in formatted_exc] |
| self.assertEqual(len(dropped), 1) |
| self.assertIn("raise self.failureException(msg)", dropped[0]) |
| |
| def test_addFailure_filter_traceback_frames_context(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| pass |
| |
| test = Foo('test_1') |
| def get_exc_info(): |
| try: |
| try: |
| test.fail("foo") |
| except: |
| raise ValueError(42) |
| except: |
| return sys.exc_info() |
| |
| exc_info_tuple = get_exc_info() |
| |
| full_exc = traceback.format_exception(*exc_info_tuple) |
| |
| result = unittest.TestResult() |
| result.startTest(test) |
| result.addFailure(test, exc_info_tuple) |
| result.stopTest(test) |
| |
| formatted_exc = result.failures[0][1] |
| dropped = [l for l in full_exc if l not in formatted_exc] |
| self.assertEqual(len(dropped), 1) |
| self.assertIn("raise self.failureException(msg)", dropped[0]) |
| |
| def test_addFailure_filter_traceback_frames_chained_exception_self_loop(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| pass |
| |
| def get_exc_info(): |
| try: |
| loop = Exception("Loop") |
| loop.__cause__ = loop |
| loop.__context__ = loop |
| raise loop |
| except: |
| return sys.exc_info() |
| |
| exc_info_tuple = get_exc_info() |
| |
| test = Foo('test_1') |
| result = unittest.TestResult() |
| result.startTest(test) |
| result.addFailure(test, exc_info_tuple) |
| result.stopTest(test) |
| |
| formatted_exc = result.failures[0][1] |
| self.assertEqual(formatted_exc.count("Exception: Loop\n"), 1) |
| |
| def test_addFailure_filter_traceback_frames_chained_exception_cycle(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| pass |
| |
| def get_exc_info(): |
| try: |
| # Create two directionally opposed cycles |
| # __cause__ in one direction, __context__ in the other |
| A, B, C = Exception("A"), Exception("B"), Exception("C") |
| edges = [(C, B), (B, A), (A, C)] |
| for ex1, ex2 in edges: |
| ex1.__cause__ = ex2 |
| ex2.__context__ = ex1 |
| raise C |
| except: |
| return sys.exc_info() |
| |
| exc_info_tuple = get_exc_info() |
| |
| test = Foo('test_1') |
| result = unittest.TestResult() |
| result.startTest(test) |
| result.addFailure(test, exc_info_tuple) |
| result.stopTest(test) |
| |
| formatted_exc = result.failures[0][1] |
| self.assertEqual(formatted_exc.count("Exception: A\n"), 1) |
| self.assertEqual(formatted_exc.count("Exception: B\n"), 1) |
| self.assertEqual(formatted_exc.count("Exception: C\n"), 1) |
| |
| # "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.assertIs(test_case, test) |
| self.assertIsInstance(formatted_exc, str) |
| |
| def test_addError_locals(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| 1/0 |
| |
| test = Foo('test_1') |
| result = unittest.TestResult() |
| result.tb_locals = True |
| |
| unittest.result.traceback = MockTraceback |
| self.addCleanup(restore_traceback) |
| result.startTestRun() |
| test.run(result) |
| result.stopTestRun() |
| |
| self.assertEqual(len(result.errors), 1) |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual('A tracebacklocals', formatted_exc) |
| |
| def test_addSubTest(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): |
| nonlocal subtest |
| with self.subTest(foo=1): |
| subtest = self._subtest |
| try: |
| 1/0 |
| except ZeroDivisionError: |
| exc_info_tuple = sys.exc_info() |
| # Register an error by hand (to check the API) |
| result.addSubTest(test, subtest, exc_info_tuple) |
| # Now trigger a failure |
| self.fail("some recognizable failure") |
| |
| subtest = None |
| test = Foo('test_1') |
| result = unittest.TestResult() |
| |
| test.run(result) |
| |
| self.assertFalse(result.wasSuccessful()) |
| self.assertEqual(len(result.errors), 1) |
| self.assertEqual(len(result.failures), 1) |
| self.assertEqual(result.testsRun, 1) |
| self.assertEqual(result.shouldStop, False) |
| |
| test_case, formatted_exc = result.errors[0] |
| self.assertIs(test_case, subtest) |
| self.assertIn("ZeroDivisionError", formatted_exc) |
| test_case, formatted_exc = result.failures[0] |
| self.assertIs(test_case, subtest) |
| self.assertIn("some recognizable failure", formatted_exc) |
| |
| 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): |
| stream = BufferedWriter() |
| runner = unittest.TextTestRunner(stream=stream, failfast=True) |
| def test(result): |
| self.assertTrue(result.failfast) |
| result = runner.run(test) |
| stream.flush() |
| self.assertTrue(stream.getvalue().endswith('\n\nOK\n')) |
| |
| |
| class Test_TextTestResult(unittest.TestCase): |
| maxDiff = None |
| |
| def testGetDescriptionWithoutDocstring(self): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self), |
| 'testGetDescriptionWithoutDocstring (' + __name__ + |
| '.Test_TextTestResult.testGetDescriptionWithoutDocstring)') |
| |
| def testGetSubTestDescriptionWithoutDocstring(self): |
| with self.subTest(foo=1, bar=2): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| 'testGetSubTestDescriptionWithoutDocstring (' + __name__ + |
| '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) (foo=1, bar=2)') |
| |
| with self.subTest('some message'): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| 'testGetSubTestDescriptionWithoutDocstring (' + __name__ + |
| '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) [some message]') |
| |
| def testGetSubTestDescriptionWithoutDocstringAndParams(self): |
| with self.subTest(): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| 'testGetSubTestDescriptionWithoutDocstringAndParams ' |
| '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstringAndParams) ' |
| '(<subtest>)') |
| |
| def testGetSubTestDescriptionForFalsyValues(self): |
| expected = 'testGetSubTestDescriptionForFalsyValues (%s.Test_TextTestResult.testGetSubTestDescriptionForFalsyValues) [%s]' |
| result = unittest.TextTestResult(None, True, 1) |
| for arg in [0, None, []]: |
| with self.subTest(arg): |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| expected % (__name__, arg) |
| ) |
| |
| def testGetNestedSubTestDescriptionWithoutDocstring(self): |
| with self.subTest(foo=1): |
| with self.subTest(baz=2, bar=3): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| 'testGetNestedSubTestDescriptionWithoutDocstring ' |
| '(' + __name__ + '.Test_TextTestResult.testGetNestedSubTestDescriptionWithoutDocstring) ' |
| '(baz=2, bar=3, foo=1)') |
| |
| def testGetDuplicatedNestedSubTestDescriptionWithoutDocstring(self): |
| with self.subTest(foo=1, bar=2): |
| with self.subTest(baz=3, bar=4): |
| result = unittest.TextTestResult(None, True, 1) |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| 'testGetDuplicatedNestedSubTestDescriptionWithoutDocstring ' |
| '(' + __name__ + '.Test_TextTestResult.testGetDuplicatedNestedSubTestDescriptionWithoutDocstring) (baz=3, bar=4, foo=1)') |
| |
| @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_TextTestResult.testGetDescriptionWithOneLineDocstring)\n' |
| 'Tests getDescription() for a method with a docstring.')) |
| |
| @unittest.skipIf(sys.flags.optimize >= 2, |
| "Docstrings are omitted with -O2 and above") |
| def testGetSubTestDescriptionWithOneLineDocstring(self): |
| """Tests getDescription() for a method with a docstring.""" |
| result = unittest.TextTestResult(None, True, 1) |
| with self.subTest(foo=1, bar=2): |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| ('testGetSubTestDescriptionWithOneLineDocstring ' |
| '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithOneLineDocstring) ' |
| '(foo=1, bar=2)\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_TextTestResult.testGetDescriptionWithMultiLineDocstring)\n' |
| 'Tests getDescription() for a method with a longer ' |
| 'docstring.')) |
| |
| @unittest.skipIf(sys.flags.optimize >= 2, |
| "Docstrings are omitted with -O2 and above") |
| def testGetSubTestDescriptionWithMultiLineDocstring(self): |
| """Tests getDescription() for a method with a longer docstring. |
| The second line of the docstring. |
| """ |
| result = unittest.TextTestResult(None, True, 1) |
| with self.subTest(foo=1, bar=2): |
| self.assertEqual( |
| result.getDescription(self._subtest), |
| ('testGetSubTestDescriptionWithMultiLineDocstring ' |
| '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithMultiLineDocstring) ' |
| '(foo=1, bar=2)\n' |
| 'Tests getDescription() for a method with a longer ' |
| 'docstring.')) |
| |
| class Test(unittest.TestCase): |
| def testSuccess(self): |
| pass |
| def testSkip(self): |
| self.skipTest('skip') |
| def testFail(self): |
| self.fail('fail') |
| def testError(self): |
| raise Exception('error') |
| @unittest.expectedFailure |
| def testExpectedFailure(self): |
| self.fail('fail') |
| @unittest.expectedFailure |
| def testUnexpectedSuccess(self): |
| pass |
| def testSubTestSuccess(self): |
| with self.subTest('one', a=1): |
| pass |
| with self.subTest('two', b=2): |
| pass |
| def testSubTestMixed(self): |
| with self.subTest('success', a=1): |
| pass |
| with self.subTest('skip', b=2): |
| self.skipTest('skip') |
| with self.subTest('fail', c=3): |
| self.fail('fail') |
| with self.subTest('error', d=4): |
| raise Exception('error') |
| |
| tearDownError = None |
| def tearDown(self): |
| if self.tearDownError is not None: |
| raise self.tearDownError |
| |
| def _run_test(self, test_name, verbosity, tearDownError=None): |
| stream = BufferedWriter() |
| stream = unittest.runner._WritelnDecorator(stream) |
| result = unittest.TextTestResult(stream, True, verbosity) |
| test = self.Test(test_name) |
| test.tearDownError = tearDownError |
| test.run(result) |
| return stream.getvalue() |
| |
| def testDotsOutput(self): |
| self.assertEqual(self._run_test('testSuccess', 1), '.') |
| self.assertEqual(self._run_test('testSkip', 1), 's') |
| self.assertEqual(self._run_test('testFail', 1), 'F') |
| self.assertEqual(self._run_test('testError', 1), 'E') |
| self.assertEqual(self._run_test('testExpectedFailure', 1), 'x') |
| self.assertEqual(self._run_test('testUnexpectedSuccess', 1), 'u') |
| |
| def testLongOutput(self): |
| classname = f'{__name__}.{self.Test.__qualname__}' |
| self.assertEqual(self._run_test('testSuccess', 2), |
| f'testSuccess ({classname}.testSuccess) ... ok\n') |
| self.assertEqual(self._run_test('testSkip', 2), |
| f"testSkip ({classname}.testSkip) ... skipped 'skip'\n") |
| self.assertEqual(self._run_test('testFail', 2), |
| f'testFail ({classname}.testFail) ... FAIL\n') |
| self.assertEqual(self._run_test('testError', 2), |
| f'testError ({classname}.testError) ... ERROR\n') |
| self.assertEqual(self._run_test('testExpectedFailure', 2), |
| f'testExpectedFailure ({classname}.testExpectedFailure) ... expected failure\n') |
| self.assertEqual(self._run_test('testUnexpectedSuccess', 2), |
| f'testUnexpectedSuccess ({classname}.testUnexpectedSuccess) ... unexpected success\n') |
| |
| def testDotsOutputSubTestSuccess(self): |
| self.assertEqual(self._run_test('testSubTestSuccess', 1), '.') |
| |
| def testLongOutputSubTestSuccess(self): |
| classname = f'{__name__}.{self.Test.__qualname__}' |
| self.assertEqual(self._run_test('testSubTestSuccess', 2), |
| f'testSubTestSuccess ({classname}.testSubTestSuccess) ... ok\n') |
| |
| def testDotsOutputSubTestMixed(self): |
| self.assertEqual(self._run_test('testSubTestMixed', 1), 'sFE') |
| |
| def testLongOutputSubTestMixed(self): |
| classname = f'{__name__}.{self.Test.__qualname__}' |
| self.assertEqual(self._run_test('testSubTestMixed', 2), |
| f'testSubTestMixed ({classname}.testSubTestMixed) ... \n' |
| f" testSubTestMixed ({classname}.testSubTestMixed) [skip] (b=2) ... skipped 'skip'\n" |
| f' testSubTestMixed ({classname}.testSubTestMixed) [fail] (c=3) ... FAIL\n' |
| f' testSubTestMixed ({classname}.testSubTestMixed) [error] (d=4) ... ERROR\n') |
| |
| def testDotsOutputTearDownFail(self): |
| out = self._run_test('testSuccess', 1, AssertionError('fail')) |
| self.assertEqual(out, 'F') |
| out = self._run_test('testError', 1, AssertionError('fail')) |
| self.assertEqual(out, 'EF') |
| out = self._run_test('testFail', 1, Exception('error')) |
| self.assertEqual(out, 'FE') |
| out = self._run_test('testSkip', 1, AssertionError('fail')) |
| self.assertEqual(out, 'sF') |
| |
| def testLongOutputTearDownFail(self): |
| classname = f'{__name__}.{self.Test.__qualname__}' |
| out = self._run_test('testSuccess', 2, AssertionError('fail')) |
| self.assertEqual(out, |
| f'testSuccess ({classname}.testSuccess) ... FAIL\n') |
| out = self._run_test('testError', 2, AssertionError('fail')) |
| self.assertEqual(out, |
| f'testError ({classname}.testError) ... ERROR\n' |
| f'testError ({classname}.testError) ... FAIL\n') |
| out = self._run_test('testFail', 2, Exception('error')) |
| self.assertEqual(out, |
| f'testFail ({classname}.testFail) ... FAIL\n' |
| f'testFail ({classname}.testFail) ... ERROR\n') |
| out = self._run_test('testSkip', 2, AssertionError('fail')) |
| self.assertEqual(out, |
| f"testSkip ({classname}.testSkip) ... skipped 'skip'\n" |
| f'testSkip ({classname}.testSkip) ... FAIL\n') |
| |
| |
| 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 |
| self.tb_locals = False |
| |
| classDict['__init__'] = __init__ |
| OldResult = type('OldResult', (object,), classDict) |
| |
| class Test_OldTestResult(unittest.TestCase): |
| |
| def assertOldResultWarning(self, test, failures): |
| with warnings_helper.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=io.StringIO()) |
| # This will raise an exception if TextTestRunner can't handle old |
| # test result objects |
| runner.run(Test('testFoo')) |
| |
| |
| 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, io.StringIO) |
| self.assertIsInstance(sys.stderr, io.StringIO) |
| self.assertIsNot(sys.stdout, sys.stderr) |
| |
| out_stream = sys.stdout |
| err_stream = sys.stderr |
| |
| result._original_stdout = io.StringIO() |
| result._original_stderr = io.StringIO() |
| |
| print('foo') |
| print('bar', file=sys.stderr) |
| |
| 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 = io.StringIO() |
| result._original_stderr = io.StringIO() |
| |
| print('foo', file=sys.stdout) |
| if include_error: |
| print('bar', file=sys.stderr) |
| |
| |
| 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 testBufferSetUp(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def setUp(self): |
| print('set up') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = f'test_foo ({strclass(Foo)}.test_foo)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDown(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def tearDown(self): |
| print('tear down') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = f'test_foo ({strclass(Foo)}.test_foo)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferDoCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def setUp(self): |
| print('set up') |
| self.addCleanup(bad_cleanup1) |
| self.addCleanup(bad_cleanup2) |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 2) |
| description = f'test_foo ({strclass(Foo)}.test_foo)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup1\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferSetUp_DoCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def setUp(self): |
| print('set up') |
| self.addCleanup(bad_cleanup1) |
| self.addCleanup(bad_cleanup2) |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 3) |
| description = f'test_foo ({strclass(Foo)}.test_foo)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup2\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup1\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup1\n', formatted_exc) |
| test_case, formatted_exc = result.errors[2] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDown_DoCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def setUp(self): |
| print('set up') |
| self.addCleanup(bad_cleanup1) |
| self.addCleanup(bad_cleanup2) |
| def tearDown(self): |
| print('tear down') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up\ntear down\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 3) |
| description = f'test_foo ({strclass(Foo)}.test_foo)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up\ntear down\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup2\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup1\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up\ntear down\ndo cleanup2\n', formatted_exc) |
| self.assertNotIn('\ndo cleanup1\n', formatted_exc) |
| test_case, formatted_exc = result.errors[2] |
| self.assertEqual(str(test_case), description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferSetupClass(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| print('set up class') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up class\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = f'setUpClass ({strclass(Foo)})' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDownClass(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def tearDownClass(cls): |
| print('tear down class') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down class\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = f'tearDownClass ({strclass(Foo)})' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferDoClassCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| print('set up class') |
| cls.addClassCleanup(bad_cleanup1) |
| cls.addClassCleanup(bad_cleanup2) |
| @classmethod |
| def tearDownClass(cls): |
| print('tear down class') |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 2) |
| description = f'tearDownClass ({strclass(Foo)})' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferSetupClass_DoClassCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| print('set up class') |
| cls.addClassCleanup(bad_cleanup1) |
| cls.addClassCleanup(bad_cleanup2) |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up class\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 3) |
| description = f'setUpClass ({strclass(Foo)})' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up class\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| test_case, formatted_exc = result.errors[2] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDownClass_DoClassCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| print('set up class') |
| cls.addClassCleanup(bad_cleanup1) |
| cls.addClassCleanup(bad_cleanup2) |
| @classmethod |
| def tearDownClass(cls): |
| print('tear down class') |
| 1/0 |
| def test_foo(self): |
| pass |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 3) |
| description = f'tearDownClass ({strclass(Foo)})' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\ntear down class\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| test_case, formatted_exc = result.errors[2] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('TypeError: bad cleanup1', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferSetUpModule(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def setUpModule(): |
| print('set up module') |
| 1/0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up module\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = 'setUpModule (Module)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDownModule(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def tearDownModule(): |
| print('tear down module') |
| 1/0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down module\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = 'tearDownModule (Module)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferDoModuleCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def setUpModule(): |
| print('set up module') |
| unittest.addModuleCleanup(bad_cleanup1) |
| unittest.addModuleCleanup(bad_cleanup2) |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 1) |
| description = 'tearDownModule (Module)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferSetUpModule_DoModuleCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def setUpModule(): |
| print('set up module') |
| unittest.addModuleCleanup(bad_cleanup1) |
| unittest.addModuleCleanup(bad_cleanup2) |
| 1/0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\nset up module\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 2) |
| description = 'setUpModule (Module)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\nset up module\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertIn(expected_out, formatted_exc) |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| def testBufferTearDownModule_DoModuleCleanups(self): |
| with captured_stdout() as stdout: |
| result = unittest.TestResult() |
| result.buffer = True |
| |
| class Foo(unittest.TestCase): |
| def test_foo(self): |
| pass |
| class Module(object): |
| @staticmethod |
| def setUpModule(): |
| print('set up module') |
| unittest.addModuleCleanup(bad_cleanup1) |
| unittest.addModuleCleanup(bad_cleanup2) |
| @staticmethod |
| def tearDownModule(): |
| print('tear down module') |
| 1/0 |
| |
| Foo.__module__ = 'Module' |
| sys.modules['Module'] = Module |
| self.addCleanup(sys.modules.pop, 'Module') |
| suite = unittest.TestSuite([Foo('test_foo')]) |
| suite(result) |
| expected_out = '\nStdout:\ntear down module\ndo cleanup2\ndo cleanup1\n' |
| self.assertEqual(stdout.getvalue(), expected_out) |
| self.assertEqual(len(result.errors), 2) |
| description = 'tearDownModule (Module)' |
| test_case, formatted_exc = result.errors[0] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ZeroDivisionError: division by zero', formatted_exc) |
| self.assertNotIn('ValueError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn('\nStdout:\ntear down module\n', formatted_exc) |
| test_case, formatted_exc = result.errors[1] |
| self.assertEqual(test_case.description, description) |
| self.assertIn('ValueError: bad cleanup2', formatted_exc) |
| self.assertNotIn('ZeroDivisionError', formatted_exc) |
| self.assertNotIn('TypeError', formatted_exc) |
| self.assertIn(expected_out, formatted_exc) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
