← Back to branch summary

~jfb-tempo-consulting/unifield-wm/sync-env-py3

« back to all changes in this revision

Viewing changes to unittest27/test/test_skipping.py

  • Committer: Samus CTO
  • Date: 2012-09-05 10:40:27 UTC
  • Revision ID: cto@openerp.com-20120905104027-geoynct7122bnoig
[IMPORT] imported unittest from Python 2.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittest27/test/test_skipping.py
 
1
import unittest
 
2
 
 
3
from .support import LoggingResult
 
4
 
 
5
 
 
6
class Test_TestSkipping(unittest.TestCase):
 
7
 
 
8
    def test_skipping(self):
 
9
        class Foo(unittest.TestCase):
 
10
            def test_skip_me(self):
 
11
                self.skipTest("skip")
 
12
        events = []
 
13
        result = LoggingResult(events)
 
14
        test = Foo("test_skip_me")
 
15
        test.run(result)
 
16
        self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
 
17
        self.assertEqual(result.skipped, [(test, "skip")])
 
18
 
 
19
        # Try letting setUp skip the test now.
 
20
        class Foo(unittest.TestCase):
 
21
            def setUp(self):
 
22
                self.skipTest("testing")
 
23
            def test_nothing(self): pass
 
24
        events = []
 
25
        result = LoggingResult(events)
 
26
        test = Foo("test_nothing")
 
27
        test.run(result)
 
28
        self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
 
29
        self.assertEqual(result.skipped, [(test, "testing")])
 
30
        self.assertEqual(result.testsRun, 1)
 
31
 
 
32
    def test_skipping_decorators(self):
 
33
        op_table = ((unittest.skipUnless, False, True),
 
34
                    (unittest.skipIf, True, False))
 
35
        for deco, do_skip, dont_skip in op_table:
 
36
            class Foo(unittest.TestCase):
 
37
                @deco(do_skip, "testing")
 
38
                def test_skip(self): pass
 
39
 
 
40
                @deco(dont_skip, "testing")
 
41
                def test_dont_skip(self): pass
 
42
            test_do_skip = Foo("test_skip")
 
43
            test_dont_skip = Foo("test_dont_skip")
 
44
            suite = unittest.TestSuite([test_do_skip, test_dont_skip])
 
45
            events = []
 
46
            result = LoggingResult(events)
 
47
            suite.run(result)
 
48
            self.assertEqual(len(result.skipped), 1)
 
49
            expected = ['startTest', 'addSkip', 'stopTest',
 
50
                        'startTest', 'addSuccess', 'stopTest']
 
51
            self.assertEqual(events, expected)
 
52
            self.assertEqual(result.testsRun, 2)
 
53
            self.assertEqual(result.skipped, [(test_do_skip, "testing")])
 
54
            self.assertTrue(result.wasSuccessful())
 
55
 
 
56
    def test_skip_class(self):
 
57
        @unittest.skip("testing")
 
58
        class Foo(unittest.TestCase):
 
59
            def test_1(self):
 
60
                record.append(1)
 
61
        record = []
 
62
        result = unittest.TestResult()
 
63
        test = Foo("test_1")
 
64
        suite = unittest.TestSuite([test])
 
65
        suite.run(result)
 
66
        self.assertEqual(result.skipped, [(test, "testing")])
 
67
        self.assertEqual(record, [])
 
68
 
 
69
    def test_expected_failure(self):
 
70
        class Foo(unittest.TestCase):
 
71
            @unittest.expectedFailure
 
72
            def test_die(self):
 
73
                self.fail("help me!")
 
74
        events = []
 
75
        result = LoggingResult(events)
 
76
        test = Foo("test_die")
 
77
        test.run(result)
 
78
        self.assertEqual(events,
 
79
                         ['startTest', 'addExpectedFailure', 'stopTest'])
 
80
        self.assertEqual(result.expectedFailures[0][0], test)
 
81
        self.assertTrue(result.wasSuccessful())
 
82
 
 
83
    def test_unexpected_success(self):
 
84
        class Foo(unittest.TestCase):
 
85
            @unittest.expectedFailure
 
86
            def test_die(self):
 
87
                pass
 
88
        events = []
 
89
        result = LoggingResult(events)
 
90
        test = Foo("test_die")
 
91
        test.run(result)
 
92
        self.assertEqual(events,
 
93
                         ['startTest', 'addUnexpectedSuccess', 'stopTest'])
 
94
        self.assertFalse(result.failures)
 
95
        self.assertEqual(result.unexpectedSuccesses, [test])
 
96
        self.assertTrue(result.wasSuccessful())
 
97
 
 
98
    def test_skip_doesnt_run_setup(self):
 
99
        class Foo(unittest.TestCase):
 
100
            wasSetUp = False
 
101
            wasTornDown = False
 
102
            def setUp(self):
 
103
                Foo.wasSetUp = True
 
104
            def tornDown(self):
 
105
                Foo.wasTornDown = True
 
106
            @unittest.skip('testing')
 
107
            def test_1(self):
 
108
                pass
 
109
 
 
110
        result = unittest.TestResult()
 
111
        test = Foo("test_1")
 
112
        suite = unittest.TestSuite([test])
 
113
        suite.run(result)
 
114
        self.assertEqual(result.skipped, [(test, "testing")])
 
115
        self.assertFalse(Foo.wasSetUp)
 
116
        self.assertFalse(Foo.wasTornDown)
 
117
 
 
118
    def test_decorated_skip(self):
 
119
        def decorator(func):
 
120
            def inner(*a):
 
121
                return func(*a)
 
122
            return inner
 
123
 
 
124
        class Foo(unittest.TestCase):
 
125
            @decorator
 
126
            @unittest.skip('testing')
 
127
            def test_1(self):
 
128
                pass
 
129
 
 
130
        result = unittest.TestResult()
 
131
        test = Foo("test_1")
 
132
        suite = unittest.TestSuite([test])
 
133
        suite.run(result)
 
134
        self.assertEqual(result.skipped, [(test, "testing")])
 
135
 
 
136
 
 
137
if __name__ == '__main__':
 
138
    unittest.main()