Debian Codegraph @

Lib/test/test_unittest/test_discovery.py

raw
1 import os.path
2 from os.path import abspath
3 import re
4 import sys
5 import types
6 import pickle
7 from importlib._bootstrap_external import NamespaceLoader
8 from test import support
9 from test.support import import_helper
10
11 import unittest
12 import unittest.mock
13 import test.test_unittest
14 from test.test_importlib import util as test_util
15
16
17 class TestableTestProgram(unittest.TestProgram):
18 module = None
19 exit = True
20 defaultTest = failfast = catchbreak = buffer = None
21 verbosity = 1
22 progName = ''
23 testRunner = testLoader = None
24
25 def __init__(self):
26 pass
27
28
29 class TestDiscovery(unittest.TestCase):
30
31 # Heavily mocked tests so I can avoid hitting the filesystem
32 def test_get_name_from_path(self):
33 loader = unittest.TestLoader()
34 loader._top_level_dir = '/foo'
35 name = loader._get_name_from_path('/foo/bar/baz.py')
36 self.assertEqual(name, 'bar.baz')
37
38 if not __debug__:
39 # asserts are off
40 return
41
42 with self.assertRaises(AssertionError):
43 loader._get_name_from_path('/bar/baz.py')
44
45 def test_find_tests(self):
46 loader = unittest.TestLoader()
47
48 original_listdir = os.listdir
49 def restore_listdir():
50 os.listdir = original_listdir
51 original_isfile = os.path.isfile
52 def restore_isfile():
53 os.path.isfile = original_isfile
54 original_isdir = os.path.isdir
55 def restore_isdir():
56 os.path.isdir = original_isdir
57
58 path_lists = [['test2.py', 'test1.py', 'not_a_test.py', 'test_dir',
59 'test.foo', 'test-not-a-module.py', 'another_dir'],
60 ['test4.py', 'test3.py', ]]
61 os.listdir = lambda path: path_lists.pop(0)
62 self.addCleanup(restore_listdir)
63
64 def isdir(path):
65 return path.endswith('dir')
66 os.path.isdir = isdir
67 self.addCleanup(restore_isdir)
68
69 def isfile(path):
70 # another_dir is not a package and so shouldn't be recursed into
71 return not path.endswith('dir') and not 'another_dir' in path
72 os.path.isfile = isfile
73 self.addCleanup(restore_isfile)
74
75 loader._get_module_from_name = lambda path: path + ' module'
76 orig_load_tests = loader.loadTestsFromModule
77 def loadTestsFromModule(module, pattern=None):
78 # This is where load_tests is called.
79 base = orig_load_tests(module, pattern=pattern)
80 return base + [module + ' tests']
81 loader.loadTestsFromModule = loadTestsFromModule
82 loader.suiteClass = lambda thing: thing
83
84 top_level = os.path.abspath('/foo')
85 loader._top_level_dir = top_level
86 suite = list(loader._find_tests(top_level, 'test*.py'))
87
88 # The test suites found should be sorted alphabetically for reliable
89 # execution order.
90 expected = [[name + ' module tests'] for name in
91 ('test1', 'test2', 'test_dir')]
92 expected.extend([[('test_dir.%s' % name) + ' module tests'] for name in
93 ('test3', 'test4')])
94 self.assertEqual(suite, expected)
95
96 def test_find_tests_socket(self):
97 # A socket is neither a directory nor a regular file.
98 # https://bugs.python.org/issue25320
99 loader = unittest.TestLoader()
100
101 original_listdir = os.listdir
102 def restore_listdir():
103 os.listdir = original_listdir
104 original_isfile = os.path.isfile
105 def restore_isfile():
106 os.path.isfile = original_isfile
107 original_isdir = os.path.isdir
108 def restore_isdir():
109 os.path.isdir = original_isdir
110
111 path_lists = [['socket']]
112 os.listdir = lambda path: path_lists.pop(0)
113 self.addCleanup(restore_listdir)
114
115 os.path.isdir = lambda path: False
116 self.addCleanup(restore_isdir)
117
118 os.path.isfile = lambda path: False
119 self.addCleanup(restore_isfile)
120
121 loader._get_module_from_name = lambda path: path + ' module'
122 orig_load_tests = loader.loadTestsFromModule
123 def loadTestsFromModule(module, pattern=None):
124 # This is where load_tests is called.
125 base = orig_load_tests(module, pattern=pattern)
126 return base + [module + ' tests']
127 loader.loadTestsFromModule = loadTestsFromModule
128 loader.suiteClass = lambda thing: thing
129
130 top_level = os.path.abspath('/foo')
131 loader._top_level_dir = top_level
132 suite = list(loader._find_tests(top_level, 'test*.py'))
133
134 self.assertEqual(suite, [])
135
136 def test_find_tests_with_package(self):
137 loader = unittest.TestLoader()
138
139 original_listdir = os.listdir
140 def restore_listdir():
141 os.listdir = original_listdir
142 original_isfile = os.path.isfile
143 def restore_isfile():
144 os.path.isfile = original_isfile
145 original_isdir = os.path.isdir
146 def restore_isdir():
147 os.path.isdir = original_isdir
148
149 directories = ['a_directory', 'test_directory', 'test_directory2']
150 path_lists = [directories, [], [], []]
151 os.listdir = lambda path: path_lists.pop(0)
152 self.addCleanup(restore_listdir)
153
154 os.path.isdir = lambda path: True
155 self.addCleanup(restore_isdir)
156
157 os.path.isfile = lambda path: os.path.basename(path) not in directories
158 self.addCleanup(restore_isfile)
159
160 class Module(object):
161 paths = []
162 load_tests_args = []
163
164 def __init__(self, path):
165 self.path = path
166 self.paths.append(path)
167 if os.path.basename(path) == 'test_directory':
168 def load_tests(loader, tests, pattern):
169 self.load_tests_args.append((loader, tests, pattern))
170 return [self.path + ' load_tests']
171 self.load_tests = load_tests
172
173 def __eq__(self, other):
174 return self.path == other.path
175
176 loader._get_module_from_name = lambda name: Module(name)
177 orig_load_tests = loader.loadTestsFromModule
178 def loadTestsFromModule(module, pattern=None):
179 # This is where load_tests is called.
180 base = orig_load_tests(module, pattern=pattern)
181 return base + [module.path + ' module tests']
182 loader.loadTestsFromModule = loadTestsFromModule
183 loader.suiteClass = lambda thing: thing
184
185 loader._top_level_dir = '/foo'
186 # this time no '.py' on the pattern so that it can match
187 # a test package
188 suite = list(loader._find_tests('/foo', 'test*'))
189
190 # We should have loaded tests from the a_directory and test_directory2
191 # directly and via load_tests for the test_directory package, which
192 # still calls the baseline module loader.
193 self.assertEqual(suite,
194 [['a_directory module tests'],
195 ['test_directory load_tests',
196 'test_directory module tests'],
197 ['test_directory2 module tests']])
198
199
200 # The test module paths should be sorted for reliable execution order
201 self.assertEqual(Module.paths,
202 ['a_directory', 'test_directory', 'test_directory2'])
203
204 # load_tests should have been called once with loader, tests and pattern
205 # (but there are no tests in our stub module itself, so that is [] at
206 # the time of call).
207 self.assertEqual(Module.load_tests_args,
208 [(loader, [], 'test*')])
209
210 def test_find_tests_default_calls_package_load_tests(self):
211 loader = unittest.TestLoader()
212
213 original_listdir = os.listdir
214 def restore_listdir():
215 os.listdir = original_listdir
216 original_isfile = os.path.isfile
217 def restore_isfile():
218 os.path.isfile = original_isfile
219 original_isdir = os.path.isdir
220 def restore_isdir():
221 os.path.isdir = original_isdir
222
223 directories = ['a_directory', 'test_directory', 'test_directory2']
224 path_lists = [directories, [], [], []]
225 os.listdir = lambda path: path_lists.pop(0)
226 self.addCleanup(restore_listdir)
227
228 os.path.isdir = lambda path: True
229 self.addCleanup(restore_isdir)
230
231 os.path.isfile = lambda path: os.path.basename(path) not in directories
232 self.addCleanup(restore_isfile)
233
234 class Module(object):
235 paths = []
236 load_tests_args = []
237
238 def __init__(self, path):
239 self.path = path
240 self.paths.append(path)
241 if os.path.basename(path) == 'test_directory':
242 def load_tests(loader, tests, pattern):
243 self.load_tests_args.append((loader, tests, pattern))
244 return [self.path + ' load_tests']
245 self.load_tests = load_tests
246
247 def __eq__(self, other):
248 return self.path == other.path
249
250 loader._get_module_from_name = lambda name: Module(name)
251 orig_load_tests = loader.loadTestsFromModule
252 def loadTestsFromModule(module, pattern=None):
253 # This is where load_tests is called.
254 base = orig_load_tests(module, pattern=pattern)
255 return base + [module.path + ' module tests']
256 loader.loadTestsFromModule = loadTestsFromModule
257 loader.suiteClass = lambda thing: thing
258
259 loader._top_level_dir = '/foo'
260 # this time no '.py' on the pattern so that it can match
261 # a test package
262 suite = list(loader._find_tests('/foo', 'test*.py'))
263
264 # We should have loaded tests from the a_directory and test_directory2
265 # directly and via load_tests for the test_directory package, which
266 # still calls the baseline module loader.
267 self.assertEqual(suite,
268 [['a_directory module tests'],
269 ['test_directory load_tests',
270 'test_directory module tests'],
271 ['test_directory2 module tests']])
272 # The test module paths should be sorted for reliable execution order
273 self.assertEqual(Module.paths,
274 ['a_directory', 'test_directory', 'test_directory2'])
275
276
277 # load_tests should have been called once with loader, tests and pattern
278 self.assertEqual(Module.load_tests_args,
279 [(loader, [], 'test*.py')])
280
281 def test_find_tests_customize_via_package_pattern(self):
282 # This test uses the example 'do-nothing' load_tests from
283 # https://docs.python.org/3/library/unittest.html#load-tests-protocol
284 # to make sure that that actually works.
285 # Housekeeping
286 original_listdir = os.listdir
287 def restore_listdir():
288 os.listdir = original_listdir
289 self.addCleanup(restore_listdir)
290 original_isfile = os.path.isfile
291 def restore_isfile():
292 os.path.isfile = original_isfile
293 self.addCleanup(restore_isfile)
294 original_isdir = os.path.isdir
295 def restore_isdir():
296 os.path.isdir = original_isdir
297 self.addCleanup(restore_isdir)
298 self.addCleanup(sys.path.remove, abspath('/foo'))
299
300 # Test data: we expect the following:
301 # a listdir to find our package, and isfile and isdir checks on it.
302 # a module-from-name call to turn that into a module
303 # followed by load_tests.
304 # then our load_tests will call discover() which is messy
305 # but that finally chains into find_tests again for the child dir -
306 # which is why we don't have an infinite loop.
307 # We expect to see:
308 # the module load tests for both package and plain module called,
309 # and the plain module result nested by the package module load_tests
310 # indicating that it was processed and could have been mutated.
311 vfs = {abspath('/foo'): ['my_package'],
312 abspath('/foo/my_package'): ['__init__.py', 'test_module.py']}
313 def list_dir(path):
314 return list(vfs[path])
315 os.listdir = list_dir
316 os.path.isdir = lambda path: not path.endswith('.py')
317 os.path.isfile = lambda path: path.endswith('.py')
318
319 class Module(object):
320 paths = []
321 load_tests_args = []
322
323 def __init__(self, path):
324 self.path = path
325 self.paths.append(path)
326 if path.endswith('test_module'):
327 def load_tests(loader, tests, pattern):
328 self.load_tests_args.append((loader, tests, pattern))
329 return [self.path + ' load_tests']
330 else:
331 def load_tests(loader, tests, pattern):
332 self.load_tests_args.append((loader, tests, pattern))
333 # top level directory cached on loader instance
334 __file__ = '/foo/my_package/__init__.py'
335 this_dir = os.path.dirname(__file__)
336 pkg_tests = loader.discover(
337 start_dir=this_dir, pattern=pattern)
338 return [self.path + ' load_tests', tests
339 ] + pkg_tests
340 self.load_tests = load_tests
341
342 def __eq__(self, other):
343 return self.path == other.path
344
345 loader = unittest.TestLoader()
346 loader._get_module_from_name = lambda name: Module(name)
347 loader.suiteClass = lambda thing: thing
348
349 loader._top_level_dir = abspath('/foo')
350 # this time no '.py' on the pattern so that it can match
351 # a test package
352 suite = list(loader._find_tests(abspath('/foo'), 'test*.py'))
353
354 # We should have loaded tests from both my_package and
355 # my_package.test_module, and also run the load_tests hook in both.
356 # (normally this would be nested TestSuites.)
357 self.assertEqual(suite,
358 [['my_package load_tests', [],
359 ['my_package.test_module load_tests']]])
360 # Parents before children.
361 self.assertEqual(Module.paths,
362 ['my_package', 'my_package.test_module'])
363
364 # load_tests should have been called twice with loader, tests and pattern
365 self.assertEqual(Module.load_tests_args,
366 [(loader, [], 'test*.py'),
367 (loader, [], 'test*.py')])
368
369 def test_discover(self):
370 loader = unittest.TestLoader()
371
372 original_isfile = os.path.isfile
373 original_isdir = os.path.isdir
374 def restore_isfile():
375 os.path.isfile = original_isfile
376
377 os.path.isfile = lambda path: False
378 self.addCleanup(restore_isfile)
379
380 orig_sys_path = sys.path[:]
381 def restore_path():
382 sys.path[:] = orig_sys_path
383 self.addCleanup(restore_path)
384
385 full_path = os.path.abspath(os.path.normpath('/foo'))
386 with self.assertRaises(ImportError):
387 loader.discover('/foo/bar', top_level_dir='/foo')
388
389 self.assertEqual(loader._top_level_dir, full_path)
390 self.assertIn(full_path, sys.path)
391
392 os.path.isfile = lambda path: True
393 os.path.isdir = lambda path: True
394
395 def restore_isdir():
396 os.path.isdir = original_isdir
397 self.addCleanup(restore_isdir)
398
399 _find_tests_args = []
400 def _find_tests(start_dir, pattern, namespace=None):
401 _find_tests_args.append((start_dir, pattern))
402 return ['tests']
403 loader._find_tests = _find_tests
404 loader.suiteClass = str
405
406 suite = loader.discover('/foo/bar/baz', 'pattern', '/foo/bar')
407
408 top_level_dir = os.path.abspath('/foo/bar')
409 start_dir = os.path.abspath('/foo/bar/baz')
410 self.assertEqual(suite, "['tests']")
411 self.assertEqual(loader._top_level_dir, os.path.abspath('/foo'))
412 self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
413 self.assertIn(top_level_dir, sys.path)
414
415 def test_discover_should_not_persist_top_level_dir_between_calls(self):
416 original_isfile = os.path.isfile
417 original_isdir = os.path.isdir
418 original_sys_path = sys.path[:]
419 def restore():
420 os.path.isfile = original_isfile
421 os.path.isdir = original_isdir
422 sys.path[:] = original_sys_path
423 self.addCleanup(restore)
424
425 os.path.isfile = lambda path: True
426 os.path.isdir = lambda path: True
427 loader = unittest.TestLoader()
428 loader.suiteClass = str
429 dir = '/foo/bar'
430 top_level_dir = '/foo'
431
432 loader.discover(dir, top_level_dir=top_level_dir)
433 self.assertEqual(loader._top_level_dir, None)
434
435 loader._top_level_dir = dir2 = '/previous/dir'
436 loader.discover(dir, top_level_dir=top_level_dir)
437 self.assertEqual(loader._top_level_dir, dir2)
438
439 def test_discover_start_dir_is_package_calls_package_load_tests(self):
440 # This test verifies that the package load_tests in a package is indeed
441 # invoked when the start_dir is a package (and not the top level).
442 # http://bugs.python.org/issue22457
443
444 # Test data: we expect the following:
445 # an isfile to verify the package, then importing and scanning
446 # as per _find_tests' normal behaviour.
447 # We expect to see our load_tests hook called once.
448 vfs = {abspath('/toplevel'): ['startdir'],
449 abspath('/toplevel/startdir'): ['__init__.py']}
450 def list_dir(path):
451 return list(vfs[path])
452 self.addCleanup(setattr, os, 'listdir', os.listdir)
453 os.listdir = list_dir
454 self.addCleanup(setattr, os.path, 'isfile', os.path.isfile)
455 os.path.isfile = lambda path: path.endswith('.py')
456 self.addCleanup(setattr, os.path, 'isdir', os.path.isdir)
457 os.path.isdir = lambda path: not path.endswith('.py')
458 self.addCleanup(sys.path.remove, abspath('/toplevel'))
459
460 class Module(object):
461 paths = []
462 load_tests_args = []
463
464 def __init__(self, path):
465 self.path = path
466
467 def load_tests(self, loader, tests, pattern):
468 return ['load_tests called ' + self.path]
469
470 def __eq__(self, other):
471 return self.path == other.path
472
473 loader = unittest.TestLoader()
474 loader._get_module_from_name = lambda name: Module(name)
475 loader.suiteClass = lambda thing: thing
476
477 suite = loader.discover('/toplevel/startdir', top_level_dir='/toplevel')
478
479 # We should have loaded tests from the package __init__.
480 # (normally this would be nested TestSuites.)
481 self.assertEqual(suite,
482 [['load_tests called startdir']])
483
484 def setup_import_issue_tests(self, fakefile):
485 listdir = os.listdir
486 os.listdir = lambda _: [fakefile]
487 isfile = os.path.isfile
488 os.path.isfile = lambda _: True
489 orig_sys_path = sys.path[:]
490 def restore():
491 os.path.isfile = isfile
492 os.listdir = listdir
493 sys.path[:] = orig_sys_path
494 self.addCleanup(restore)
495
496 def setup_import_issue_package_tests(self, vfs):
497 self.addCleanup(setattr, os, 'listdir', os.listdir)
498 self.addCleanup(setattr, os.path, 'isfile', os.path.isfile)
499 self.addCleanup(setattr, os.path, 'isdir', os.path.isdir)
500 self.addCleanup(sys.path.__setitem__, slice(None), list(sys.path))
501 def list_dir(path):
502 return list(vfs[path])
503 os.listdir = list_dir
504 os.path.isdir = lambda path: not path.endswith('.py')
505 os.path.isfile = lambda path: path.endswith('.py')
506
507 def test_discover_with_modules_that_fail_to_import(self):
508 loader = unittest.TestLoader()
509
510 self.setup_import_issue_tests('test_this_does_not_exist.py')
511
512 suite = loader.discover('.')
513 self.assertIn(os.getcwd(), sys.path)
514 self.assertEqual(suite.countTestCases(), 1)
515 # Errors loading the suite are also captured for introspection.
516 self.assertNotEqual([], loader.errors)
517 self.assertEqual(1, len(loader.errors))
518 error = loader.errors[0]
519 self.assertTrue(
520 'Failed to import test module: test_this_does_not_exist' in error,
521 'missing error string in %r' % error)
522 test = list(list(suite)[0])[0] # extract test from suite
523
524 with self.assertRaises(ImportError):
525 test.test_this_does_not_exist()
526
527 def test_discover_with_init_modules_that_fail_to_import(self):
528 vfs = {abspath('/foo'): ['my_package'],
529 abspath('/foo/my_package'): ['__init__.py', 'test_module.py']}
530 self.setup_import_issue_package_tests(vfs)
531 import_calls = []
532 def _get_module_from_name(name):
533 import_calls.append(name)
534 raise ImportError("Cannot import Name")
535 loader = unittest.TestLoader()
536 loader._get_module_from_name = _get_module_from_name
537 suite = loader.discover(abspath('/foo'))
538
539 self.assertIn(abspath('/foo'), sys.path)
540 self.assertEqual(suite.countTestCases(), 1)
541 # Errors loading the suite are also captured for introspection.
542 self.assertNotEqual([], loader.errors)
543 self.assertEqual(1, len(loader.errors))
544 error = loader.errors[0]
545 self.assertTrue(
546 'Failed to import test module: my_package' in error,
547 'missing error string in %r' % error)
548 test = list(list(suite)[0])[0] # extract test from suite
549 with self.assertRaises(ImportError):
550 test.my_package()
551 self.assertEqual(import_calls, ['my_package'])
552
553 # Check picklability
554 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
555 pickle.loads(pickle.dumps(test, proto))
556
557 def test_discover_with_module_that_raises_SkipTest_on_import(self):
558 if not unittest.BaseTestSuite._cleanup:
559 raise unittest.SkipTest("Suite cleanup is disabled")
560
561 loader = unittest.TestLoader()
562
563 def _get_module_from_name(name):
564 raise unittest.SkipTest('skipperoo')
565 loader._get_module_from_name = _get_module_from_name
566
567 self.setup_import_issue_tests('test_skip_dummy.py')
568
569 suite = loader.discover('.')
570 self.assertEqual(suite.countTestCases(), 1)
571
572 result = unittest.TestResult()
573 suite.run(result)
574 self.assertEqual(len(result.skipped), 1)
575
576 # Check picklability
577 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
578 pickle.loads(pickle.dumps(suite, proto))
579
580 def test_discover_with_init_module_that_raises_SkipTest_on_import(self):
581 if not unittest.BaseTestSuite._cleanup:
582 raise unittest.SkipTest("Suite cleanup is disabled")
583
584 vfs = {abspath('/foo'): ['my_package'],
585 abspath('/foo/my_package'): ['__init__.py', 'test_module.py']}
586 self.setup_import_issue_package_tests(vfs)
587 import_calls = []
588 def _get_module_from_name(name):
589 import_calls.append(name)
590 raise unittest.SkipTest('skipperoo')
591 loader = unittest.TestLoader()
592 loader._get_module_from_name = _get_module_from_name
593 suite = loader.discover(abspath('/foo'))
594
595 self.assertIn(abspath('/foo'), sys.path)
596 self.assertEqual(suite.countTestCases(), 1)
597 result = unittest.TestResult()
598 suite.run(result)
599 self.assertEqual(len(result.skipped), 1)
600 self.assertEqual(result.testsRun, 1)
601 self.assertEqual(import_calls, ['my_package'])
602
603 # Check picklability
604 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
605 pickle.loads(pickle.dumps(suite, proto))
606
607 def test_command_line_handling_parseArgs(self):
608 program = TestableTestProgram()
609
610 args = []
611 program._do_discovery = args.append
612 program.parseArgs(['something', 'discover'])
613 self.assertEqual(args, [[]])
614
615 args[:] = []
616 program.parseArgs(['something', 'discover', 'foo', 'bar'])
617 self.assertEqual(args, [['foo', 'bar']])
618
619 def test_command_line_handling_discover_by_default(self):
620 program = TestableTestProgram()
621
622 args = []
623 program._do_discovery = args.append
624 program.parseArgs(['something'])
625 self.assertEqual(args, [[]])
626 self.assertEqual(program.verbosity, 1)
627 self.assertIs(program.buffer, False)
628 self.assertIs(program.catchbreak, False)
629 self.assertIs(program.failfast, False)
630
631 def test_command_line_handling_discover_by_default_with_options(self):
632 program = TestableTestProgram()
633
634 args = []
635 program._do_discovery = args.append
636 program.parseArgs(['something', '-v', '-b', '-v', '-c', '-f'])
637 self.assertEqual(args, [[]])
638 self.assertEqual(program.verbosity, 2)
639 self.assertIs(program.buffer, True)
640 self.assertIs(program.catchbreak, True)
641 self.assertIs(program.failfast, True)
642
643
644 def test_command_line_handling_do_discovery_too_many_arguments(self):
645 program = TestableTestProgram()
646 program.testLoader = None
647
648 with support.captured_stderr() as stderr, \
649 self.assertRaises(SystemExit) as cm:
650 # too many args
651 program._do_discovery(['one', 'two', 'three', 'four'])
652 self.assertEqual(cm.exception.args, (2,))
653 self.assertIn('usage:', stderr.getvalue())
654
655
656 def test_command_line_handling_do_discovery_uses_default_loader(self):
657 program = object.__new__(unittest.TestProgram)
658 program._initArgParsers()
659
660 class Loader(object):
661 args = []
662 def discover(self, start_dir, pattern, top_level_dir):
663 self.args.append((start_dir, pattern, top_level_dir))
664 return 'tests'
665
666 program.testLoader = Loader()
667 program._do_discovery(['-v'])
668 self.assertEqual(Loader.args, [('.', 'test*.py', None)])
669
670 def test_command_line_handling_do_discovery_calls_loader(self):
671 program = TestableTestProgram()
672
673 class Loader(object):
674 args = []
675 def discover(self, start_dir, pattern, top_level_dir):
676 self.args.append((start_dir, pattern, top_level_dir))
677 return 'tests'
678
679 program._do_discovery(['-v'], Loader=Loader)
680 self.assertEqual(program.verbosity, 2)
681 self.assertEqual(program.test, 'tests')
682 self.assertEqual(Loader.args, [('.', 'test*.py', None)])
683
684 Loader.args = []
685 program = TestableTestProgram()
686 program._do_discovery(['--verbose'], Loader=Loader)
687 self.assertEqual(program.test, 'tests')
688 self.assertEqual(Loader.args, [('.', 'test*.py', None)])
689
690 Loader.args = []
691 program = TestableTestProgram()
692 program._do_discovery([], Loader=Loader)
693 self.assertEqual(program.test, 'tests')
694 self.assertEqual(Loader.args, [('.', 'test*.py', None)])
695
696 Loader.args = []
697 program = TestableTestProgram()
698 program._do_discovery(['fish'], Loader=Loader)
699 self.assertEqual(program.test, 'tests')
700 self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
701
702 Loader.args = []
703 program = TestableTestProgram()
704 program._do_discovery(['fish', 'eggs'], Loader=Loader)
705 self.assertEqual(program.test, 'tests')
706 self.assertEqual(Loader.args, [('fish', 'eggs', None)])
707
708 Loader.args = []
709 program = TestableTestProgram()
710 program._do_discovery(['fish', 'eggs', 'ham'], Loader=Loader)
711 self.assertEqual(program.test, 'tests')
712 self.assertEqual(Loader.args, [('fish', 'eggs', 'ham')])
713
714 Loader.args = []
715 program = TestableTestProgram()
716 program._do_discovery(['-s', 'fish'], Loader=Loader)
717 self.assertEqual(program.test, 'tests')
718 self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
719
720 Loader.args = []
721 program = TestableTestProgram()
722 program._do_discovery(['-t', 'fish'], Loader=Loader)
723 self.assertEqual(program.test, 'tests')
724 self.assertEqual(Loader.args, [('.', 'test*.py', 'fish')])
725
726 Loader.args = []
727 program = TestableTestProgram()
728 program._do_discovery(['-p', 'fish'], Loader=Loader)
729 self.assertEqual(program.test, 'tests')
730 self.assertEqual(Loader.args, [('.', 'fish', None)])
731 self.assertFalse(program.failfast)
732 self.assertFalse(program.catchbreak)
733
734 Loader.args = []
735 program = TestableTestProgram()
736 program._do_discovery(['-p', 'eggs', '-s', 'fish', '-v', '-f', '-c'],
737 Loader=Loader)
738 self.assertEqual(program.test, 'tests')
739 self.assertEqual(Loader.args, [('fish', 'eggs', None)])
740 self.assertEqual(program.verbosity, 2)
741 self.assertTrue(program.failfast)
742 self.assertTrue(program.catchbreak)
743
744 def setup_module_clash(self):
745 class Module(object):
746 __file__ = 'bar/foo.py'
747 sys.modules['foo'] = Module
748 full_path = os.path.abspath('foo')
749 original_listdir = os.listdir
750 original_isfile = os.path.isfile
751 original_isdir = os.path.isdir
752 original_realpath = os.path.realpath
753
754 def cleanup():
755 os.listdir = original_listdir
756 os.path.isfile = original_isfile
757 os.path.isdir = original_isdir
758 os.path.realpath = original_realpath
759 del sys.modules['foo']
760 if full_path in sys.path:
761 sys.path.remove(full_path)
762 self.addCleanup(cleanup)
763
764 def listdir(_):
765 return ['foo.py']
766 def isfile(_):
767 return True
768 def isdir(_):
769 return True
770 os.listdir = listdir
771 os.path.isfile = isfile
772 os.path.isdir = isdir
773 if os.name == 'nt':
774 # ntpath.realpath may inject path prefixes when failing to
775 # resolve real files, so we substitute abspath() here instead.
776 os.path.realpath = os.path.abspath
777 return full_path
778
779 def test_detect_module_clash(self):
780 full_path = self.setup_module_clash()
781 loader = unittest.TestLoader()
782
783 mod_dir = os.path.abspath('bar')
784 expected_dir = os.path.abspath('foo')
785 msg = re.escape(r"'foo' module incorrectly imported from %r. Expected %r. "
786 "Is this module globally installed?" % (mod_dir, expected_dir))
787 self.assertRaisesRegex(
788 ImportError, '^%s$' % msg, loader.discover,
789 start_dir='foo', pattern='foo.py'
790 )
791 self.assertEqual(sys.path[0], full_path)
792
793 def test_module_symlink_ok(self):
794 full_path = self.setup_module_clash()
795
796 original_realpath = os.path.realpath
797
798 mod_dir = os.path.abspath('bar')
799 expected_dir = os.path.abspath('foo')
800
801 def cleanup():
802 os.path.realpath = original_realpath
803 self.addCleanup(cleanup)
804
805 def realpath(path):
806 if path == os.path.join(mod_dir, 'foo.py'):
807 return os.path.join(expected_dir, 'foo.py')
808 return path
809 os.path.realpath = realpath
810 loader = unittest.TestLoader()
811 loader.discover(start_dir='foo', pattern='foo.py')
812
813 def test_discovery_from_dotted_path(self):
814 loader = unittest.TestLoader()
815
816 tests = [self]
817 expectedPath = os.path.abspath(os.path.dirname(test.test_unittest.__file__))
818
819 self.wasRun = False
820 def _find_tests(start_dir, pattern, namespace=None):
821 self.wasRun = True
822 self.assertEqual(start_dir, expectedPath)
823 return tests
824 loader._find_tests = _find_tests
825 suite = loader.discover('test.test_unittest')
826 self.assertTrue(self.wasRun)
827 self.assertEqual(suite._tests, tests)
828
829
830 def test_discovery_from_dotted_path_builtin_modules(self):
831
832 loader = unittest.TestLoader()
833
834 listdir = os.listdir
835 os.listdir = lambda _: ['test_this_does_not_exist.py']
836 isfile = os.path.isfile
837 isdir = os.path.isdir
838 os.path.isdir = lambda _: False
839 orig_sys_path = sys.path[:]
840 def restore():
841 os.path.isfile = isfile
842 os.path.isdir = isdir
843 os.listdir = listdir
844 sys.path[:] = orig_sys_path
845 self.addCleanup(restore)
846
847 with self.assertRaises(TypeError) as cm:
848 loader.discover('sys')
849 self.assertEqual(str(cm.exception),
850 'Can not use builtin modules '
851 'as dotted module names')
852
853 def test_discovery_from_dotted_namespace_packages(self):
854 loader = unittest.TestLoader()
855
856 package = types.ModuleType('package')
857 package.__name__ = "tests"
858 package.__path__ = ['/a', '/b']
859 package.__file__ = None
860 package.__spec__ = types.SimpleNamespace(
861 name=package.__name__,
862 loader=NamespaceLoader(package.__name__, package.__path__, None),
863 submodule_search_locations=['/a', '/b']
864 )
865
866 def _import(packagename, *args, **kwargs):
867 sys.modules[packagename] = package
868 return package
869
870 _find_tests_args = []
871 def _find_tests(start_dir, pattern, namespace=None):
872 _find_tests_args.append((start_dir, pattern))
873 return ['%s/tests' % start_dir]
874
875 loader._find_tests = _find_tests
876 loader.suiteClass = list
877
878 with unittest.mock.patch('builtins.__import__', _import):
879 # Since loader.discover() can modify sys.path, restore it when done.
880 with import_helper.DirsOnSysPath():
881 # Make sure to remove 'package' from sys.modules when done.
882 with test_util.uncache('package'):
883 suite = loader.discover('package')
884
885 self.assertEqual(suite, ['/a/tests', '/b/tests'])
886
887 def test_discovery_start_dir_is_namespace(self):
888 """Subdirectory discovery not affected if start_dir is a namespace pkg."""
889 loader = unittest.TestLoader()
890 with (
891 import_helper.DirsOnSysPath(os.path.join(os.path.dirname(__file__))),
892 test_util.uncache('namespace_test_pkg')
893 ):
894 suite = loader.discover('namespace_test_pkg')
895 self.assertEqual(
896 {list(suite)[0]._tests[0].__module__ for suite in suite._tests if list(suite)},
897 # files under namespace_test_pkg.noop not discovered.
898 {'namespace_test_pkg.test_foo', 'namespace_test_pkg.bar.test_bar'},
899 )
900
901 def test_discovery_failed_discovery(self):
902 from test.test_importlib import util
903
904 loader = unittest.TestLoader()
905 package = types.ModuleType('package')
906
907 def _import(packagename, *args, **kwargs):
908 sys.modules[packagename] = package
909 return package
910
911 with unittest.mock.patch('builtins.__import__', _import):
912 # Since loader.discover() can modify sys.path, restore it when done.
913 with import_helper.DirsOnSysPath():
914 # Make sure to remove 'package' from sys.modules when done.
915 with util.uncache('package'):
916 with self.assertRaises(TypeError) as cm:
917 loader.discover('package')
918 self.assertEqual(str(cm.exception),
919 'don\'t know how to discover from {!r}'
920 .format(package))
921
922
923 if __name__ == '__main__':
924 unittest.main()