Beispiel #1
0
 def test_expected_failure_subtests(self):
     # A failure in any subtest counts as the expected failure of the
     # whole test.
     class Foo(unittest.TestCase):
         @unittest.expectedFailure
         def test_die(self):
             with self.subTest():
                 # This one succeeds
                 pass
             with self.subTest():
                 self.fail("help me!")
             with self.subTest():
                 # This one doesn't get executed
                 self.fail("shouldn't come here")
     events = []
     result = LoggingResult(events)
     test = Foo("test_die")
     self.assertIs(test.run(result), result)
     self.assertEqual(events,
                      ['startTest', 'addSubTestSuccess',
                       'addExpectedFailure', 'stopTest'])
     self.assertFalse(result.failures)
     self.assertEqual(len(result.expectedFailures), 1)
     self.assertIs(result.expectedFailures[0][0], test)
     self.assertFalse(result.unexpectedSuccesses)
     self.assertTrue(result.wasSuccessful())
    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')])


        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)
Beispiel #3
0
    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())
Beispiel #4
0
    def test_unexpected_success_subtests(self):
        # Success in all subtests counts as the unexpected success of
        # the whole test.
        class Foo(unittest.TestCase):
            @unittest.expectedFailure
            def test_die(self):
                with self.subTest():
                    # This one succeeds
                    pass
                with self.subTest():
                    # So does this one
                    pass

        events = []
        result = LoggingResult(events)
        test = Foo("test_die")
        self.assertIs(test.run(result), result)
        self.assertEqual(events, [
            'startTest', 'addSubTestSuccess', 'addSubTestSuccess',
            'addUnexpectedSuccess', 'stopTest'
        ])
        self.assertFalse(result.failures)
        self.assertFalse(result.expectedFailures)
        self.assertEqual(result.unexpectedSuccesses, [test])
        self.assertFalse(result.wasSuccessful())
Beispiel #5
0
    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)
Beispiel #6
0
 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())
Beispiel #7
0
 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())
Beispiel #8
0
    def test_expected_failure_with_wrapped_class(self):
        @unittest.expectedFailure
        class Foo(unittest.TestCase):
            def test_1(self):
                self.assertTrue(False)

        events = []
        result = LoggingResult(events)
        test = Foo("test_1")
        test.run(result)
        self.assertEqual(events,
                         ['startTest', 'addExpectedFailure', 'stopTest'])
        self.assertEqual(result.expectedFailures[0][0], test)
        self.assertTrue(result.wasSuccessful())
Beispiel #9
0
    def test_expected_failure_with_wrapped_class(self):
        @unittest.expectedFailure
        class Foo(unittest.TestCase):
            def test_1(self):
                self.assertTrue(False)

        events = []
        result = LoggingResult(events)
        test = Foo("test_1")
        test.run(result)
        self.assertEqual(events,
                         ['startTest', 'addExpectedFailure', 'stopTest'])
        self.assertEqual(result.expectedFailures[0][0], test)
        self.assertTrue(result.wasSuccessful())
    def test_skipping_subtests(self):


        class Foo(unittest.TestCase):

            def test_skip_me(self):
                with self.subTest(a=1):
                    with self.subTest(b=2):
                        self.skipTest('skip 1')
                    self.skipTest('skip 2')
                self.skipTest('skip 3')
        events = []
        result = LoggingResult(events)
        test = Foo('test_skip_me')
        test.run(result)
        self.assertEqual(events, ['startTest', 'addSkip', 'addSkip',
            'addSkip', 'stopTest'])
        self.assertEqual(len(result.skipped), 3)
        subtest, msg = result.skipped[0]
        self.assertEqual(msg, 'skip 1')
        self.assertIsInstance(subtest, unittest.TestCase)
        self.assertIsNot(subtest, test)
        subtest, msg = result.skipped[1]
        self.assertEqual(msg, 'skip 2')
        self.assertIsInstance(subtest, unittest.TestCase)
        self.assertIsNot(subtest, test)
        self.assertEqual(result.skipped[2], (test, 'skip 3'))
Beispiel #11
0
    def test_skip_class(self):
        @unittest.skip("testing")
        class Foo(unittest.TestCase):
            def defaultTestResult(self):
                return LoggingResult(events)

            def test_1(self):
                record.append(1)

        events = []
        record = []
        result = LoggingResult(events)
        test = Foo("test_1")
        suite = unittest.TestSuite([test])
        self.assertIs(suite.run(result), result)
        self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
        self.assertEqual(result.skipped, [(test, "testing")])
        self.assertEqual(record, [])

        events = []
        result = test.run()
        self.assertEqual(events, [
            'startTestRun', 'startTest', 'addSkip', 'stopTest', 'stopTestRun'
        ])
        self.assertEqual(result.skipped, [(test, "testing")])
        self.assertEqual(record, [])
Beispiel #12
0
    def test_skipping_subtests(self):
        class Foo(unittest.TestCase):
            def defaultTestResult(self):
                return LoggingResult(events)
            def test_skip_me(self):
                with self.subTest(a=1):
                    with self.subTest(b=2):
                        self.skipTest("skip 1")
                    self.skipTest("skip 2")
                self.skipTest("skip 3")
        events = []
        result = LoggingResult(events)
        test = Foo("test_skip_me")
        self.assertIs(test.run(result), result)
        self.assertEqual(events, ['startTest', 'addSkip', 'addSkip',
                                  'addSkip', 'stopTest'])
        self.assertEqual(len(result.skipped), 3)
        subtest, msg = result.skipped[0]
        self.assertEqual(msg, "skip 1")
        self.assertIsInstance(subtest, unittest.TestCase)
        self.assertIsNot(subtest, test)
        subtest, msg = result.skipped[1]
        self.assertEqual(msg, "skip 2")
        self.assertIsInstance(subtest, unittest.TestCase)
        self.assertIsNot(subtest, test)
        self.assertEqual(result.skipped[2], (test, "skip 3"))

        events = []
        result = test.run()
        self.assertEqual(events,
                         ['startTestRun', 'startTest', 'addSkip', 'addSkip',
                          'addSkip', 'stopTest', 'stopTestRun'])
        self.assertEqual([msg for subtest, msg in result.skipped],
                         ['skip 1', 'skip 2', 'skip 3'])
Beispiel #13
0
 def test_run_call_order__subtests_success(self):
     events = []
     result = LoggingResult(events)
     # The 6 subtest successes are individually recorded, in addition
     # to the whole test success.
     expected = (['startTest', 'setUp', 'test', 'tearDown'] +
                 6 * ['addSubTestSuccess'] + ['addSuccess', 'stopTest'])
     self._check_call_order__subtests_success(result, events, expected)
Beispiel #14
0
    def test_run__empty_suite(self):
        events = []
        result = LoggingResult(events)

        suite = unittest.TestSuite()

        suite.run(result)

        self.assertEqual(events, [])
Beispiel #15
0
 def test_run_call_order__subtests(self):
     events = []
     result = LoggingResult(events)
     expected = [
         'startTest', 'setUp', 'test', 'tearDown', 'addSubTestFailure',
         'addSubTestSuccess', 'addSubTestFailure', 'addSubTestFailure',
         'addSubTestSuccess', 'addError', 'stopTest'
     ]
     self._check_call_order__subtests(result, events, expected)
Beispiel #16
0
 def test_unexpected_success_and_skip_in_cleanup(self):
     class Foo(unittest.TestCase):
         @unittest.expectedFailure
         def test_die(self):
             pass
         def tearDown(self):
             self.skipTest("skip")
     events = []
     result = LoggingResult(events)
     test = Foo("test_die")
     self.assertIs(test.run(result), result)
     self.assertEqual(events,
                      ['startTest', 'addSkip', 'stopTest'])
     self.assertFalse(result.failures)
     self.assertFalse(result.expectedFailures)
     self.assertFalse(result.unexpectedSuccesses)
     self.assertEqual(result.skipped, [(test, "skip")])
     self.assertTrue(result.wasSuccessful())
Beispiel #17
0
 def test_unexpected_success_and_fail_in_cleanup(self):
     class Foo(unittest.TestCase):
         @unittest.expectedFailure
         def test_die(self):
             pass
         def tearDown(self):
             self.fail("bad tearDown")
     events = []
     result = LoggingResult(events)
     test = Foo("test_die")
     self.assertIs(test.run(result), result)
     self.assertEqual(events,
                      ['startTest', 'addFailure', 'stopTest'])
     self.assertEqual(len(result.failures), 1)
     self.assertIn('AssertionError: bad tearDown', result.failures[0][1])
     self.assertFalse(result.expectedFailures)
     self.assertFalse(result.unexpectedSuccesses)
     self.assertFalse(result.wasSuccessful())
Beispiel #18
0
    def test_expected_failure_with_wrapped_subclass(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                self.assertTrue(False)

        @unittest.expectedFailure
        class Bar(Foo):
            pass

        events = []
        result = LoggingResult(events)
        test = Bar("test_1")
        self.assertIs(test.run(result), result)
        self.assertEqual(events,
                         ['startTest', 'addExpectedFailure', 'stopTest'])
        self.assertFalse(result.failures)
        self.assertEqual(result.expectedFailures[0][0], test)
        self.assertFalse(result.unexpectedSuccesses)
        self.assertTrue(result.wasSuccessful())
Beispiel #19
0
    def test_run_call_order__subtests_failfast(self):
        events = []
        result = LoggingResult(events)
        result.failfast = True

        class Foo(Test.LoggingTestCase):
            def test(self):
                super(Foo, self).test()
                with self.subTest(i=1):
                    self.fail('failure')
                with self.subTest(i=2):
                    self.fail('failure')
                self.fail('failure')

        expected = [
            'startTest', 'setUp', 'test', 'tearDown', 'addSubTestFailure',
            'stopTest'
        ]
        Foo(events).run(result)
        self.assertEqual(events, expected)
Beispiel #20
0
 def test_skip_in_setup(self):
     class Foo(unittest.TestCase):
         def setUp(self):
             self.skipTest("skip")
         def test_skip_me(self):
             self.fail("shouldn't come here")
     events = []
     result = LoggingResult(events)
     test = Foo("test_skip_me")
     self.assertIs(test.run(result), result)
     self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
     self.assertEqual(result.skipped, [(test, "skip")])
Beispiel #21
0
    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)
Beispiel #22
0
 def test_skipping_and_fail_in_cleanup(self):
     class Foo(unittest.TestCase):
         def test_skip_me(self):
             self.skipTest("skip")
         def tearDown(self):
             self.fail("fail")
     events = []
     result = LoggingResult(events)
     test = Foo("test_skip_me")
     self.assertIs(test.run(result), result)
     self.assertEqual(events, ['startTest', 'addSkip', 'addFailure', 'stopTest'])
     self.assertEqual(result.skipped, [(test, "skip")])
    def test_expected_failure_subtests(self):


        class Foo(unittest.TestCase):

            @unittest.expectedFailure
            def test_die(self):
                with self.subTest():
                    pass
                with self.subTest():
                    self.fail('help me!')
                with self.subTest():
                    self.fail("shouldn't come here")
        events = []
        result = LoggingResult(events)
        test = Foo('test_die')
        test.run(result)
        self.assertEqual(events, ['startTest', 'addSubTestSuccess',
            'addExpectedFailure', 'stopTest'])
        self.assertEqual(len(result.expectedFailures), 1)
        self.assertIs(result.expectedFailures[0][0], test)
        self.assertTrue(result.wasSuccessful())
 def test_unexpected_success_subtests(self):
     # Success in all subtests counts as the unexpected success of
     # the whole test.
     class Foo(unittest.TestCase):
         @unittest.expectedFailure
         def test_die(self):
             with self.subTest():
                 # This one succeeds
                 pass
             with self.subTest():
                 # So does this one
                 pass
     events = []
     result = LoggingResult(events)
     test = Foo("test_die")
     test.run(result)
     self.assertEqual(events,
                      ['startTest',
                       'addSubTestSuccess', 'addSubTestSuccess',
                       'addUnexpectedSuccess', 'stopTest'])
     self.assertFalse(result.failures)
     self.assertEqual(result.unexpectedSuccesses, [test])
     self.assertFalse(result.wasSuccessful())
    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())
Beispiel #26
0
    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)
 def test_expected_failure_subtests(self):
     # A failure in any subtest counts as the expected failure of the
     # whole test.
     class Foo(unittest.TestCase):
         @unittest.expectedFailure
         def test_die(self):
             with self.subTest():
                 # This one succeeds
                 pass
             with self.subTest():
                 self.fail("help me!")
             with self.subTest():
                 # This one doesn't get executed
                 self.fail("shouldn't come here")
     events = []
     result = LoggingResult(events)
     test = Foo("test_die")
     test.run(result)
     self.assertEqual(events,
                      ['startTest', 'addSubTestSuccess',
                       'addExpectedFailure', 'stopTest'])
     self.assertEqual(len(result.expectedFailures), 1)
     self.assertIs(result.expectedFailures[0][0], test)
     self.assertTrue(result.wasSuccessful())
Beispiel #28
0
    def test_failureException__subclassing__implicit_raise(self):
        events = []
        result = LoggingResult(events)

        class Foo(unittest.TestCase):
            def test(self):
                self.fail("foo")

            failureException = RuntimeError

        self.assertIs(Foo('test').failureException, RuntimeError)

        Foo('test').run(result)
        expected = ['startTest', 'addFailure', 'stopTest']
        self.assertEqual(events, expected)
Beispiel #29
0
    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)
    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'])
Beispiel #31
0
    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)
Beispiel #32
0
    def test_debug_skipping_subtests(self):
        class Foo(unittest.TestCase):
            def setUp(self):
                events.append("setUp")
            def tearDown(self):
                events.append("tearDown")
            def test(self):
                with self.subTest(a=1):
                    events.append('subtest')
                    self.skipTest("skip subtest")
                    events.append('end subtest')
                events.append('end test')

        events = []
        result = LoggingResult(events)
        test = Foo("test")
        with self.assertRaises(unittest.SkipTest) as cm:
            test.debug()
        self.assertIn("skip subtest", str(cm.exception))
        self.assertEqual(events, ['setUp', 'subtest'])
Beispiel #33
0
    def test_run__uses_defaultTestResult(self):
        events = []
        defaultResult = LoggingResult(events)

        class Foo(unittest.TestCase):
            def test(self):
                events.append('test')

            def defaultTestResult(self):
                return defaultResult

        # Make run() find a result object on its own
        result = Foo('test').run()

        self.assertIs(result, defaultResult)
        expected = [
            'startTestRun', 'startTest', 'test', 'addSuccess', 'stopTest',
            'stopTestRun'
        ]
        self.assertEqual(events, expected)
Beispiel #34
0
 def defaultTestResult(self):
     return LoggingResult(events)