Debian Codegraph @

tests/test_runner/test_discover_runner.py

raw
1 import logging
2 import multiprocessing
3 import os
4 import unittest.loader
5 from argparse import ArgumentParser
6 from contextlib import contextmanager
7 from importlib import import_module
8 from unittest import TestSuite, TextTestRunner, defaultTestLoader, mock
9
10 from django.db import connections
11 from django.test import SimpleTestCase
12 from django.test.runner import DiscoverRunner, get_max_test_processes
13 from django.test.utils import (
14 NullTimeKeeper,
15 TimeKeeper,
16 captured_stderr,
17 captured_stdout,
18 )
19 from django.utils.version import PY312
20
21
22 @contextmanager
23 def change_cwd(directory):
24 current_dir = os.path.abspath(os.path.dirname(__file__))
25 new_dir = os.path.join(current_dir, directory)
26 old_cwd = os.getcwd()
27 os.chdir(new_dir)
28 try:
29 yield
30 finally:
31 os.chdir(old_cwd)
32
33
34 @contextmanager
35 def change_loader_patterns(patterns):
36 original_patterns = DiscoverRunner.test_loader.testNamePatterns
37 DiscoverRunner.test_loader.testNamePatterns = patterns
38 try:
39 yield
40 finally:
41 DiscoverRunner.test_loader.testNamePatterns = original_patterns
42
43
44 # Isolate from the real environment.
45 @mock.patch.dict(os.environ, {}, clear=True)
46 @mock.patch.object(multiprocessing, "cpu_count", return_value=12)
47 # Python 3.8 on macOS defaults to 'spawn' mode.
48 # Python 3.14 on POSIX systems defaults to 'forkserver' mode.
49 @mock.patch.object(multiprocessing, "get_start_method", return_value="fork")
50 class DiscoverRunnerParallelArgumentTests(SimpleTestCase):
51 def get_parser(self):
52 parser = ArgumentParser()
53 DiscoverRunner.add_arguments(parser)
54 return parser
55
56 def test_parallel_default(self, *mocked_objects):
57 result = self.get_parser().parse_args([])
58 self.assertEqual(result.parallel, 0)
59
60 def test_parallel_flag(self, *mocked_objects):
61 result = self.get_parser().parse_args(["--parallel"])
62 self.assertEqual(result.parallel, "auto")
63
64 def test_parallel_auto(self, *mocked_objects):
65 result = self.get_parser().parse_args(["--parallel", "auto"])
66 self.assertEqual(result.parallel, "auto")
67
68 def test_parallel_count(self, *mocked_objects):
69 result = self.get_parser().parse_args(["--parallel", "17"])
70 self.assertEqual(result.parallel, 17)
71
72 def test_parallel_invalid(self, *mocked_objects):
73 with self.assertRaises(SystemExit), captured_stderr() as stderr:
74 self.get_parser().parse_args(["--parallel", "unaccepted"])
75 msg = "argument --parallel: 'unaccepted' is not an integer or the string 'auto'"
76 self.assertIn(msg, stderr.getvalue())
77
78 def test_get_max_test_processes(self, *mocked_objects):
79 self.assertEqual(get_max_test_processes(), 12)
80
81 @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"})
82 def test_get_max_test_processes_env_var(self, *mocked_objects):
83 self.assertEqual(get_max_test_processes(), 7)
84
85 def test_get_max_test_processes_spawn(
86 self,
87 mocked_get_start_method,
88 mocked_cpu_count,
89 ):
90 mocked_get_start_method.return_value = "spawn"
91 self.assertEqual(get_max_test_processes(), 12)
92 with mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}):
93 self.assertEqual(get_max_test_processes(), 7)
94
95 def test_get_max_test_processes_forkserver(
96 self,
97 mocked_get_start_method,
98 mocked_cpu_count,
99 ):
100 mocked_get_start_method.return_value = "forkserver"
101 self.assertEqual(get_max_test_processes(), 1)
102 with mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}):
103 self.assertEqual(get_max_test_processes(), 1)
104
105
106 class DiscoverRunnerTests(SimpleTestCase):
107 @staticmethod
108 def get_test_methods_names(suite):
109 return [t.__class__.__name__ + "." + t._testMethodName for t in suite._tests]
110
111 def test_init_debug_mode(self):
112 runner = DiscoverRunner()
113 self.assertFalse(runner.debug_mode)
114
115 def test_add_arguments_shuffle(self):
116 parser = ArgumentParser()
117 DiscoverRunner.add_arguments(parser)
118 ns = parser.parse_args([])
119 self.assertIs(ns.shuffle, False)
120 ns = parser.parse_args(["--shuffle"])
121 self.assertIsNone(ns.shuffle)
122 ns = parser.parse_args(["--shuffle", "5"])
123 self.assertEqual(ns.shuffle, 5)
124
125 def test_add_arguments_debug_mode(self):
126 parser = ArgumentParser()
127 DiscoverRunner.add_arguments(parser)
128
129 ns = parser.parse_args([])
130 self.assertFalse(ns.debug_mode)
131 ns = parser.parse_args(["--debug-mode"])
132 self.assertTrue(ns.debug_mode)
133
134 def test_setup_shuffler_no_shuffle_argument(self):
135 runner = DiscoverRunner()
136 self.assertIs(runner.shuffle, False)
137 runner.setup_shuffler()
138 self.assertIsNone(runner.shuffle_seed)
139
140 def test_setup_shuffler_shuffle_none(self):
141 runner = DiscoverRunner(shuffle=None)
142 self.assertIsNone(runner.shuffle)
143 with mock.patch("random.randint", return_value=1):
144 with captured_stdout() as stdout:
145 runner.setup_shuffler()
146 self.assertEqual(stdout.getvalue(), "Using shuffle seed: 1 (generated)\n")
147 self.assertEqual(runner.shuffle_seed, 1)
148
149 def test_setup_shuffler_shuffle_int(self):
150 runner = DiscoverRunner(shuffle=2)
151 self.assertEqual(runner.shuffle, 2)
152 with captured_stdout() as stdout:
153 runner.setup_shuffler()
154 expected_out = "Using shuffle seed: 2 (given)\n"
155 self.assertEqual(stdout.getvalue(), expected_out)
156 self.assertEqual(runner.shuffle_seed, 2)
157
158 def test_load_tests_for_label_file_path(self):
159 with change_cwd("."):
160 msg = (
161 "One of the test labels is a path to a file: "
162 "'test_discover_runner.py', which is not supported. Use a "
163 "dotted module name or path to a directory instead."
164 )
165 with self.assertRaisesMessage(RuntimeError, msg):
166 DiscoverRunner().load_tests_for_label("test_discover_runner.py", {})
167
168 def test_dotted_test_module(self):
169 count = (
170 DiscoverRunner(verbosity=0)
171 .build_suite(
172 ["test_runner_apps.sample.tests_sample"],
173 )
174 .countTestCases()
175 )
176
177 self.assertEqual(count, 4)
178
179 def test_dotted_test_class_vanilla_unittest(self):
180 count = (
181 DiscoverRunner(verbosity=0)
182 .build_suite(
183 ["test_runner_apps.sample.tests_sample.TestVanillaUnittest"],
184 )
185 .countTestCases()
186 )
187
188 self.assertEqual(count, 1)
189
190 def test_dotted_test_class_django_testcase(self):
191 count = (
192 DiscoverRunner(verbosity=0)
193 .build_suite(
194 ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"],
195 )
196 .countTestCases()
197 )
198
199 self.assertEqual(count, 1)
200
201 def test_dotted_test_method_django_testcase(self):
202 count = (
203 DiscoverRunner(verbosity=0)
204 .build_suite(
205 ["test_runner_apps.sample.tests_sample.TestDjangoTestCase.test_sample"],
206 )
207 .countTestCases()
208 )
209
210 self.assertEqual(count, 1)
211
212 def test_pattern(self):
213 count = (
214 DiscoverRunner(
215 pattern="*_tests.py",
216 verbosity=0,
217 )
218 .build_suite(["test_runner_apps.sample"])
219 .countTestCases()
220 )
221
222 self.assertEqual(count, 1)
223
224 def test_name_patterns(self):
225 all_test_1 = [
226 "DjangoCase1.test_1",
227 "DjangoCase2.test_1",
228 "SimpleCase1.test_1",
229 "SimpleCase2.test_1",
230 "UnittestCase1.test_1",
231 "UnittestCase2.test_1",
232 ]
233 all_test_2 = [
234 "DjangoCase1.test_2",
235 "DjangoCase2.test_2",
236 "SimpleCase1.test_2",
237 "SimpleCase2.test_2",
238 "UnittestCase1.test_2",
239 "UnittestCase2.test_2",
240 ]
241 all_tests = sorted([*all_test_1, *all_test_2, "UnittestCase2.test_3_test"])
242 for pattern, expected in [
243 [["test_1"], all_test_1],
244 [["UnittestCase1"], ["UnittestCase1.test_1", "UnittestCase1.test_2"]],
245 [["*test"], ["UnittestCase2.test_3_test"]],
246 [["test*"], all_tests],
247 [["test"], all_tests],
248 [["test_1", "test_2"], sorted([*all_test_1, *all_test_2])],
249 [["test*1"], all_test_1],
250 ]:
251 with self.subTest(pattern):
252 suite = DiscoverRunner(
253 test_name_patterns=pattern,
254 verbosity=0,
255 ).build_suite(["test_runner_apps.simple"])
256 self.assertEqual(expected, self.get_test_methods_names(suite))
257
258 def test_loader_patterns_not_mutated(self):
259 runner = DiscoverRunner(test_name_patterns=["test_sample"], verbosity=0)
260 tests = [
261 ("test_runner_apps.sample.tests", 1),
262 ("test_runner_apps.sample.tests.Test.test_sample", 1),
263 ("test_runner_apps.sample.empty", 0),
264 ("test_runner_apps.sample.tests_sample.EmptyTestCase", 0),
265 ]
266 for test_labels, tests_count in tests:
267 with self.subTest(test_labels=test_labels):
268 with change_loader_patterns(["UnittestCase1"]):
269 count = runner.build_suite([test_labels]).countTestCases()
270 self.assertEqual(count, tests_count)
271 self.assertEqual(
272 runner.test_loader.testNamePatterns, ["UnittestCase1"]
273 )
274
275 def test_loader_patterns_not_mutated_when_test_label_is_file_path(self):
276 runner = DiscoverRunner(test_name_patterns=["test_sample"], verbosity=0)
277 with change_cwd("."), change_loader_patterns(["UnittestCase1"]):
278 with self.assertRaises(RuntimeError):
279 runner.build_suite(["test_discover_runner.py"])
280 self.assertEqual(runner.test_loader.testNamePatterns, ["UnittestCase1"])
281
282 def test_file_path(self):
283 with change_cwd(".."):
284 count = (
285 DiscoverRunner(verbosity=0)
286 .build_suite(
287 ["test_runner_apps/sample/"],
288 )
289 .countTestCases()
290 )
291
292 self.assertEqual(count, 5)
293
294 def test_empty_label(self):
295 """
296 If the test label is empty, discovery should happen on the current
297 working directory.
298 """
299 with change_cwd("."):
300 suite = DiscoverRunner(verbosity=0).build_suite([])
301 self.assertEqual(
302 suite._tests[0].id().split(".")[0],
303 os.path.basename(os.getcwd()),
304 )
305
306 def test_empty_test_case(self):
307 count = (
308 DiscoverRunner(verbosity=0)
309 .build_suite(
310 ["test_runner_apps.sample.tests_sample.EmptyTestCase"],
311 )
312 .countTestCases()
313 )
314
315 self.assertEqual(count, 0)
316
317 def test_discovery_on_package(self):
318 count = (
319 DiscoverRunner(verbosity=0)
320 .build_suite(
321 ["test_runner_apps.sample.tests"],
322 )
323 .countTestCases()
324 )
325
326 self.assertEqual(count, 1)
327
328 def test_ignore_adjacent(self):
329 """
330 When given a dotted path to a module, unittest discovery searches
331 not just the module, but also the directory containing the module.
332
333 This results in tests from adjacent modules being run when they
334 should not. The discover runner avoids this behavior.
335 """
336 count = (
337 DiscoverRunner(verbosity=0)
338 .build_suite(
339 ["test_runner_apps.sample.empty"],
340 )
341 .countTestCases()
342 )
343
344 self.assertEqual(count, 0)
345
346 def test_testcase_ordering(self):
347 with change_cwd(".."):
348 suite = DiscoverRunner(verbosity=0).build_suite(
349 ["test_runner_apps/sample/"]
350 )
351 self.assertEqual(
352 suite._tests[0].__class__.__name__,
353 "TestDjangoTestCase",
354 msg="TestDjangoTestCase should be the first test case",
355 )
356 self.assertEqual(
357 suite._tests[1].__class__.__name__,
358 "TestZimpleTestCase",
359 msg="TestZimpleTestCase should be the second test case",
360 )
361 # All others can follow in unspecified order, including doctests
362 self.assertIn(
363 "DocTestCase", [t.__class__.__name__ for t in suite._tests[2:]]
364 )
365
366 def test_duplicates_ignored(self):
367 """
368 Tests shouldn't be discovered twice when discovering on overlapping paths.
369 """
370 base_app = "forms_tests"
371 sub_app = "forms_tests.field_tests"
372 runner = DiscoverRunner(verbosity=0)
373 with self.modify_settings(INSTALLED_APPS={"append": sub_app}):
374 single = runner.build_suite([base_app]).countTestCases()
375 dups = runner.build_suite([base_app, sub_app]).countTestCases()
376 self.assertEqual(single, dups)
377
378 def test_reverse(self):
379 """
380 Reverse should reorder tests while maintaining the grouping specified
381 by ``DiscoverRunner.reorder_by``.
382 """
383 runner = DiscoverRunner(reverse=True, verbosity=0)
384 suite = runner.build_suite(
385 test_labels=("test_runner_apps.sample", "test_runner_apps.simple")
386 )
387 self.assertIn(
388 "test_runner_apps.simple",
389 next(iter(suite)).id(),
390 msg="Test labels should be reversed.",
391 )
392 suite = runner.build_suite(test_labels=("test_runner_apps.simple",))
393 suite = tuple(suite)
394 self.assertIn(
395 "DjangoCase", suite[0].id(), msg="Test groups should not be reversed."
396 )
397 self.assertIn(
398 "SimpleCase", suite[4].id(), msg="Test groups order should be preserved."
399 )
400 self.assertIn(
401 "DjangoCase2", suite[0].id(), msg="Django test cases should be reversed."
402 )
403 self.assertIn(
404 "SimpleCase2", suite[4].id(), msg="Simple test cases should be reversed."
405 )
406 self.assertIn(
407 "UnittestCase2",
408 suite[8].id(),
409 msg="Unittest test cases should be reversed.",
410 )
411 self.assertIn(
412 "test_2", suite[0].id(), msg="Methods of Django cases should be reversed."
413 )
414 self.assertIn(
415 "test_2", suite[4].id(), msg="Methods of simple cases should be reversed."
416 )
417 self.assertIn(
418 "test_2", suite[9].id(), msg="Methods of unittest cases should be reversed."
419 )
420
421 def test_build_suite_failed_tests_first(self):
422 # The "doesnotexist" label results in a _FailedTest instance.
423 suite = DiscoverRunner(verbosity=0).build_suite(
424 test_labels=["test_runner_apps.sample", "doesnotexist"],
425 )
426 tests = list(suite)
427 self.assertIsInstance(tests[0], unittest.loader._FailedTest)
428 self.assertNotIsInstance(tests[-1], unittest.loader._FailedTest)
429
430 def test_build_suite_shuffling(self):
431 # These will result in unittest.loader._FailedTest instances rather
432 # than TestCase objects, but they are sufficient for testing.
433 labels = ["label1", "label2", "label3", "label4"]
434 cases = [
435 ({}, ["label1", "label2", "label3", "label4"]),
436 ({"reverse": True}, ["label4", "label3", "label2", "label1"]),
437 ({"shuffle": 8}, ["label4", "label1", "label3", "label2"]),
438 ({"shuffle": 8, "reverse": True}, ["label2", "label3", "label1", "label4"]),
439 ]
440 for kwargs, expected in cases:
441 with self.subTest(kwargs=kwargs):
442 # Prevent writing the seed to stdout.
443 runner = DiscoverRunner(**kwargs, verbosity=0)
444 tests = runner.build_suite(test_labels=labels)
445 # The ids have the form "unittest.loader._FailedTest.label1".
446 names = [test.id().split(".")[-1] for test in tests]
447 self.assertEqual(names, expected)
448
449 def test_overridable_get_test_runner_kwargs(self):
450 self.assertIsInstance(DiscoverRunner().get_test_runner_kwargs(), dict)
451
452 def test_overridable_test_suite(self):
453 self.assertEqual(DiscoverRunner().test_suite, TestSuite)
454
455 def test_overridable_test_runner(self):
456 self.assertEqual(DiscoverRunner().test_runner, TextTestRunner)
457
458 def test_overridable_test_loader(self):
459 self.assertEqual(DiscoverRunner().test_loader, defaultTestLoader)
460
461 def test_tags(self):
462 runner = DiscoverRunner(tags=["core"], verbosity=0)
463 self.assertEqual(
464 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 1
465 )
466 runner = DiscoverRunner(tags=["fast"], verbosity=0)
467 self.assertEqual(
468 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 2
469 )
470 runner = DiscoverRunner(tags=["slow"], verbosity=0)
471 self.assertEqual(
472 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 2
473 )
474
475 def test_exclude_tags(self):
476 runner = DiscoverRunner(tags=["fast"], exclude_tags=["core"], verbosity=0)
477 self.assertEqual(
478 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 1
479 )
480 runner = DiscoverRunner(tags=["fast"], exclude_tags=["slow"], verbosity=0)
481 self.assertEqual(
482 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 0
483 )
484 runner = DiscoverRunner(exclude_tags=["slow"], verbosity=0)
485 self.assertEqual(
486 runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 0
487 )
488
489 def test_tag_inheritance(self):
490 def count_tests(**kwargs):
491 kwargs.setdefault("verbosity", 0)
492 suite = DiscoverRunner(**kwargs).build_suite(
493 ["test_runner_apps.tagged.tests_inheritance"]
494 )
495 return suite.countTestCases()
496
497 self.assertEqual(count_tests(tags=["foo"]), 4)
498 self.assertEqual(count_tests(tags=["bar"]), 2)
499 self.assertEqual(count_tests(tags=["baz"]), 2)
500 self.assertEqual(count_tests(tags=["foo"], exclude_tags=["bar"]), 2)
501 self.assertEqual(count_tests(tags=["foo"], exclude_tags=["bar", "baz"]), 1)
502 self.assertEqual(count_tests(exclude_tags=["foo"]), 0)
503
504 def test_tag_fail_to_load(self):
505 with self.assertRaises(SyntaxError):
506 import_module("test_runner_apps.tagged.tests_syntax_error")
507 runner = DiscoverRunner(tags=["syntax_error"], verbosity=0)
508 # A label that doesn't exist or cannot be loaded due to syntax errors
509 # is always considered matching.
510 suite = runner.build_suite(["doesnotexist", "test_runner_apps.tagged"])
511 self.assertEqual(
512 [test.id() for test in suite],
513 [
514 "unittest.loader._FailedTest.doesnotexist",
515 "unittest.loader._FailedTest.test_runner_apps.tagged."
516 "tests_syntax_error",
517 ],
518 )
519
520 def test_included_tags_displayed(self):
521 runner = DiscoverRunner(tags=["foo", "bar"], verbosity=2)
522 with captured_stdout() as stdout:
523 runner.build_suite(["test_runner_apps.tagged.tests"])
524 self.assertIn("Including test tag(s): bar, foo.\n", stdout.getvalue())
525
526 def test_excluded_tags_displayed(self):
527 runner = DiscoverRunner(exclude_tags=["foo", "bar"], verbosity=3)
528 with captured_stdout() as stdout:
529 runner.build_suite(["test_runner_apps.tagged.tests"])
530 self.assertIn("Excluding test tag(s): bar, foo.\n", stdout.getvalue())
531
532 def test_number_of_tests_found_displayed(self):
533 runner = DiscoverRunner()
534 with captured_stdout() as stdout:
535 runner.build_suite(
536 [
537 "test_runner_apps.sample.tests_sample.TestDjangoTestCase",
538 "test_runner_apps.simple",
539 ]
540 )
541 self.assertIn("Found 14 test(s).\n", stdout.getvalue())
542
543 def test_pdb_with_parallel(self):
544 msg = "You cannot use --pdb with parallel tests; pass --parallel=1 to use it."
545 with self.assertRaisesMessage(ValueError, msg):
546 DiscoverRunner(pdb=True, parallel=2)
547
548 def test_number_of_parallel_workers(self):
549 """Number of processes doesn't exceed the number of TestCases."""
550 runner = DiscoverRunner(parallel=5, verbosity=0)
551 suite = runner.build_suite(["test_runner_apps.tagged"])
552 self.assertEqual(suite.processes, len(suite.subsuites))
553
554 def test_number_of_databases_parallel_test_suite(self):
555 """
556 Number of databases doesn't exceed the number of TestCases with
557 parallel tests.
558 """
559 runner = DiscoverRunner(parallel=8, verbosity=0)
560 suite = runner.build_suite(["test_runner_apps.tagged"])
561 self.assertEqual(suite.processes, len(suite.subsuites))
562 self.assertEqual(runner.parallel, suite.processes)
563
564 def test_number_of_databases_no_parallel_test_suite(self):
565 """
566 Number of databases doesn't exceed the number of TestCases with
567 non-parallel tests.
568 """
569 runner = DiscoverRunner(parallel=8, verbosity=0)
570 suite = runner.build_suite(["test_runner_apps.simple.tests.DjangoCase1"])
571 self.assertEqual(runner.parallel, 1)
572 self.assertIsInstance(suite, TestSuite)
573
574 def test_buffer_mode_test_pass(self):
575 runner = DiscoverRunner(buffer=True, verbosity=0)
576 with captured_stdout() as stdout, captured_stderr() as stderr:
577 suite = runner.build_suite(
578 [
579 "test_runner_apps.buffer.tests_buffer.WriteToStdoutStderrTestCase."
580 "test_pass",
581 ]
582 )
583 runner.run_suite(suite)
584 self.assertNotIn("Write to stderr.", stderr.getvalue())
585 self.assertNotIn("Write to stdout.", stdout.getvalue())
586
587 def test_buffer_mode_test_fail(self):
588 runner = DiscoverRunner(buffer=True, verbosity=0)
589 with captured_stdout() as stdout, captured_stderr() as stderr:
590 suite = runner.build_suite(
591 [
592 "test_runner_apps.buffer.tests_buffer.WriteToStdoutStderrTestCase."
593 "test_fail",
594 ]
595 )
596 runner.run_suite(suite)
597 self.assertIn("Write to stderr.", stderr.getvalue())
598 self.assertIn("Write to stdout.", stdout.getvalue())
599
600 def run_suite_with_runner(self, runner_class, **kwargs):
601 class MyRunner(DiscoverRunner):
602 def test_runner(self, *args, **kwargs):
603 return runner_class()
604
605 runner = MyRunner(**kwargs)
606 # Suppress logging "Using shuffle seed" to the console.
607 with captured_stdout():
608 runner.setup_shuffler()
609 with captured_stdout() as stdout:
610 try:
611 result = runner.run_suite(None)
612 except RuntimeError as exc:
613 result = str(exc)
614 output = stdout.getvalue()
615 return result, output
616
617 def test_run_suite_logs_seed(self):
618 class TestRunner:
619 def run(self, suite):
620 return "<fake-result>"
621
622 expected_prefix = "Used shuffle seed"
623 # Test with and without shuffling enabled.
624 result, output = self.run_suite_with_runner(TestRunner)
625 self.assertEqual(result, "<fake-result>")
626 self.assertNotIn(expected_prefix, output)
627
628 result, output = self.run_suite_with_runner(TestRunner, shuffle=2)
629 self.assertEqual(result, "<fake-result>")
630 expected_output = f"{expected_prefix}: 2 (given)\n"
631 self.assertEqual(output, expected_output)
632
633 def test_run_suite_logs_seed_exception(self):
634 """
635 run_suite() logs the seed when TestRunner.run() raises an exception.
636 """
637
638 class TestRunner:
639 def run(self, suite):
640 raise RuntimeError("my exception")
641
642 result, output = self.run_suite_with_runner(TestRunner, shuffle=2)
643 self.assertEqual(result, "my exception")
644 expected_output = "Used shuffle seed: 2 (given)\n"
645 self.assertEqual(output, expected_output)
646
647 @mock.patch("faulthandler.enable")
648 def test_faulthandler_enabled(self, mocked_enable):
649 with mock.patch("faulthandler.is_enabled", return_value=False):
650 DiscoverRunner(enable_faulthandler=True)
651 mocked_enable.assert_called()
652
653 @mock.patch("faulthandler.enable")
654 def test_faulthandler_already_enabled(self, mocked_enable):
655 with mock.patch("faulthandler.is_enabled", return_value=True):
656 DiscoverRunner(enable_faulthandler=True)
657 mocked_enable.assert_not_called()
658
659 @mock.patch("faulthandler.enable")
660 def test_faulthandler_enabled_fileno(self, mocked_enable):
661 # sys.stderr that is not an actual file.
662 with (
663 mock.patch("faulthandler.is_enabled", return_value=False),
664 captured_stderr(),
665 ):
666 DiscoverRunner(enable_faulthandler=True)
667 mocked_enable.assert_called()
668
669 @mock.patch("faulthandler.enable")
670 def test_faulthandler_disabled(self, mocked_enable):
671 with mock.patch("faulthandler.is_enabled", return_value=False):
672 DiscoverRunner(enable_faulthandler=False)
673 mocked_enable.assert_not_called()
674
675 def test_timings_not_captured(self):
676 runner = DiscoverRunner(timing=False)
677 with captured_stderr() as stderr:
678 with runner.time_keeper.timed("test"):
679 pass
680 runner.time_keeper.print_results()
681 self.assertIsInstance(runner.time_keeper, NullTimeKeeper)
682 self.assertNotIn("test", stderr.getvalue())
683
684 def test_timings_captured(self):
685 runner = DiscoverRunner(timing=True)
686 with captured_stderr() as stderr:
687 with runner.time_keeper.timed("test"):
688 pass
689 runner.time_keeper.print_results()
690 self.assertIsInstance(runner.time_keeper, TimeKeeper)
691 self.assertIn("test", stderr.getvalue())
692
693 def test_log(self):
694 custom_low_level = 5
695 custom_high_level = 45
696 msg = "logging message"
697 cases = [
698 (0, None, False),
699 (0, custom_low_level, False),
700 (0, logging.DEBUG, False),
701 (0, logging.INFO, False),
702 (0, logging.WARNING, False),
703 (0, custom_high_level, False),
704 (1, None, True),
705 (1, custom_low_level, False),
706 (1, logging.DEBUG, False),
707 (1, logging.INFO, True),
708 (1, logging.WARNING, True),
709 (1, custom_high_level, True),
710 (2, None, True),
711 (2, custom_low_level, True),
712 (2, logging.DEBUG, True),
713 (2, logging.INFO, True),
714 (2, logging.WARNING, True),
715 (2, custom_high_level, True),
716 (3, None, True),
717 (3, custom_low_level, True),
718 (3, logging.DEBUG, True),
719 (3, logging.INFO, True),
720 (3, logging.WARNING, True),
721 (3, custom_high_level, True),
722 ]
723 for verbosity, level, output in cases:
724 with self.subTest(verbosity=verbosity, level=level):
725 with captured_stdout() as stdout:
726 runner = DiscoverRunner(verbosity=verbosity)
727 runner.log(msg, level)
728 self.assertEqual(stdout.getvalue(), f"{msg}\n" if output else "")
729
730 def test_log_logger(self):
731 logger = logging.getLogger("test.logging")
732 cases = [
733 (None, "INFO:test.logging:log message"),
734 # Test a low custom logging level.
735 (5, "Level 5:test.logging:log message"),
736 (logging.DEBUG, "DEBUG:test.logging:log message"),
737 (logging.INFO, "INFO:test.logging:log message"),
738 (logging.WARNING, "WARNING:test.logging:log message"),
739 # Test a high custom logging level.
740 (45, "Level 45:test.logging:log message"),
741 ]
742 for level, expected in cases:
743 with self.subTest(level=level):
744 runner = DiscoverRunner(logger=logger)
745 # Pass a logging level smaller than the smallest level in cases
746 # in order to capture all messages.
747 with self.assertLogs("test.logging", level=1) as cm:
748 runner.log("log message", level)
749 self.assertEqual(cm.output, [expected])
750
751 def test_suite_result_with_failure(self):
752 cases = [
753 (1, "FailureTestCase"),
754 (1, "ErrorTestCase"),
755 (0, "ExpectedFailureTestCase"),
756 (1, "UnexpectedSuccessTestCase"),
757 ]
758 runner = DiscoverRunner(verbosity=0)
759 for expected_failures, testcase in cases:
760 with self.subTest(testcase=testcase):
761 suite = runner.build_suite(
762 [
763 f"test_runner_apps.failures.tests_failures.{testcase}",
764 ]
765 )
766 with captured_stderr():
767 result = runner.run_suite(suite)
768 failures = runner.suite_result(suite, result)
769 self.assertEqual(failures, expected_failures)
770
771 @unittest.skipUnless(PY312, "unittest --durations option requires Python 3.12")
772 def test_durations(self):
773 with captured_stderr() as stderr, captured_stdout():
774 runner = DiscoverRunner(durations=10)
775 suite = runner.build_suite(["test_runner_apps.simple.tests.SimpleCase1"])
776 runner.run_suite(suite)
777 self.assertIn("Slowest test durations", stderr.getvalue())
778
779 @unittest.skipUnless(PY312, "unittest --durations option requires Python 3.12")
780 def test_durations_debug_sql(self):
781 with captured_stderr() as stderr, captured_stdout():
782 runner = DiscoverRunner(durations=10, debug_sql=True)
783 suite = runner.build_suite(["test_runner_apps.simple.SimpleCase1"])
784 runner.run_suite(suite)
785 self.assertIn("Slowest test durations", stderr.getvalue())
786
787
788 class DiscoverRunnerGetDatabasesTests(SimpleTestCase):
789 runner = DiscoverRunner(verbosity=2)
790 skip_msg = "Skipping setup of unused database(s): "
791
792 def get_databases(self, test_labels):
793 with captured_stdout() as stdout:
794 suite = self.runner.build_suite(test_labels)
795 databases = self.runner.get_databases(suite)
796 return databases, stdout.getvalue()
797
798 def assertSkippedDatabases(self, test_labels, expected_databases):
799 databases, output = self.get_databases(test_labels)
800 self.assertEqual(databases, expected_databases)
801 skipped_databases = set(connections) - set(expected_databases)
802 if skipped_databases:
803 self.assertIn(self.skip_msg + ", ".join(sorted(skipped_databases)), output)
804 else:
805 self.assertNotIn(self.skip_msg, output)
806
807 def test_mixed(self):
808 databases, output = self.get_databases(["test_runner_apps.databases.tests"])
809 self.assertEqual(databases, {"default": True, "other": False})
810 self.assertNotIn(self.skip_msg, output)
811
812 def test_all(self):
813 databases, output = self.get_databases(
814 ["test_runner_apps.databases.tests.AllDatabasesTests"]
815 )
816 self.assertEqual(databases, {alias: False for alias in connections})
817 self.assertNotIn(self.skip_msg, output)
818
819 def test_default_and_other(self):
820 self.assertSkippedDatabases(
821 [
822 "test_runner_apps.databases.tests.DefaultDatabaseTests",
823 "test_runner_apps.databases.tests.OtherDatabaseTests",
824 ],
825 {"default": False, "other": False},
826 )
827
828 def test_default_only(self):
829 self.assertSkippedDatabases(
830 [
831 "test_runner_apps.databases.tests.DefaultDatabaseTests",
832 ],
833 {"default": False},
834 )
835
836 def test_other_only(self):
837 self.assertSkippedDatabases(
838 ["test_runner_apps.databases.tests.OtherDatabaseTests"], {"other": False}
839 )
840
841 def test_no_databases_required(self):
842 self.assertSkippedDatabases(
843 ["test_runner_apps.databases.tests.NoDatabaseTests"], {}
844 )
845
846 def test_serialize(self):
847 databases, _ = self.get_databases(
848 ["test_runner_apps.databases.tests.DefaultDatabaseSerializedTests"]
849 )
850 self.assertEqual(databases, {"default": True})