Debian Codegraph @

Lib/test/test_unittest/test_program.py

raw
1 import os
2 import sys
3 import subprocess
4 from test import support
5 import unittest
6 import test.test_unittest
7 from test.test_unittest.test_result import BufferedWriter
8
9
10 @support.force_not_colorized_test_class
11 class Test_TestProgram(unittest.TestCase):
12
13 def test_discovery_from_dotted_path(self):
14 loader = unittest.TestLoader()
15
16 tests = [self]
17 expectedPath = os.path.abspath(os.path.dirname(test.test_unittest.__file__))
18
19 self.wasRun = False
20 def _find_tests(start_dir, pattern):
21 self.wasRun = True
22 self.assertEqual(start_dir, expectedPath)
23 return tests
24 loader._find_tests = _find_tests
25 suite = loader.discover('test.test_unittest')
26 self.assertTrue(self.wasRun)
27 self.assertEqual(suite._tests, tests)
28
29 # Horrible white box test
30 def testNoExit(self):
31 result = object()
32 test = object()
33
34 class FakeRunner(object):
35 def run(self, test):
36 self.test = test
37 return result
38
39 runner = FakeRunner()
40
41 oldParseArgs = unittest.TestProgram.parseArgs
42 def restoreParseArgs():
43 unittest.TestProgram.parseArgs = oldParseArgs
44 unittest.TestProgram.parseArgs = lambda *args: None
45 self.addCleanup(restoreParseArgs)
46
47 def removeTest():
48 del unittest.TestProgram.test
49 unittest.TestProgram.test = test
50 self.addCleanup(removeTest)
51
52 program = unittest.TestProgram(testRunner=runner, exit=False, verbosity=2)
53
54 self.assertEqual(program.result, result)
55 self.assertEqual(runner.test, test)
56 self.assertEqual(program.verbosity, 2)
57
58 class FooBar(unittest.TestCase):
59 def testPass(self):
60 pass
61 def testFail(self):
62 raise AssertionError
63 def testError(self):
64 1/0
65 @unittest.skip('skipping')
66 def testSkipped(self):
67 raise AssertionError
68 @unittest.expectedFailure
69 def testExpectedFailure(self):
70 raise AssertionError
71 @unittest.expectedFailure
72 def testUnexpectedSuccess(self):
73 pass
74
75 class Empty(unittest.TestCase):
76 pass
77
78 class SetUpClassFailure(unittest.TestCase):
79 @classmethod
80 def setUpClass(cls):
81 super().setUpClass()
82 raise Exception
83 def testPass(self):
84 pass
85
86 class TestLoader(unittest.TestLoader):
87 """Test loader that returns a suite containing the supplied testcase."""
88
89 def __init__(self, testcase):
90 self.testcase = testcase
91
92 def loadTestsFromModule(self, module):
93 return self.suiteClass(
94 [self.loadTestsFromTestCase(self.testcase)])
95
96 def loadTestsFromNames(self, names, module):
97 return self.suiteClass(
98 [self.loadTestsFromTestCase(self.testcase)])
99
100 def test_defaultTest_with_string(self):
101 class FakeRunner(object):
102 def run(self, test):
103 self.test = test
104 return True
105
106 old_argv = sys.argv
107 sys.argv = ['faketest']
108 runner = FakeRunner()
109 program = unittest.TestProgram(testRunner=runner, exit=False,
110 defaultTest='test.test_unittest',
111 testLoader=self.TestLoader(self.FooBar))
112 sys.argv = old_argv
113 self.assertEqual(('test.test_unittest',), program.testNames)
114
115 def test_defaultTest_with_iterable(self):
116 class FakeRunner(object):
117 def run(self, test):
118 self.test = test
119 return True
120
121 old_argv = sys.argv
122 sys.argv = ['faketest']
123 runner = FakeRunner()
124 program = unittest.TestProgram(
125 testRunner=runner, exit=False,
126 defaultTest=['test.test_unittest', 'test.test_unittest2'],
127 testLoader=self.TestLoader(self.FooBar))
128 sys.argv = old_argv
129 self.assertEqual(['test.test_unittest', 'test.test_unittest2'],
130 program.testNames)
131
132 def test_NonExit(self):
133 stream = BufferedWriter()
134 program = unittest.main(exit=False,
135 argv=["foobar"],
136 testRunner=unittest.TextTestRunner(stream=stream),
137 testLoader=self.TestLoader(self.FooBar))
138 self.assertHasAttr(program, 'result')
139 out = stream.getvalue()
140 self.assertIn('\nFAIL: testFail ', out)
141 self.assertIn('\nERROR: testError ', out)
142 self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
143 expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
144 'expected failures=1, unexpected successes=1)\n')
145 self.assertEndsWith(out, expected)
146
147 def test_Exit(self):
148 stream = BufferedWriter()
149 with self.assertRaises(SystemExit) as cm:
150 unittest.main(
151 argv=["foobar"],
152 testRunner=unittest.TextTestRunner(stream=stream),
153 exit=True,
154 testLoader=self.TestLoader(self.FooBar))
155 self.assertEqual(cm.exception.code, 1)
156 out = stream.getvalue()
157 self.assertIn('\nFAIL: testFail ', out)
158 self.assertIn('\nERROR: testError ', out)
159 self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
160 expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
161 'expected failures=1, unexpected successes=1)\n')
162 self.assertEndsWith(out, expected)
163
164 def test_ExitAsDefault(self):
165 stream = BufferedWriter()
166 with self.assertRaises(SystemExit):
167 unittest.main(
168 argv=["foobar"],
169 testRunner=unittest.TextTestRunner(stream=stream),
170 testLoader=self.TestLoader(self.FooBar))
171 out = stream.getvalue()
172 self.assertIn('\nFAIL: testFail ', out)
173 self.assertIn('\nERROR: testError ', out)
174 self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
175 expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
176 'expected failures=1, unexpected successes=1)\n')
177 self.assertEndsWith(out, expected)
178
179 def test_ExitSkippedSuite(self):
180 stream = BufferedWriter()
181 with self.assertRaises(SystemExit) as cm:
182 unittest.main(
183 argv=["foobar", "-k", "testSkipped"],
184 testRunner=unittest.TextTestRunner(stream=stream),
185 testLoader=self.TestLoader(self.FooBar))
186 self.assertEqual(cm.exception.code, 0)
187 out = stream.getvalue()
188 expected = '\n\nOK (skipped=1)\n'
189 self.assertEndsWith(out, expected)
190
191 def test_ExitEmptySuite(self):
192 stream = BufferedWriter()
193 with self.assertRaises(SystemExit) as cm:
194 unittest.main(
195 argv=["empty"],
196 testRunner=unittest.TextTestRunner(stream=stream),
197 testLoader=self.TestLoader(self.Empty))
198 self.assertEqual(cm.exception.code, 5)
199 out = stream.getvalue()
200 self.assertIn('\nNO TESTS RAN\n', out)
201
202 def test_ExitSetUpClassFailureSuite(self):
203 stream = BufferedWriter()
204 with self.assertRaises(SystemExit) as cm:
205 unittest.main(
206 argv=["setup_class_failure"],
207 testRunner=unittest.TextTestRunner(stream=stream),
208 testLoader=self.TestLoader(self.SetUpClassFailure))
209 self.assertEqual(cm.exception.code, 1)
210 out = stream.getvalue()
211 self.assertIn("ERROR: setUpClass", out)
212 self.assertIn("SetUpClassFailure", out)
213
214
215 class InitialisableProgram(unittest.TestProgram):
216 exit = False
217 result = None
218 verbosity = 1
219 defaultTest = None
220 tb_locals = False
221 testRunner = None
222 testLoader = unittest.defaultTestLoader
223 module = '__main__'
224 progName = 'test'
225 test = 'test'
226 def __init__(self, *args):
227 pass
228
229 RESULT = object()
230
231 class FakeRunner(object):
232 initArgs = None
233 test = None
234 raiseError = 0
235
236 def __init__(self, **kwargs):
237 FakeRunner.initArgs = kwargs
238 if FakeRunner.raiseError:
239 FakeRunner.raiseError -= 1
240 raise TypeError
241
242 def run(self, test):
243 FakeRunner.test = test
244 return RESULT
245
246
247 @support.requires_subprocess()
248 class TestCommandLineArgs(unittest.TestCase):
249
250 def setUp(self):
251 self.program = InitialisableProgram()
252 self.program.createTests = lambda: None
253 FakeRunner.initArgs = None
254 FakeRunner.test = None
255 FakeRunner.raiseError = 0
256
257 def testVerbosity(self):
258 program = self.program
259
260 for opt in '-q', '--quiet':
261 program.verbosity = 1
262 program.parseArgs([None, opt])
263 self.assertEqual(program.verbosity, 0)
264
265 for opt in '-v', '--verbose':
266 program.verbosity = 1
267 program.parseArgs([None, opt])
268 self.assertEqual(program.verbosity, 2)
269
270 def testBufferCatchFailfast(self):
271 program = self.program
272 for arg, attr in (('buffer', 'buffer'), ('failfast', 'failfast'),
273 ('catch', 'catchbreak')):
274
275 setattr(program, attr, None)
276 program.parseArgs([None])
277 self.assertIs(getattr(program, attr), False)
278
279 false = []
280 setattr(program, attr, false)
281 program.parseArgs([None])
282 self.assertIs(getattr(program, attr), false)
283
284 true = [42]
285 setattr(program, attr, true)
286 program.parseArgs([None])
287 self.assertIs(getattr(program, attr), true)
288
289 short_opt = '-%s' % arg[0]
290 long_opt = '--%s' % arg
291 for opt in short_opt, long_opt:
292 setattr(program, attr, None)
293 program.parseArgs([None, opt])
294 self.assertIs(getattr(program, attr), True)
295
296 setattr(program, attr, False)
297 with support.captured_stderr() as stderr, \
298 self.assertRaises(SystemExit) as cm:
299 program.parseArgs([None, opt])
300 self.assertEqual(cm.exception.args, (2,))
301
302 setattr(program, attr, True)
303 with support.captured_stderr() as stderr, \
304 self.assertRaises(SystemExit) as cm:
305 program.parseArgs([None, opt])
306 self.assertEqual(cm.exception.args, (2,))
307
308 def testWarning(self):
309 """Test the warnings argument"""
310 # see #10535
311 class FakeTP(unittest.TestProgram):
312 def parseArgs(self, *args, **kw): pass
313 def runTests(self, *args, **kw): pass
314 warnoptions = sys.warnoptions[:]
315 try:
316 sys.warnoptions[:] = []
317 # no warn options, no arg -> default
318 self.assertEqual(FakeTP().warnings, 'default')
319 # no warn options, w/ arg -> arg value
320 self.assertEqual(FakeTP(warnings='ignore').warnings, 'ignore')
321 sys.warnoptions[:] = ['somevalue']
322 # warn options, no arg -> None
323 # warn options, w/ arg -> arg value
324 self.assertEqual(FakeTP().warnings, None)
325 self.assertEqual(FakeTP(warnings='ignore').warnings, 'ignore')
326 finally:
327 sys.warnoptions[:] = warnoptions
328
329 def testRunTestsRunnerClass(self):
330 program = self.program
331
332 program.testRunner = FakeRunner
333 program.verbosity = 'verbosity'
334 program.failfast = 'failfast'
335 program.buffer = 'buffer'
336 program.warnings = 'warnings'
337 program.durations = '5'
338
339 program.runTests()
340
341 self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity',
342 'failfast': 'failfast',
343 'buffer': 'buffer',
344 'tb_locals': False,
345 'warnings': 'warnings',
346 'durations': '5'})
347 self.assertEqual(FakeRunner.test, 'test')
348 self.assertIs(program.result, RESULT)
349
350 def testRunTestsRunnerInstance(self):
351 program = self.program
352
353 program.testRunner = FakeRunner()
354 FakeRunner.initArgs = None
355
356 program.runTests()
357
358 # A new FakeRunner should not have been instantiated
359 self.assertIsNone(FakeRunner.initArgs)
360
361 self.assertEqual(FakeRunner.test, 'test')
362 self.assertIs(program.result, RESULT)
363
364 def test_locals(self):
365 program = self.program
366
367 program.testRunner = FakeRunner
368 program.parseArgs([None, '--locals'])
369 self.assertEqual(True, program.tb_locals)
370 program.runTests()
371 self.assertEqual(FakeRunner.initArgs, {'buffer': False,
372 'failfast': False,
373 'tb_locals': True,
374 'verbosity': 1,
375 'warnings': None,
376 'durations': None})
377
378 def testRunTestsOldRunnerClass(self):
379 program = self.program
380
381 # Two TypeErrors are needed to fall all the way back to old-style
382 # runners - one to fail tb_locals, one to fail buffer etc.
383 FakeRunner.raiseError = 2
384 program.testRunner = FakeRunner
385 program.verbosity = 'verbosity'
386 program.failfast = 'failfast'
387 program.buffer = 'buffer'
388 program.test = 'test'
389 program.durations = '0'
390
391 program.runTests()
392
393 # If initialising raises a type error it should be retried
394 # without the new keyword arguments
395 self.assertEqual(FakeRunner.initArgs, {})
396 self.assertEqual(FakeRunner.test, 'test')
397 self.assertIs(program.result, RESULT)
398
399 def testCatchBreakInstallsHandler(self):
400 module = sys.modules['unittest.main']
401 original = module.installHandler
402 def restore():
403 module.installHandler = original
404 self.addCleanup(restore)
405
406 self.installed = False
407 def fakeInstallHandler():
408 self.installed = True
409 module.installHandler = fakeInstallHandler
410
411 program = self.program
412 program.catchbreak = True
413 program.durations = None
414
415 program.testRunner = FakeRunner
416
417 program.runTests()
418 self.assertTrue(self.installed)
419
420 def _patch_isfile(self, names, exists=True):
421 def isfile(path):
422 return path in names
423 original = os.path.isfile
424 os.path.isfile = isfile
425 def restore():
426 os.path.isfile = original
427 self.addCleanup(restore)
428
429
430 def testParseArgsFileNames(self):
431 # running tests with filenames instead of module names
432 program = self.program
433 argv = ['progname', 'foo.py', 'bar.Py', 'baz.PY', 'wing.txt']
434 self._patch_isfile(argv)
435
436 program.createTests = lambda: None
437 program.parseArgs(argv)
438
439 # note that 'wing.txt' is not a Python file so the name should
440 # *not* be converted to a module name
441 expected = ['foo', 'bar', 'baz', 'wing.txt']
442 self.assertEqual(program.testNames, expected)
443
444
445 def testParseArgsFilePaths(self):
446 program = self.program
447 argv = ['progname', 'foo/bar/baz.py', 'green\\red.py']
448 self._patch_isfile(argv)
449
450 program.createTests = lambda: None
451 program.parseArgs(argv)
452
453 expected = ['foo.bar.baz', 'green.red']
454 self.assertEqual(program.testNames, expected)
455
456
457 def testParseArgsNonExistentFiles(self):
458 program = self.program
459 argv = ['progname', 'foo/bar/baz.py', 'green\\red.py']
460 self._patch_isfile([])
461
462 program.createTests = lambda: None
463 program.parseArgs(argv)
464
465 self.assertEqual(program.testNames, argv[1:])
466
467 def testParseArgsAbsolutePathsThatCanBeConverted(self):
468 cur_dir = os.getcwd()
469 program = self.program
470 def _join(name):
471 return os.path.join(cur_dir, name)
472 argv = ['progname', _join('foo/bar/baz.py'), _join('green\\red.py')]
473 self._patch_isfile(argv)
474
475 program.createTests = lambda: None
476 program.parseArgs(argv)
477
478 expected = ['foo.bar.baz', 'green.red']
479 self.assertEqual(program.testNames, expected)
480
481 def testParseArgsAbsolutePathsThatCannotBeConverted(self):
482 program = self.program
483 drive = os.path.splitdrive(os.getcwd())[0]
484 argv = ['progname', f'{drive}/foo/bar/baz.py', f'{drive}/green/red.py']
485 self._patch_isfile(argv)
486
487 program.createTests = lambda: None
488 program.parseArgs(argv)
489
490 self.assertEqual(program.testNames, argv[1:])
491
492 # it may be better to use platform specific functions to normalise paths
493 # rather than accepting '.PY' and '\' as file separator on Linux / Mac
494 # it would also be better to check that a filename is a valid module
495 # identifier (we have a regex for this in loader.py)
496 # for invalid filenames should we raise a useful error rather than
497 # leaving the current error message (import of filename fails) in place?
498
499 def testParseArgsSelectedTestNames(self):
500 program = self.program
501 argv = ['progname', '-k', 'foo', '-k', 'bar', '-k', '*pat*']
502
503 program.createTests = lambda: None
504 program.parseArgs(argv)
505
506 self.assertEqual(program.testNamePatterns, ['*foo*', '*bar*', '*pat*'])
507
508 def testSelectedTestNamesFunctionalTest(self):
509 def run_unittest(args):
510 # Use -E to ignore PYTHONSAFEPATH env var
511 cmd = [sys.executable, '-E', '-m', 'unittest'] + args
512 p = subprocess.Popen(cmd,
513 stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, cwd=os.path.dirname(__file__))
514 with p:
515 _, stderr = p.communicate()
516 return stderr.decode()
517
518 t = '_test_warnings'
519 self.assertIn('Ran 5 tests', run_unittest([t]))
520 self.assertIn('Ran 5 tests', run_unittest(['-k', 'TestWarnings', t]))
521 self.assertIn('Ran 5 tests', run_unittest(['discover', '-p', '*_test*', '-k', 'TestWarnings']))
522 self.assertIn('Ran 1 test ', run_unittest(['-k', 'f', t]))
523 self.assertIn('Ran 5 tests', run_unittest(['-k', 't', t]))
524 self.assertIn('Ran 2 tests', run_unittest(['-k', '*t', t]))
525 self.assertIn('Ran 5 tests', run_unittest(['-k', '*test_warnings.*Warning*', t]))
526 self.assertIn('Ran 1 test ', run_unittest(['-k', '*test_warnings.*warning*', t]))
527
528
529 if __name__ == '__main__':
530 unittest.main()