« back to all changes in this revision
Viewing changes to unittest27/test/test_suite.py
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- 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
- files added:
- unittest27
- unittest27/test
- files modified:
- mkdb.py
added
removed
unittest27/test/test_suite.py
1
import unittest
2
3
import sys
4
from .support import LoggingResult, TestEquality
5
6
7
### Support code for Test_TestSuite
8
################################################################
9
10
class Test(object):
11
class Foo(unittest.TestCase):
12
def test_1(self): pass
13
def test_2(self): pass
14
def test_3(self): pass
15
def runTest(self): pass
16
17
def _mk_TestSuite(*names):
18
return unittest.TestSuite(Test.Foo(n) for n in names)
19
20
################################################################
21
22
23
class Test_TestSuite(unittest.TestCase, TestEquality):
24
25
### Set up attributes needed by inherited tests
26
################################################################
27
28
# Used by TestEquality.test_eq
29
eq_pairs = [(unittest.TestSuite(), unittest.TestSuite()),
30
(unittest.TestSuite(), unittest.TestSuite([])),
31
(_mk_TestSuite('test_1'), _mk_TestSuite('test_1'))]
32
33
# Used by TestEquality.test_ne
34
ne_pairs = [(unittest.TestSuite(), _mk_TestSuite('test_1')),
35
(unittest.TestSuite([]), _mk_TestSuite('test_1')),
36
(_mk_TestSuite('test_1', 'test_2'), _mk_TestSuite('test_1', 'test_3')),
37
(_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))]
38
39
################################################################
40
### /Set up attributes needed by inherited tests
41
42
### Tests for TestSuite.__init__
43
################################################################
44
45
# "class TestSuite([tests])"
46
#
47
# The tests iterable should be optional
48
def test_init__tests_optional(self):
49
suite = unittest.TestSuite()
50
51
self.assertEqual(suite.countTestCases(), 0)
52
53
# "class TestSuite([tests])"
54
# ...
55
# "If tests is given, it must be an iterable of individual test cases
56
# or other test suites that will be used to build the suite initially"
57
#
58
# TestSuite should deal with empty tests iterables by allowing the
59
# creation of an empty suite
60
def test_init__empty_tests(self):
61
suite = unittest.TestSuite([])
62
63
self.assertEqual(suite.countTestCases(), 0)
64
65
# "class TestSuite([tests])"
66
# ...
67
# "If tests is given, it must be an iterable of individual test cases
68
# or other test suites that will be used to build the suite initially"
69
#
70
# TestSuite should allow any iterable to provide tests
71
def test_init__tests_from_any_iterable(self):
72
def tests():
73
yield unittest.FunctionTestCase(lambda: None)
74
yield unittest.FunctionTestCase(lambda: None)
75
76
suite_1 = unittest.TestSuite(tests())
77
self.assertEqual(suite_1.countTestCases(), 2)
78
79
suite_2 = unittest.TestSuite(suite_1)
80
self.assertEqual(suite_2.countTestCases(), 2)
81
82
suite_3 = unittest.TestSuite(set(suite_1))
83
self.assertEqual(suite_3.countTestCases(), 2)
84
85
# "class TestSuite([tests])"
86
# ...
87
# "If tests is given, it must be an iterable of individual test cases
88
# or other test suites that will be used to build the suite initially"
89
#
90
# Does TestSuite() also allow other TestSuite() instances to be present
91
# in the tests iterable?
92
def test_init__TestSuite_instances_in_tests(self):
93
def tests():
94
ftc = unittest.FunctionTestCase(lambda: None)
95
yield unittest.TestSuite([ftc])
96
yield unittest.FunctionTestCase(lambda: None)
97
98
suite = unittest.TestSuite(tests())
99
self.assertEqual(suite.countTestCases(), 2)
100
101
################################################################
102
### /Tests for TestSuite.__init__
103
104
# Container types should support the iter protocol
105
def test_iter(self):
106
test1 = unittest.FunctionTestCase(lambda: None)
107
test2 = unittest.FunctionTestCase(lambda: None)
108
suite = unittest.TestSuite((test1, test2))
109
110
self.assertEqual(list(suite), [test1, test2])
111
112
# "Return the number of tests represented by the this test object.
113
# ...this method is also implemented by the TestSuite class, which can
114
# return larger [greater than 1] values"
115
#
116
# Presumably an empty TestSuite returns 0?
117
def test_countTestCases_zero_simple(self):
118
suite = unittest.TestSuite()
119
120
self.assertEqual(suite.countTestCases(), 0)
121
122
# "Return the number of tests represented by the this test object.
123
# ...this method is also implemented by the TestSuite class, which can
124
# return larger [greater than 1] values"
125
#
126
# Presumably an empty TestSuite (even if it contains other empty
127
# TestSuite instances) returns 0?
128
def test_countTestCases_zero_nested(self):
129
class Test1(unittest.TestCase):
130
def test(self):
131
pass
132
133
suite = unittest.TestSuite([unittest.TestSuite()])
134
135
self.assertEqual(suite.countTestCases(), 0)
136
137
# "Return the number of tests represented by the this test object.
138
# ...this method is also implemented by the TestSuite class, which can
139
# return larger [greater than 1] values"
140
def test_countTestCases_simple(self):
141
test1 = unittest.FunctionTestCase(lambda: None)
142
test2 = unittest.FunctionTestCase(lambda: None)
143
suite = unittest.TestSuite((test1, test2))
144
145
self.assertEqual(suite.countTestCases(), 2)
146
147
# "Return the number of tests represented by the this test object.
148
# ...this method is also implemented by the TestSuite class, which can
149
# return larger [greater than 1] values"
150
#
151
# Make sure this holds for nested TestSuite instances, too
152
def test_countTestCases_nested(self):
153
class Test1(unittest.TestCase):
154
def test1(self): pass
155
def test2(self): pass
156
157
test2 = unittest.FunctionTestCase(lambda: None)
158
test3 = unittest.FunctionTestCase(lambda: None)
159
child = unittest.TestSuite((Test1('test2'), test2))
160
parent = unittest.TestSuite((test3, child, Test1('test1')))
161
162
self.assertEqual(parent.countTestCases(), 4)
163
164
# "Run the tests associated with this suite, collecting the result into
165
# the test result object passed as result."
166
#
167
# And if there are no tests? What then?
168
def test_run__empty_suite(self):
169
events = []
170
result = LoggingResult(events)
171
172
suite = unittest.TestSuite()
173
174
suite.run(result)
175
176
self.assertEqual(events, [])
177
178
# "Note that unlike TestCase.run(), TestSuite.run() requires the
179
# "result object to be passed in."
180
def test_run__requires_result(self):
181
suite = unittest.TestSuite()
182
183
try:
184
suite.run()
185
except TypeError:
186
pass
187
else:
188
self.fail("Failed to raise TypeError")
189
190
# "Run the tests associated with this suite, collecting the result into
191
# the test result object passed as result."
192
def test_run(self):
193
events = []
194
result = LoggingResult(events)
195
196
class LoggingCase(unittest.TestCase):
197
def run(self, result):
198
events.append('run %s' % self._testMethodName)
199
200
def test1(self): pass
201
def test2(self): pass
202
203
tests = [LoggingCase('test1'), LoggingCase('test2')]
204
205
unittest.TestSuite(tests).run(result)
206
207
self.assertEqual(events, ['run test1', 'run test2'])
208
209
# "Add a TestCase ... to the suite"
210
def test_addTest__TestCase(self):
211
class Foo(unittest.TestCase):
212
def test(self): pass
213
214
test = Foo('test')
215
suite = unittest.TestSuite()
216
217
suite.addTest(test)
218
219
self.assertEqual(suite.countTestCases(), 1)
220
self.assertEqual(list(suite), [test])
221
222
# "Add a ... TestSuite to the suite"
223
def test_addTest__TestSuite(self):
224
class Foo(unittest.TestCase):
225
def test(self): pass
226
227
suite_2 = unittest.TestSuite([Foo('test')])
228
229
suite = unittest.TestSuite()
230
suite.addTest(suite_2)
231
232
self.assertEqual(suite.countTestCases(), 1)
233
self.assertEqual(list(suite), [suite_2])
234
235
# "Add all the tests from an iterable of TestCase and TestSuite
236
# instances to this test suite."
237
#
238
# "This is equivalent to iterating over tests, calling addTest() for
239
# each element"
240
def test_addTests(self):
241
class Foo(unittest.TestCase):
242
def test_1(self): pass
243
def test_2(self): pass
244
245
test_1 = Foo('test_1')
246
test_2 = Foo('test_2')
247
inner_suite = unittest.TestSuite([test_2])
248
249
def gen():
250
yield test_1
251
yield test_2
252
yield inner_suite
253
254
suite_1 = unittest.TestSuite()
255
suite_1.addTests(gen())
256
257
self.assertEqual(list(suite_1), list(gen()))
258
259
# "This is equivalent to iterating over tests, calling addTest() for
260
# each element"
261
suite_2 = unittest.TestSuite()
262
for t in gen():
263
suite_2.addTest(t)
264
265
self.assertEqual(suite_1, suite_2)
266
267
# "Add all the tests from an iterable of TestCase and TestSuite
268
# instances to this test suite."
269
#
270
# What happens if it doesn't get an iterable?
271
def test_addTest__noniterable(self):
272
suite = unittest.TestSuite()
273
274
try:
275
suite.addTests(5)
276
except TypeError:
277
pass
278
else:
279
self.fail("Failed to raise TypeError")
280
281
def test_addTest__noncallable(self):
282
suite = unittest.TestSuite()
283
self.assertRaises(TypeError, suite.addTest, 5)
284
285
def test_addTest__casesuiteclass(self):
286
suite = unittest.TestSuite()
287
self.assertRaises(TypeError, suite.addTest, Test_TestSuite)
288
self.assertRaises(TypeError, suite.addTest, unittest.TestSuite)
289
290
def test_addTests__string(self):
291
suite = unittest.TestSuite()
292
self.assertRaises(TypeError, suite.addTests, "foo")
293
294
def test_function_in_suite(self):
295
def f(_):
296
pass
297
suite = unittest.TestSuite()
298
suite.addTest(f)
299
300
# when the bug is fixed this line will not crash
301
suite.run(unittest.TestResult())
302
303
304
305
def test_basetestsuite(self):
306
class Test(unittest.TestCase):
307
wasSetUp = False
308
wasTornDown = False
309
@classmethod
310
def setUpClass(cls):
311
cls.wasSetUp = True
312
@classmethod
313
def tearDownClass(cls):
314
cls.wasTornDown = True
315
def testPass(self):
316
pass
317
def testFail(self):
318
fail
319
class Module(object):
320
wasSetUp = False
321
wasTornDown = False
322
@staticmethod
323
def setUpModule():
324
Module.wasSetUp = True
325
@staticmethod
326
def tearDownModule():
327
Module.wasTornDown = True
328
329
Test.__module__ = 'Module'
330
sys.modules['Module'] = Module
331
self.addCleanup(sys.modules.pop, 'Module')
332
333
suite = unittest.BaseTestSuite()
334
suite.addTests([Test('testPass'), Test('testFail')])
335
self.assertEqual(suite.countTestCases(), 2)
336
337
result = unittest.TestResult()
338
suite.run(result)
339
self.assertFalse(Module.wasSetUp)
340
self.assertFalse(Module.wasTornDown)
341
self.assertFalse(Test.wasSetUp)
342
self.assertFalse(Test.wasTornDown)
343
self.assertEqual(len(result.errors), 1)
344
self.assertEqual(len(result.failures), 0)
345
self.assertEqual(result.testsRun, 2)
346
347
348
def test_overriding_call(self):
349
class MySuite(unittest.TestSuite):
350
called = False
351
def __call__(self, *args, **kw):
352
self.called = True
353
unittest.TestSuite.__call__(self, *args, **kw)
354
355
suite = MySuite()
356
result = unittest.TestResult()
357
wrapper = unittest.TestSuite()
358
wrapper.addTest(suite)
359
wrapper(result)
360
self.assertTrue(suite.called)
361
362
# reusing results should be permitted even if abominable
363
self.assertFalse(result._testRunEntered)
364
365
366
if __name__ == '__main__':
367
unittest.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1