« back to all changes in this revision
Viewing changes to unittest27/test/test_result.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_result.py
1
import sys
2
import textwrap
3
from StringIO import StringIO
4
from test import test_support
5
6
import traceback
7
import unittest
8
9
10
class Test_TestResult(unittest.TestCase):
11
# Note: there are not separate tests for TestResult.wasSuccessful(),
12
# TestResult.errors, TestResult.failures, TestResult.testsRun or
13
# TestResult.shouldStop because these only have meaning in terms of
14
# other TestResult methods.
15
#
16
# Accordingly, tests for the aforenamed attributes are incorporated
17
# in with the tests for the defining methods.
18
################################################################
19
20
def test_init(self):
21
result = unittest.TestResult()
22
23
self.assertTrue(result.wasSuccessful())
24
self.assertEqual(len(result.errors), 0)
25
self.assertEqual(len(result.failures), 0)
26
self.assertEqual(result.testsRun, 0)
27
self.assertEqual(result.shouldStop, False)
28
self.assertIsNone(result._stdout_buffer)
29
self.assertIsNone(result._stderr_buffer)
30
31
32
# "This method can be called to signal that the set of tests being
33
# run should be aborted by setting the TestResult's shouldStop
34
# attribute to True."
35
def test_stop(self):
36
result = unittest.TestResult()
37
38
result.stop()
39
40
self.assertEqual(result.shouldStop, True)
41
42
# "Called when the test case test is about to be run. The default
43
# implementation simply increments the instance's testsRun counter."
44
def test_startTest(self):
45
class Foo(unittest.TestCase):
46
def test_1(self):
47
pass
48
49
test = Foo('test_1')
50
51
result = unittest.TestResult()
52
53
result.startTest(test)
54
55
self.assertTrue(result.wasSuccessful())
56
self.assertEqual(len(result.errors), 0)
57
self.assertEqual(len(result.failures), 0)
58
self.assertEqual(result.testsRun, 1)
59
self.assertEqual(result.shouldStop, False)
60
61
result.stopTest(test)
62
63
# "Called after the test case test has been executed, regardless of
64
# the outcome. The default implementation does nothing."
65
def test_stopTest(self):
66
class Foo(unittest.TestCase):
67
def test_1(self):
68
pass
69
70
test = Foo('test_1')
71
72
result = unittest.TestResult()
73
74
result.startTest(test)
75
76
self.assertTrue(result.wasSuccessful())
77
self.assertEqual(len(result.errors), 0)
78
self.assertEqual(len(result.failures), 0)
79
self.assertEqual(result.testsRun, 1)
80
self.assertEqual(result.shouldStop, False)
81
82
result.stopTest(test)
83
84
# Same tests as above; make sure nothing has changed
85
self.assertTrue(result.wasSuccessful())
86
self.assertEqual(len(result.errors), 0)
87
self.assertEqual(len(result.failures), 0)
88
self.assertEqual(result.testsRun, 1)
89
self.assertEqual(result.shouldStop, False)
90
91
# "Called before and after tests are run. The default implementation does nothing."
92
def test_startTestRun_stopTestRun(self):
93
result = unittest.TestResult()
94
result.startTestRun()
95
result.stopTestRun()
96
97
# "addSuccess(test)"
98
# ...
99
# "Called when the test case test succeeds"
100
# ...
101
# "wasSuccessful() - Returns True if all tests run so far have passed,
102
# otherwise returns False"
103
# ...
104
# "testsRun - The total number of tests run so far."
105
# ...
106
# "errors - A list containing 2-tuples of TestCase instances and
107
# formatted tracebacks. Each tuple represents a test which raised an
108
# unexpected exception. Contains formatted
109
# tracebacks instead of sys.exc_info() results."
110
# ...
111
# "failures - A list containing 2-tuples of TestCase instances and
112
# formatted tracebacks. Each tuple represents a test where a failure was
113
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
114
# methods. Contains formatted tracebacks instead
115
# of sys.exc_info() results."
116
def test_addSuccess(self):
117
class Foo(unittest.TestCase):
118
def test_1(self):
119
pass
120
121
test = Foo('test_1')
122
123
result = unittest.TestResult()
124
125
result.startTest(test)
126
result.addSuccess(test)
127
result.stopTest(test)
128
129
self.assertTrue(result.wasSuccessful())
130
self.assertEqual(len(result.errors), 0)
131
self.assertEqual(len(result.failures), 0)
132
self.assertEqual(result.testsRun, 1)
133
self.assertEqual(result.shouldStop, False)
134
135
# "addFailure(test, err)"
136
# ...
137
# "Called when the test case test signals a failure. err is a tuple of
138
# the form returned by sys.exc_info(): (type, value, traceback)"
139
# ...
140
# "wasSuccessful() - Returns True if all tests run so far have passed,
141
# otherwise returns False"
142
# ...
143
# "testsRun - The total number of tests run so far."
144
# ...
145
# "errors - A list containing 2-tuples of TestCase instances and
146
# formatted tracebacks. Each tuple represents a test which raised an
147
# unexpected exception. Contains formatted
148
# tracebacks instead of sys.exc_info() results."
149
# ...
150
# "failures - A list containing 2-tuples of TestCase instances and
151
# formatted tracebacks. Each tuple represents a test where a failure was
152
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
153
# methods. Contains formatted tracebacks instead
154
# of sys.exc_info() results."
155
def test_addFailure(self):
156
class Foo(unittest.TestCase):
157
def test_1(self):
158
pass
159
160
test = Foo('test_1')
161
try:
162
test.fail("foo")
163
except:
164
exc_info_tuple = sys.exc_info()
165
166
result = unittest.TestResult()
167
168
result.startTest(test)
169
result.addFailure(test, exc_info_tuple)
170
result.stopTest(test)
171
172
self.assertFalse(result.wasSuccessful())
173
self.assertEqual(len(result.errors), 0)
174
self.assertEqual(len(result.failures), 1)
175
self.assertEqual(result.testsRun, 1)
176
self.assertEqual(result.shouldStop, False)
177
178
test_case, formatted_exc = result.failures[0]
179
self.assertTrue(test_case is test)
180
self.assertIsInstance(formatted_exc, str)
181
182
# "addError(test, err)"
183
# ...
184
# "Called when the test case test raises an unexpected exception err
185
# is a tuple of the form returned by sys.exc_info():
186
# (type, value, traceback)"
187
# ...
188
# "wasSuccessful() - Returns True if all tests run so far have passed,
189
# otherwise returns False"
190
# ...
191
# "testsRun - The total number of tests run so far."
192
# ...
193
# "errors - A list containing 2-tuples of TestCase instances and
194
# formatted tracebacks. Each tuple represents a test which raised an
195
# unexpected exception. Contains formatted
196
# tracebacks instead of sys.exc_info() results."
197
# ...
198
# "failures - A list containing 2-tuples of TestCase instances and
199
# formatted tracebacks. Each tuple represents a test where a failure was
200
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
201
# methods. Contains formatted tracebacks instead
202
# of sys.exc_info() results."
203
def test_addError(self):
204
class Foo(unittest.TestCase):
205
def test_1(self):
206
pass
207
208
test = Foo('test_1')
209
try:
210
raise TypeError()
211
except:
212
exc_info_tuple = sys.exc_info()
213
214
result = unittest.TestResult()
215
216
result.startTest(test)
217
result.addError(test, exc_info_tuple)
218
result.stopTest(test)
219
220
self.assertFalse(result.wasSuccessful())
221
self.assertEqual(len(result.errors), 1)
222
self.assertEqual(len(result.failures), 0)
223
self.assertEqual(result.testsRun, 1)
224
self.assertEqual(result.shouldStop, False)
225
226
test_case, formatted_exc = result.errors[0]
227
self.assertTrue(test_case is test)
228
self.assertIsInstance(formatted_exc, str)
229
230
def testGetDescriptionWithoutDocstring(self):
231
result = unittest.TextTestResult(None, True, 1)
232
self.assertEqual(
233
result.getDescription(self),
234
'testGetDescriptionWithoutDocstring (' + __name__ +
235
'.Test_TestResult)')
236
237
@unittest.skipIf(sys.flags.optimize >= 2,
238
"Docstrings are omitted with -O2 and above")
239
def testGetDescriptionWithOneLineDocstring(self):
240
"""Tests getDescription() for a method with a docstring."""
241
result = unittest.TextTestResult(None, True, 1)
242
self.assertEqual(
243
result.getDescription(self),
244
('testGetDescriptionWithOneLineDocstring '
245
'(' + __name__ + '.Test_TestResult)\n'
246
'Tests getDescription() for a method with a docstring.'))
247
248
@unittest.skipIf(sys.flags.optimize >= 2,
249
"Docstrings are omitted with -O2 and above")
250
def testGetDescriptionWithMultiLineDocstring(self):
251
"""Tests getDescription() for a method with a longer docstring.
252
The second line of the docstring.
253
"""
254
result = unittest.TextTestResult(None, True, 1)
255
self.assertEqual(
256
result.getDescription(self),
257
('testGetDescriptionWithMultiLineDocstring '
258
'(' + __name__ + '.Test_TestResult)\n'
259
'Tests getDescription() for a method with a longer '
260
'docstring.'))
261
262
def testStackFrameTrimming(self):
263
class Frame(object):
264
class tb_frame(object):
265
f_globals = {}
266
result = unittest.TestResult()
267
self.assertFalse(result._is_relevant_tb_level(Frame))
268
269
Frame.tb_frame.f_globals['__unittest'] = True
270
self.assertTrue(result._is_relevant_tb_level(Frame))
271
272
def testFailFast(self):
273
result = unittest.TestResult()
274
result._exc_info_to_string = lambda *_: ''
275
result.failfast = True
276
result.addError(None, None)
277
self.assertTrue(result.shouldStop)
278
279
result = unittest.TestResult()
280
result._exc_info_to_string = lambda *_: ''
281
result.failfast = True
282
result.addFailure(None, None)
283
self.assertTrue(result.shouldStop)
284
285
result = unittest.TestResult()
286
result._exc_info_to_string = lambda *_: ''
287
result.failfast = True
288
result.addUnexpectedSuccess(None)
289
self.assertTrue(result.shouldStop)
290
291
def testFailFastSetByRunner(self):
292
runner = unittest.TextTestRunner(stream=StringIO(), failfast=True)
293
def test(result):
294
self.assertTrue(result.failfast)
295
runner.run(test)
296
297
298
classDict = dict(unittest.TestResult.__dict__)
299
for m in ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess',
300
'__init__'):
301
del classDict[m]
302
303
def __init__(self, stream=None, descriptions=None, verbosity=None):
304
self.failures = []
305
self.errors = []
306
self.testsRun = 0
307
self.shouldStop = False
308
self.buffer = False
309
310
classDict['__init__'] = __init__
311
OldResult = type('OldResult', (object,), classDict)
312
313
class Test_OldTestResult(unittest.TestCase):
314
315
def assertOldResultWarning(self, test, failures):
316
with test_support.check_warnings(("TestResult has no add.+ method,",
317
RuntimeWarning)):
318
result = OldResult()
319
test.run(result)
320
self.assertEqual(len(result.failures), failures)
321
322
def testOldTestResult(self):
323
class Test(unittest.TestCase):
324
def testSkip(self):
325
self.skipTest('foobar')
326
@unittest.expectedFailure
327
def testExpectedFail(self):
328
raise TypeError
329
@unittest.expectedFailure
330
def testUnexpectedSuccess(self):
331
pass
332
333
for test_name, should_pass in (('testSkip', True),
334
('testExpectedFail', True),
335
('testUnexpectedSuccess', False)):
336
test = Test(test_name)
337
self.assertOldResultWarning(test, int(not should_pass))
338
339
def testOldTestTesultSetup(self):
340
class Test(unittest.TestCase):
341
def setUp(self):
342
self.skipTest('no reason')
343
def testFoo(self):
344
pass
345
self.assertOldResultWarning(Test('testFoo'), 0)
346
347
def testOldTestResultClass(self):
348
@unittest.skip('no reason')
349
class Test(unittest.TestCase):
350
def testFoo(self):
351
pass
352
self.assertOldResultWarning(Test('testFoo'), 0)
353
354
def testOldResultWithRunner(self):
355
class Test(unittest.TestCase):
356
def testFoo(self):
357
pass
358
runner = unittest.TextTestRunner(resultclass=OldResult,
359
stream=StringIO())
360
# This will raise an exception if TextTestRunner can't handle old
361
# test result objects
362
runner.run(Test('testFoo'))
363
364
365
class MockTraceback(object):
366
@staticmethod
367
def format_exception(*_):
368
return ['A traceback']
369
370
def restore_traceback():
371
unittest.result.traceback = traceback
372
373
374
class TestOutputBuffering(unittest.TestCase):
375
376
def setUp(self):
377
self._real_out = sys.stdout
378
self._real_err = sys.stderr
379
380
def tearDown(self):
381
sys.stdout = self._real_out
382
sys.stderr = self._real_err
383
384
def testBufferOutputOff(self):
385
real_out = self._real_out
386
real_err = self._real_err
387
388
result = unittest.TestResult()
389
self.assertFalse(result.buffer)
390
391
self.assertIs(real_out, sys.stdout)
392
self.assertIs(real_err, sys.stderr)
393
394
result.startTest(self)
395
396
self.assertIs(real_out, sys.stdout)
397
self.assertIs(real_err, sys.stderr)
398
399
def testBufferOutputStartTestAddSuccess(self):
400
real_out = self._real_out
401
real_err = self._real_err
402
403
result = unittest.TestResult()
404
self.assertFalse(result.buffer)
405
406
result.buffer = True
407
408
self.assertIs(real_out, sys.stdout)
409
self.assertIs(real_err, sys.stderr)
410
411
result.startTest(self)
412
413
self.assertIsNot(real_out, sys.stdout)
414
self.assertIsNot(real_err, sys.stderr)
415
self.assertIsInstance(sys.stdout, StringIO)
416
self.assertIsInstance(sys.stderr, StringIO)
417
self.assertIsNot(sys.stdout, sys.stderr)
418
419
out_stream = sys.stdout
420
err_stream = sys.stderr
421
422
result._original_stdout = StringIO()
423
result._original_stderr = StringIO()
424
425
print 'foo'
426
print >> sys.stderr, 'bar'
427
428
self.assertEqual(out_stream.getvalue(), 'foo\n')
429
self.assertEqual(err_stream.getvalue(), 'bar\n')
430
431
self.assertEqual(result._original_stdout.getvalue(), '')
432
self.assertEqual(result._original_stderr.getvalue(), '')
433
434
result.addSuccess(self)
435
result.stopTest(self)
436
437
self.assertIs(sys.stdout, result._original_stdout)
438
self.assertIs(sys.stderr, result._original_stderr)
439
440
self.assertEqual(result._original_stdout.getvalue(), '')
441
self.assertEqual(result._original_stderr.getvalue(), '')
442
443
self.assertEqual(out_stream.getvalue(), '')
444
self.assertEqual(err_stream.getvalue(), '')
445
446
447
def getStartedResult(self):
448
result = unittest.TestResult()
449
result.buffer = True
450
result.startTest(self)
451
return result
452
453
def testBufferOutputAddErrorOrFailure(self):
454
unittest.result.traceback = MockTraceback
455
self.addCleanup(restore_traceback)
456
457
for message_attr, add_attr, include_error in [
458
('errors', 'addError', True),
459
('failures', 'addFailure', False),
460
('errors', 'addError', True),
461
('failures', 'addFailure', False)
462
]:
463
result = self.getStartedResult()
464
buffered_out = sys.stdout
465
buffered_err = sys.stderr
466
result._original_stdout = StringIO()
467
result._original_stderr = StringIO()
468
469
print >> sys.stdout, 'foo'
470
if include_error:
471
print >> sys.stderr, 'bar'
472
473
474
addFunction = getattr(result, add_attr)
475
addFunction(self, (None, None, None))
476
result.stopTest(self)
477
478
result_list = getattr(result, message_attr)
479
self.assertEqual(len(result_list), 1)
480
481
test, message = result_list[0]
482
expectedOutMessage = textwrap.dedent("""
483
Stdout:
484
foo
485
""")
486
expectedErrMessage = ''
487
if include_error:
488
expectedErrMessage = textwrap.dedent("""
489
Stderr:
490
bar
491
""")
492
expectedFullMessage = 'A traceback%s%s' % (expectedOutMessage, expectedErrMessage)
493
494
self.assertIs(test, self)
495
self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage)
496
self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage)
497
self.assertMultiLineEqual(message, expectedFullMessage)
498
499
def testBufferSetupClass(self):
500
result = unittest.TestResult()
501
result.buffer = True
502
503
class Foo(unittest.TestCase):
504
@classmethod
505
def setUpClass(cls):
506
1//0
507
def test_foo(self):
508
pass
509
suite = unittest.TestSuite([Foo('test_foo')])
510
suite(result)
511
self.assertEqual(len(result.errors), 1)
512
513
def testBufferTearDownClass(self):
514
result = unittest.TestResult()
515
result.buffer = True
516
517
class Foo(unittest.TestCase):
518
@classmethod
519
def tearDownClass(cls):
520
1//0
521
def test_foo(self):
522
pass
523
suite = unittest.TestSuite([Foo('test_foo')])
524
suite(result)
525
self.assertEqual(len(result.errors), 1)
526
527
def testBufferSetUpModule(self):
528
result = unittest.TestResult()
529
result.buffer = True
530
531
class Foo(unittest.TestCase):
532
def test_foo(self):
533
pass
534
class Module(object):
535
@staticmethod
536
def setUpModule():
537
1//0
538
539
Foo.__module__ = 'Module'
540
sys.modules['Module'] = Module
541
self.addCleanup(sys.modules.pop, 'Module')
542
suite = unittest.TestSuite([Foo('test_foo')])
543
suite(result)
544
self.assertEqual(len(result.errors), 1)
545
546
def testBufferTearDownModule(self):
547
result = unittest.TestResult()
548
result.buffer = True
549
550
class Foo(unittest.TestCase):
551
def test_foo(self):
552
pass
553
class Module(object):
554
@staticmethod
555
def tearDownModule():
556
1//0
557
558
Foo.__module__ = 'Module'
559
sys.modules['Module'] = Module
560
self.addCleanup(sys.modules.pop, 'Module')
561
suite = unittest.TestSuite([Foo('test_foo')])
562
suite(result)
563
self.assertEqual(len(result.errors), 1)
564
565
566
if __name__ == '__main__':
567
unittest.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1