diff options
Diffstat (limited to 'tests/test_runner/tests.py')
| -rw-r--r-- | tests/test_runner/tests.py | 734 |
1 files changed, 444 insertions, 290 deletions
diff --git a/tests/test_runner/tests.py b/tests/test_runner/tests.py index 62b489abc7..665f2c5ef8 100644 --- a/tests/test_runner/tests.py +++ b/tests/test_runner/tests.py @@ -15,15 +15,19 @@ from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.core.management import call_command from django.core.management.base import SystemCheckError -from django.test import ( - SimpleTestCase, TransactionTestCase, skipUnlessDBFeature, -) +from django.test import SimpleTestCase, TransactionTestCase, skipUnlessDBFeature from django.test.runner import ( - DiscoverRunner, Shuffler, reorder_test_bin, reorder_tests, shuffle_tests, + DiscoverRunner, + Shuffler, + reorder_test_bin, + reorder_tests, + shuffle_tests, ) from django.test.testcases import connections_support_transactions from django.test.utils import ( - captured_stderr, dependency_ordered, get_unique_databases_and_mirrors, + captured_stderr, + dependency_ordered, + get_unique_databases_and_mirrors, iter_test_cases, ) from django.utils.deprecation import RemovedInDjango50Warning @@ -85,15 +89,21 @@ class TestSuiteTests(SimpleTestCase): # Each test.id() has a form like the following: # "test_runner.tests.IterTestCasesTests.test_iter_test_cases.<locals>.Tests1.test1". # It suffices to check only the last two parts. - names = ['.'.join(test.id().split('.')[-2:]) for test in tests] + names = [".".join(test.id().split(".")[-2:]) for test in tests] self.assertEqual(names, expected) def test_iter_test_cases_basic(self): suite = self.make_test_suite() tests = iter_test_cases(suite) - self.assertTestNames(tests, expected=[ - 'Tests1.test1', 'Tests1.test2', 'Tests2.test1', 'Tests2.test2', - ]) + self.assertTestNames( + tests, + expected=[ + "Tests1.test1", + "Tests1.test2", + "Tests2.test1", + "Tests2.test2", + ], + ) def test_iter_test_cases_string_input(self): msg = ( @@ -101,7 +111,7 @@ class TestSuiteTests(SimpleTestCase): "in 'abc')." ) with self.assertRaisesMessage(TypeError, msg): - list(iter_test_cases('abc')) + list(iter_test_cases("abc")) def test_iter_test_cases_iterable_of_tests(self): class Tests(unittest.TestCase): @@ -113,16 +123,26 @@ class TestSuiteTests(SimpleTestCase): tests = list(unittest.defaultTestLoader.loadTestsFromTestCase(Tests)) actual_tests = iter_test_cases(tests) - self.assertTestNames(actual_tests, expected=[ - 'Tests.test1', 'Tests.test2', - ]) + self.assertTestNames( + actual_tests, + expected=[ + "Tests.test1", + "Tests.test2", + ], + ) def test_iter_test_cases_custom_test_suite_class(self): suite = self.make_test_suite(suite_class=MySuite) tests = iter_test_cases(suite) - self.assertTestNames(tests, expected=[ - 'Tests1.test1', 'Tests1.test2', 'Tests2.test1', 'Tests2.test2', - ]) + self.assertTestNames( + tests, + expected=[ + "Tests1.test1", + "Tests1.test2", + "Tests2.test1", + "Tests2.test2", + ], + ) def test_iter_test_cases_mixed_test_suite_classes(self): suite = self.make_test_suite(suite=MySuite()) @@ -144,25 +164,43 @@ class TestSuiteTests(SimpleTestCase): shuffler = Shuffler(seed=9) shuffled_tests = shuffle_tests(tests, shuffler) self.assertIsInstance(shuffled_tests, collections.abc.Iterator) - self.assertTestNames(shuffled_tests, expected=[ - 'Tests2.test1', 'Tests2.test2', 'Tests1.test2', 'Tests1.test1', - ]) + self.assertTestNames( + shuffled_tests, + expected=[ + "Tests2.test1", + "Tests2.test2", + "Tests1.test2", + "Tests1.test1", + ], + ) def test_reorder_test_bin_no_arguments(self): tests = self.make_tests() reordered_tests = reorder_test_bin(tests) self.assertIsInstance(reordered_tests, collections.abc.Iterator) - self.assertTestNames(reordered_tests, expected=[ - 'Tests1.test1', 'Tests1.test2', 'Tests2.test1', 'Tests2.test2', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests1.test1", + "Tests1.test2", + "Tests2.test1", + "Tests2.test2", + ], + ) def test_reorder_test_bin_reverse(self): tests = self.make_tests() reordered_tests = reorder_test_bin(tests, reverse=True) self.assertIsInstance(reordered_tests, collections.abc.Iterator) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test2', 'Tests2.test1', 'Tests1.test2', 'Tests1.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test2", + "Tests2.test1", + "Tests1.test2", + "Tests1.test1", + ], + ) def test_reorder_test_bin_random(self): tests = self.make_tests() @@ -170,9 +208,15 @@ class TestSuiteTests(SimpleTestCase): shuffler = Shuffler(seed=9) reordered_tests = reorder_test_bin(tests, shuffler=shuffler) self.assertIsInstance(reordered_tests, collections.abc.Iterator) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test1', 'Tests2.test2', 'Tests1.test2', 'Tests1.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test1", + "Tests2.test2", + "Tests1.test2", + "Tests1.test1", + ], + ) def test_reorder_test_bin_random_and_reverse(self): tests = self.make_tests() @@ -180,22 +224,40 @@ class TestSuiteTests(SimpleTestCase): shuffler = Shuffler(seed=9) reordered_tests = reorder_test_bin(tests, shuffler=shuffler, reverse=True) self.assertIsInstance(reordered_tests, collections.abc.Iterator) - self.assertTestNames(reordered_tests, expected=[ - 'Tests1.test1', 'Tests1.test2', 'Tests2.test2', 'Tests2.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests1.test1", + "Tests1.test2", + "Tests2.test2", + "Tests2.test1", + ], + ) def test_reorder_tests_same_type_consecutive(self): """Tests of the same type are made consecutive.""" tests = self.make_tests() # Move the last item to the front. tests.insert(0, tests.pop()) - self.assertTestNames(tests, expected=[ - 'Tests2.test2', 'Tests1.test1', 'Tests1.test2', 'Tests2.test1', - ]) + self.assertTestNames( + tests, + expected=[ + "Tests2.test2", + "Tests1.test1", + "Tests1.test2", + "Tests2.test1", + ], + ) reordered_tests = reorder_tests(tests, classes=[]) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test2', 'Tests2.test1', 'Tests1.test1', 'Tests1.test2', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test2", + "Tests2.test1", + "Tests1.test1", + "Tests1.test2", + ], + ) def test_reorder_tests_random(self): tests = self.make_tests() @@ -203,22 +265,40 @@ class TestSuiteTests(SimpleTestCase): shuffler = Shuffler(seed=9) reordered_tests = reorder_tests(tests, classes=[], shuffler=shuffler) self.assertIsInstance(reordered_tests, collections.abc.Iterator) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test1', 'Tests2.test2', 'Tests1.test2', 'Tests1.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test1", + "Tests2.test2", + "Tests1.test2", + "Tests1.test1", + ], + ) def test_reorder_tests_random_mixed_classes(self): tests = self.make_tests() # Move the last item to the front. tests.insert(0, tests.pop()) shuffler = Shuffler(seed=9) - self.assertTestNames(tests, expected=[ - 'Tests2.test2', 'Tests1.test1', 'Tests1.test2', 'Tests2.test1', - ]) + self.assertTestNames( + tests, + expected=[ + "Tests2.test2", + "Tests1.test1", + "Tests1.test2", + "Tests2.test1", + ], + ) reordered_tests = reorder_tests(tests, classes=[], shuffler=shuffler) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test1', 'Tests2.test2', 'Tests1.test2', 'Tests1.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test1", + "Tests2.test2", + "Tests1.test2", + "Tests1.test1", + ], + ) def test_reorder_tests_reverse_with_duplicates(self): class Tests1(unittest.TestCase): @@ -236,124 +316,133 @@ class TestSuiteTests(SimpleTestCase): subsuite = list(suite)[0] suite.addTest(subsuite) tests = list(iter_test_cases(suite)) - self.assertTestNames(tests, expected=[ - 'Tests1.test1', 'Tests2.test2', 'Tests2.test3', 'Tests1.test1', - ]) + self.assertTestNames( + tests, + expected=[ + "Tests1.test1", + "Tests2.test2", + "Tests2.test3", + "Tests1.test1", + ], + ) reordered_tests = reorder_tests(tests, classes=[]) - self.assertTestNames(reordered_tests, expected=[ - 'Tests1.test1', 'Tests2.test2', 'Tests2.test3', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests1.test1", + "Tests2.test2", + "Tests2.test3", + ], + ) reordered_tests = reorder_tests(tests, classes=[], reverse=True) - self.assertTestNames(reordered_tests, expected=[ - 'Tests2.test3', 'Tests2.test2', 'Tests1.test1', - ]) + self.assertTestNames( + reordered_tests, + expected=[ + "Tests2.test3", + "Tests2.test2", + "Tests1.test1", + ], + ) class DependencyOrderingTests(unittest.TestCase): - def test_simple_dependencies(self): raw = [ - ('s1', ('s1_db', ['alpha'])), - ('s2', ('s2_db', ['bravo'])), - ('s3', ('s3_db', ['charlie'])), + ("s1", ("s1_db", ["alpha"])), + ("s2", ("s2_db", ["bravo"])), + ("s3", ("s3_db", ["charlie"])), ] dependencies = { - 'alpha': ['charlie'], - 'bravo': ['charlie'], + "alpha": ["charlie"], + "bravo": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, value in ordered] - self.assertIn('s1', ordered_sigs) - self.assertIn('s2', ordered_sigs) - self.assertIn('s3', ordered_sigs) - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1')) - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2')) + self.assertIn("s1", ordered_sigs) + self.assertIn("s2", ordered_sigs) + self.assertIn("s3", ordered_sigs) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) def test_chained_dependencies(self): raw = [ - ('s1', ('s1_db', ['alpha'])), - ('s2', ('s2_db', ['bravo'])), - ('s3', ('s3_db', ['charlie'])), + ("s1", ("s1_db", ["alpha"])), + ("s2", ("s2_db", ["bravo"])), + ("s3", ("s3_db", ["charlie"])), ] dependencies = { - 'alpha': ['bravo'], - 'bravo': ['charlie'], + "alpha": ["bravo"], + "bravo": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, value in ordered] - self.assertIn('s1', ordered_sigs) - self.assertIn('s2', ordered_sigs) - self.assertIn('s3', ordered_sigs) + self.assertIn("s1", ordered_sigs) + self.assertIn("s2", ordered_sigs) + self.assertIn("s3", ordered_sigs) # Explicit dependencies - self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1')) - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2')) + self.assertLess(ordered_sigs.index("s2"), ordered_sigs.index("s1")) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) # Implied dependencies - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1')) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) def test_multiple_dependencies(self): raw = [ - ('s1', ('s1_db', ['alpha'])), - ('s2', ('s2_db', ['bravo'])), - ('s3', ('s3_db', ['charlie'])), - ('s4', ('s4_db', ['delta'])), + ("s1", ("s1_db", ["alpha"])), + ("s2", ("s2_db", ["bravo"])), + ("s3", ("s3_db", ["charlie"])), + ("s4", ("s4_db", ["delta"])), ] dependencies = { - 'alpha': ['bravo', 'delta'], - 'bravo': ['charlie'], - 'delta': ['charlie'], + "alpha": ["bravo", "delta"], + "bravo": ["charlie"], + "delta": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, aliases in ordered] - self.assertIn('s1', ordered_sigs) - self.assertIn('s2', ordered_sigs) - self.assertIn('s3', ordered_sigs) - self.assertIn('s4', ordered_sigs) + self.assertIn("s1", ordered_sigs) + self.assertIn("s2", ordered_sigs) + self.assertIn("s3", ordered_sigs) + self.assertIn("s4", ordered_sigs) # Explicit dependencies - self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1')) - self.assertLess(ordered_sigs.index('s4'), ordered_sigs.index('s1')) - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2')) - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s4')) + self.assertLess(ordered_sigs.index("s2"), ordered_sigs.index("s1")) + self.assertLess(ordered_sigs.index("s4"), ordered_sigs.index("s1")) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s4")) # Implicit dependencies - self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1')) + self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) def test_circular_dependencies(self): raw = [ - ('s1', ('s1_db', ['alpha'])), - ('s2', ('s2_db', ['bravo'])), + ("s1", ("s1_db", ["alpha"])), + ("s2", ("s2_db", ["bravo"])), ] dependencies = { - 'bravo': ['alpha'], - 'alpha': ['bravo'], + "bravo": ["alpha"], + "alpha": ["bravo"], } with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) def test_own_alias_dependency(self): - raw = [ - ('s1', ('s1_db', ['alpha', 'bravo'])) - ] - dependencies = { - 'alpha': ['bravo'] - } + raw = [("s1", ("s1_db", ["alpha", "bravo"]))] + dependencies = {"alpha": ["bravo"]} with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) # reordering aliases shouldn't matter - raw = [ - ('s1', ('s1_db', ['bravo', 'alpha'])) - ] + raw = [("s1", ("s1_db", ["bravo", "alpha"]))] with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) @@ -361,105 +450,108 @@ class DependencyOrderingTests(unittest.TestCase): class MockTestRunner: def __init__(self, *args, **kwargs): - if parallel := kwargs.get('parallel'): - sys.stderr.write(f'parallel={parallel}') + if parallel := kwargs.get("parallel"): + sys.stderr.write(f"parallel={parallel}") MockTestRunner.run_tests = mock.Mock(return_value=[]) class ManageCommandTests(unittest.TestCase): - def test_custom_test_runner(self): - call_command('test', 'sites', - testrunner='test_runner.tests.MockTestRunner') - MockTestRunner.run_tests.assert_called_with(('sites',)) + call_command("test", "sites", testrunner="test_runner.tests.MockTestRunner") + MockTestRunner.run_tests.assert_called_with(("sites",)) def test_bad_test_runner(self): with self.assertRaises(AttributeError): - call_command('test', 'sites', testrunner='test_runner.NonexistentRunner') + call_command("test", "sites", testrunner="test_runner.NonexistentRunner") def test_time_recorded(self): with captured_stderr() as stderr: - call_command('test', '--timing', 'sites', testrunner='test_runner.tests.MockTestRunner') - self.assertIn('Total run took', stderr.getvalue()) + call_command( + "test", + "--timing", + "sites", + testrunner="test_runner.tests.MockTestRunner", + ) + self.assertIn("Total run took", stderr.getvalue()) # Isolate from the real environment. @mock.patch.dict(os.environ, {}, clear=True) -@mock.patch.object(multiprocessing, 'cpu_count', return_value=12) +@mock.patch.object(multiprocessing, "cpu_count", return_value=12) # Python 3.8 on macOS defaults to 'spawn' mode. -@mock.patch.object(multiprocessing, 'get_start_method', return_value='fork') +@mock.patch.object(multiprocessing, "get_start_method", return_value="fork") class ManageCommandParallelTests(SimpleTestCase): def test_parallel_default(self, *mocked_objects): with captured_stderr() as stderr: call_command( - 'test', - '--parallel', - testrunner='test_runner.tests.MockTestRunner', + "test", + "--parallel", + testrunner="test_runner.tests.MockTestRunner", ) - self.assertIn('parallel=12', stderr.getvalue()) + self.assertIn("parallel=12", stderr.getvalue()) def test_parallel_auto(self, *mocked_objects): with captured_stderr() as stderr: call_command( - 'test', - '--parallel=auto', - testrunner='test_runner.tests.MockTestRunner', + "test", + "--parallel=auto", + testrunner="test_runner.tests.MockTestRunner", ) - self.assertIn('parallel=12', stderr.getvalue()) + self.assertIn("parallel=12", stderr.getvalue()) def test_no_parallel(self, *mocked_objects): with captured_stderr() as stderr: - call_command('test', testrunner='test_runner.tests.MockTestRunner') + call_command("test", testrunner="test_runner.tests.MockTestRunner") # Parallel is disabled by default. - self.assertEqual(stderr.getvalue(), '') + self.assertEqual(stderr.getvalue(), "") def test_parallel_spawn(self, mocked_get_start_method, mocked_cpu_count): - mocked_get_start_method.return_value = 'spawn' + mocked_get_start_method.return_value = "spawn" with captured_stderr() as stderr: call_command( - 'test', - '--parallel=auto', - testrunner='test_runner.tests.MockTestRunner', + "test", + "--parallel=auto", + testrunner="test_runner.tests.MockTestRunner", ) - self.assertIn('parallel=1', stderr.getvalue()) + self.assertIn("parallel=1", stderr.getvalue()) def test_no_parallel_spawn(self, mocked_get_start_method, mocked_cpu_count): - mocked_get_start_method.return_value = 'spawn' + mocked_get_start_method.return_value = "spawn" with captured_stderr() as stderr: call_command( - 'test', - testrunner='test_runner.tests.MockTestRunner', + "test", + testrunner="test_runner.tests.MockTestRunner", ) - self.assertEqual(stderr.getvalue(), '') + self.assertEqual(stderr.getvalue(), "") - @mock.patch.dict(os.environ, {'DJANGO_TEST_PROCESSES': '7'}) + @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}) def test_no_parallel_django_test_processes_env(self, *mocked_objects): with captured_stderr() as stderr: - call_command('test', testrunner='test_runner.tests.MockTestRunner') - self.assertEqual(stderr.getvalue(), '') + call_command("test", testrunner="test_runner.tests.MockTestRunner") + self.assertEqual(stderr.getvalue(), "") - @mock.patch.dict(os.environ, {'DJANGO_TEST_PROCESSES': 'invalid'}) + @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "invalid"}) def test_django_test_processes_env_non_int(self, *mocked_objects): with self.assertRaises(ValueError): call_command( - 'test', - '--parallel', - testrunner='test_runner.tests.MockTestRunner', + "test", + "--parallel", + testrunner="test_runner.tests.MockTestRunner", ) - @mock.patch.dict(os.environ, {'DJANGO_TEST_PROCESSES': '7'}) + @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}) def test_django_test_processes_parallel_default(self, *mocked_objects): - for parallel in ['--parallel', '--parallel=auto']: + for parallel in ["--parallel", "--parallel=auto"]: with self.subTest(parallel=parallel): with captured_stderr() as stderr: call_command( - 'test', + "test", parallel, - testrunner='test_runner.tests.MockTestRunner', + testrunner="test_runner.tests.MockTestRunner", ) - self.assertIn('parallel=7', stderr.getvalue()) + self.assertIn("parallel=7", stderr.getvalue()) class CustomTestRunnerOptionsSettingsTests(AdminScriptTestCase): @@ -467,37 +559,43 @@ class CustomTestRunnerOptionsSettingsTests(AdminScriptTestCase): Custom runners can add command line arguments. The runner is specified through a settings file. """ + def setUp(self): super().setUp() settings = { - 'TEST_RUNNER': '\'test_runner.runner.CustomOptionsTestRunner\'', + "TEST_RUNNER": "'test_runner.runner.CustomOptionsTestRunner'", } - self.write_settings('settings.py', sdict=settings) + self.write_settings("settings.py", sdict=settings) def test_default_options(self): - args = ['test', '--settings=test_project.settings'] + args = ["test", "--settings=test_project.settings"] out, err = self.run_django_admin(args) self.assertNoOutput(err) - self.assertOutput(out, '1:2:3') + self.assertOutput(out, "1:2:3") def test_default_and_given_options(self): - args = ['test', '--settings=test_project.settings', '--option_b=foo'] + args = ["test", "--settings=test_project.settings", "--option_b=foo"] out, err = self.run_django_admin(args) self.assertNoOutput(err) - self.assertOutput(out, '1:foo:3') + self.assertOutput(out, "1:foo:3") def test_option_name_and_value_separated(self): - args = ['test', '--settings=test_project.settings', '--option_b', 'foo'] + args = ["test", "--settings=test_project.settings", "--option_b", "foo"] out, err = self.run_django_admin(args) self.assertNoOutput(err) - self.assertOutput(out, '1:foo:3') + self.assertOutput(out, "1:foo:3") def test_all_options_given(self): - args = ['test', '--settings=test_project.settings', '--option_a=bar', - '--option_b=foo', '--option_c=31337'] + args = [ + "test", + "--settings=test_project.settings", + "--option_a=bar", + "--option_b=foo", + "--option_c=31337", + ] out, err = self.run_django_admin(args) self.assertNoOutput(err) - self.assertOutput(out, 'bar:foo:31337') + self.assertOutput(out, "bar:foo:31337") class CustomTestRunnerOptionsCmdlineTests(AdminScriptTestCase): @@ -505,54 +603,64 @@ class CustomTestRunnerOptionsCmdlineTests(AdminScriptTestCase): Custom runners can add command line arguments when the runner is specified using --testrunner. """ + def setUp(self): super().setUp() - self.write_settings('settings.py') + self.write_settings("settings.py") def test_testrunner_option(self): args = [ - 'test', '--testrunner', 'test_runner.runner.CustomOptionsTestRunner', - '--option_a=bar', '--option_b=foo', '--option_c=31337' + "test", + "--testrunner", + "test_runner.runner.CustomOptionsTestRunner", + "--option_a=bar", + "--option_b=foo", + "--option_c=31337", ] - out, err = self.run_django_admin(args, 'test_project.settings') + out, err = self.run_django_admin(args, "test_project.settings") self.assertNoOutput(err) - self.assertOutput(out, 'bar:foo:31337') + self.assertOutput(out, "bar:foo:31337") def test_testrunner_equals(self): args = [ - 'test', '--testrunner=test_runner.runner.CustomOptionsTestRunner', - '--option_a=bar', '--option_b=foo', '--option_c=31337' + "test", + "--testrunner=test_runner.runner.CustomOptionsTestRunner", + "--option_a=bar", + "--option_b=foo", + "--option_c=31337", ] - out, err = self.run_django_admin(args, 'test_project.settings') + out, err = self.run_django_admin(args, "test_project.settings") self.assertNoOutput(err) - self.assertOutput(out, 'bar:foo:31337') + self.assertOutput(out, "bar:foo:31337") def test_no_testrunner(self): - args = ['test', '--testrunner'] - out, err = self.run_django_admin(args, 'test_project.settings') - self.assertIn('usage', err) - self.assertNotIn('Traceback', err) + args = ["test", "--testrunner"] + out, err = self.run_django_admin(args, "test_project.settings") + self.assertIn("usage", err) + self.assertNotIn("Traceback", err) self.assertNoOutput(out) class Ticket17477RegressionTests(AdminScriptTestCase): def setUp(self): super().setUp() - self.write_settings('settings.py') + self.write_settings("settings.py") def test_ticket_17477(self): """'manage.py help test' works after r16352.""" - args = ['help', 'test'] + args = ["help", "test"] out, err = self.run_manage(args) self.assertNoOutput(err) class SQLiteInMemoryTestDbs(TransactionTestCase): - available_apps = ['test_runner'] - databases = {'default', 'other'} + available_apps = ["test_runner"] + databases = {"default", "other"} - @unittest.skipUnless(all(db.connections[conn].vendor == 'sqlite' for conn in db.connections), - "This is an sqlite-specific issue") + @unittest.skipUnless( + all(db.connections[conn].vendor == "sqlite" for conn in db.connections), + "This is an sqlite-specific issue", + ) def test_transaction_support(self): # Assert connections mocking is appropriately applied by preventing # any attempts at calling create_test_db on the global connection @@ -560,29 +668,36 @@ class SQLiteInMemoryTestDbs(TransactionTestCase): for connection in db.connections.all(): create_test_db = mock.patch.object( connection.creation, - 'create_test_db', - side_effect=AssertionError("Global connection object shouldn't be manipulated.") + "create_test_db", + side_effect=AssertionError( + "Global connection object shouldn't be manipulated." + ), ) create_test_db.start() self.addCleanup(create_test_db.stop) for option_key, option_value in ( - ('NAME', ':memory:'), ('TEST', {'NAME': ':memory:'})): - tested_connections = db.ConnectionHandler({ - 'default': { - 'ENGINE': 'django.db.backends.sqlite3', - option_key: option_value, - }, - 'other': { - 'ENGINE': 'django.db.backends.sqlite3', - option_key: option_value, - }, - }) - with mock.patch('django.test.utils.connections', new=tested_connections): - other = tested_connections['other'] + ("NAME", ":memory:"), + ("TEST", {"NAME": ":memory:"}), + ): + tested_connections = db.ConnectionHandler( + { + "default": { + "ENGINE": "django.db.backends.sqlite3", + option_key: option_value, + }, + "other": { + "ENGINE": "django.db.backends.sqlite3", + option_key: option_value, + }, + } + ) + with mock.patch("django.test.utils.connections", new=tested_connections): + other = tested_connections["other"] DiscoverRunner(verbosity=0).setup_databases() msg = ( "DATABASES setting '%s' option set to sqlite3's ':memory:' value " - "shouldn't interfere with transaction support detection." % option_key + "shouldn't interfere with transaction support detection." + % option_key ) # Transaction support is properly initialized for the 'other' DB. self.assertTrue(other.features.supports_transactions, msg) @@ -596,7 +711,7 @@ class DummyBackendTest(unittest.TestCase): setup_databases() doesn't fail with dummy database backend. """ tested_connections = db.ConnectionHandler({}) - with mock.patch('django.test.utils.connections', new=tested_connections): + with mock.patch("django.test.utils.connections", new=tested_connections): runner_instance = DiscoverRunner(verbosity=0) old_config = runner_instance.setup_databases() runner_instance.teardown_databases(old_config) @@ -607,110 +722,126 @@ class AliasedDefaultTestSetupTest(unittest.TestCase): """ setup_databases() doesn't fail when 'default' is aliased """ - tested_connections = db.ConnectionHandler({ - 'default': { - 'NAME': 'dummy' - }, - 'aliased': { - 'NAME': 'dummy' - } - }) - with mock.patch('django.test.utils.connections', new=tested_connections): + tested_connections = db.ConnectionHandler( + {"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}} + ) + with mock.patch("django.test.utils.connections", new=tested_connections): runner_instance = DiscoverRunner(verbosity=0) old_config = runner_instance.setup_databases() runner_instance.teardown_databases(old_config) class SetupDatabasesTests(SimpleTestCase): - def setUp(self): self.runner_instance = DiscoverRunner(verbosity=0) def test_setup_aliased_databases(self): - tested_connections = db.ConnectionHandler({ - 'default': { - 'ENGINE': 'django.db.backends.dummy', - 'NAME': 'dbname', - }, - 'other': { - 'ENGINE': 'django.db.backends.dummy', - 'NAME': 'dbname', + tested_connections = db.ConnectionHandler( + { + "default": { + "ENGINE": "django.db.backends.dummy", + "NAME": "dbname", + }, + "other": { + "ENGINE": "django.db.backends.dummy", + "NAME": "dbname", + }, } - }) + ) - with mock.patch('django.db.backends.dummy.base.DatabaseWrapper.creation_class') as mocked_db_creation: - with mock.patch('django.test.utils.connections', new=tested_connections): + with mock.patch( + "django.db.backends.dummy.base.DatabaseWrapper.creation_class" + ) as mocked_db_creation: + with mock.patch("django.test.utils.connections", new=tested_connections): old_config = self.runner_instance.setup_databases() self.runner_instance.teardown_databases(old_config) - mocked_db_creation.return_value.destroy_test_db.assert_called_once_with('dbname', 0, False) + mocked_db_creation.return_value.destroy_test_db.assert_called_once_with( + "dbname", 0, False + ) def test_setup_test_database_aliases(self): """ The default database must be the first because data migrations use the default alias by default. """ - tested_connections = db.ConnectionHandler({ - 'other': { - 'ENGINE': 'django.db.backends.dummy', - 'NAME': 'dbname', - }, - 'default': { - 'ENGINE': 'django.db.backends.dummy', - 'NAME': 'dbname', + tested_connections = db.ConnectionHandler( + { + "other": { + "ENGINE": "django.db.backends.dummy", + "NAME": "dbname", + }, + "default": { + "ENGINE": "django.db.backends.dummy", + "NAME": "dbname", + }, } - }) - with mock.patch('django.test.utils.connections', new=tested_connections): + ) + with mock.patch("django.test.utils.connections", new=tested_connections): test_databases, _ = get_unique_databases_and_mirrors() self.assertEqual( test_databases, { - ('', '', 'django.db.backends.dummy', 'test_dbname'): ( - 'dbname', - ['default', 'other'], + ("", "", "django.db.backends.dummy", "test_dbname"): ( + "dbname", + ["default", "other"], ), }, ) def test_destroy_test_db_restores_db_name(self): - tested_connections = db.ConnectionHandler({ - 'default': { - 'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"], - 'NAME': 'xxx_test_database', - }, - }) + tested_connections = db.ConnectionHandler( + { + "default": { + "ENGINE": settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"], + "NAME": "xxx_test_database", + }, + } + ) # Using the real current name as old_name to not mess with the test suite. old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"] - with mock.patch('django.db.connections', new=tested_connections): - tested_connections['default'].creation.destroy_test_db(old_name, verbosity=0, keepdb=True) - self.assertEqual(tested_connections['default'].settings_dict["NAME"], old_name) + with mock.patch("django.db.connections", new=tested_connections): + tested_connections["default"].creation.destroy_test_db( + old_name, verbosity=0, keepdb=True + ) + self.assertEqual( + tested_connections["default"].settings_dict["NAME"], old_name + ) def test_serialization(self): - tested_connections = db.ConnectionHandler({ - 'default': { - 'ENGINE': 'django.db.backends.dummy', - }, - }) - with mock.patch('django.db.backends.dummy.base.DatabaseWrapper.creation_class') as mocked_db_creation: - with mock.patch('django.test.utils.connections', new=tested_connections): + tested_connections = db.ConnectionHandler( + { + "default": { + "ENGINE": "django.db.backends.dummy", + }, + } + ) + with mock.patch( + "django.db.backends.dummy.base.DatabaseWrapper.creation_class" + ) as mocked_db_creation: + with mock.patch("django.test.utils.connections", new=tested_connections): self.runner_instance.setup_databases() mocked_db_creation.return_value.create_test_db.assert_called_once_with( verbosity=0, autoclobber=False, serialize=True, keepdb=False ) def test_serialized_off(self): - tested_connections = db.ConnectionHandler({ - 'default': { - 'ENGINE': 'django.db.backends.dummy', - 'TEST': {'SERIALIZE': False}, - }, - }) + tested_connections = db.ConnectionHandler( + { + "default": { + "ENGINE": "django.db.backends.dummy", + "TEST": {"SERIALIZE": False}, + }, + } + ) msg = ( - 'The SERIALIZE test database setting is deprecated as it can be ' - 'inferred from the TestCase/TransactionTestCase.databases that ' - 'enable the serialized_rollback feature.' + "The SERIALIZE test database setting is deprecated as it can be " + "inferred from the TestCase/TransactionTestCase.databases that " + "enable the serialized_rollback feature." ) - with mock.patch('django.db.backends.dummy.base.DatabaseWrapper.creation_class') as mocked_db_creation: - with mock.patch('django.test.utils.connections', new=tested_connections): + with mock.patch( + "django.db.backends.dummy.base.DatabaseWrapper.creation_class" + ) as mocked_db_creation: + with mock.patch("django.test.utils.connections", new=tested_connections): with self.assertWarnsMessage(RemovedInDjango50Warning, msg): self.runner_instance.setup_databases() mocked_db_creation.return_value.create_test_db.assert_called_once_with( @@ -718,23 +849,23 @@ class SetupDatabasesTests(SimpleTestCase): ) -@skipUnlessDBFeature('supports_sequence_reset') +@skipUnlessDBFeature("supports_sequence_reset") class AutoIncrementResetTest(TransactionTestCase): """ Creating the same models in different test methods receive the same PK values since the sequences are reset before each test method. """ - available_apps = ['test_runner'] + available_apps = ["test_runner"] reset_sequences = True def _test(self): # Regular model - p = Person.objects.create(first_name='Jack', last_name='Smith') + p = Person.objects.create(first_name="Jack", last_name="Smith") self.assertEqual(p.pk, 1) # Auto-created many-to-many through model - p.friends.add(Person.objects.create(first_name='Jacky', last_name='Smith')) + p.friends.add(Person.objects.create(first_name="Jacky", last_name="Smith")) self.assertEqual(p.friends.through.objects.first().pk, 1) # Many-to-many through model b = B.objects.create() @@ -754,10 +885,12 @@ class EmptyDefaultDatabaseTest(unittest.TestCase): An empty default database in settings does not raise an ImproperlyConfigured error when running a unit test that does not use a database. """ - tested_connections = db.ConnectionHandler({'default': {}}) - with mock.patch('django.db.connections', new=tested_connections): + tested_connections = db.ConnectionHandler({"default": {}}) + with mock.patch("django.db.connections", new=tested_connections): connection = tested_connections[db.utils.DEFAULT_DB_ALIAS] - self.assertEqual(connection.settings_dict['ENGINE'], 'django.db.backends.dummy') + self.assertEqual( + connection.settings_dict["ENGINE"], "django.db.backends.dummy" + ) connections_support_transactions() @@ -766,15 +899,22 @@ class RunTestsExceptionHandlingTests(unittest.TestCase): """ Teardown functions are run when run_checks() raises SystemCheckError. """ - with mock.patch('django.test.runner.DiscoverRunner.setup_test_environment'), \ - mock.patch('django.test.runner.DiscoverRunner.setup_databases'), \ - mock.patch('django.test.runner.DiscoverRunner.build_suite'), \ - mock.patch('django.test.runner.DiscoverRunner.run_checks', side_effect=SystemCheckError), \ - mock.patch('django.test.runner.DiscoverRunner.teardown_databases') as teardown_databases, \ - mock.patch('django.test.runner.DiscoverRunner.teardown_test_environment') as teardown_test_environment: + with mock.patch( + "django.test.runner.DiscoverRunner.setup_test_environment" + ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( + "django.test.runner.DiscoverRunner.build_suite" + ), mock.patch( + "django.test.runner.DiscoverRunner.run_checks", side_effect=SystemCheckError + ), mock.patch( + "django.test.runner.DiscoverRunner.teardown_databases" + ) as teardown_databases, mock.patch( + "django.test.runner.DiscoverRunner.teardown_test_environment" + ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(SystemCheckError): - runner.run_tests(['test_runner_apps.sample.tests_sample.TestDjangoTestCase']) + runner.run_tests( + ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] + ) self.assertTrue(teardown_databases.called) self.assertTrue(teardown_test_environment.called) @@ -783,16 +923,23 @@ class RunTestsExceptionHandlingTests(unittest.TestCase): SystemCheckError is surfaced when run_checks() raises SystemCheckError and teardown databases() raises ValueError. """ - with mock.patch('django.test.runner.DiscoverRunner.setup_test_environment'), \ - mock.patch('django.test.runner.DiscoverRunner.setup_databases'), \ - mock.patch('django.test.runner.DiscoverRunner.build_suite'), \ - mock.patch('django.test.runner.DiscoverRunner.run_checks', side_effect=SystemCheckError), \ - mock.patch('django.test.runner.DiscoverRunner.teardown_databases', side_effect=ValueError) \ - as teardown_databases, \ - mock.patch('django.test.runner.DiscoverRunner.teardown_test_environment') as teardown_test_environment: + with mock.patch( + "django.test.runner.DiscoverRunner.setup_test_environment" + ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( + "django.test.runner.DiscoverRunner.build_suite" + ), mock.patch( + "django.test.runner.DiscoverRunner.run_checks", side_effect=SystemCheckError + ), mock.patch( + "django.test.runner.DiscoverRunner.teardown_databases", + side_effect=ValueError, + ) as teardown_databases, mock.patch( + "django.test.runner.DiscoverRunner.teardown_test_environment" + ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(SystemCheckError): - runner.run_tests(['test_runner_apps.sample.tests_sample.TestDjangoTestCase']) + runner.run_tests( + ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] + ) self.assertTrue(teardown_databases.called) self.assertFalse(teardown_test_environment.called) @@ -801,18 +948,25 @@ class RunTestsExceptionHandlingTests(unittest.TestCase): Exceptions on teardown are surfaced if no exceptions happen during run_checks(). """ - with mock.patch('django.test.runner.DiscoverRunner.setup_test_environment'), \ - mock.patch('django.test.runner.DiscoverRunner.setup_databases'), \ - mock.patch('django.test.runner.DiscoverRunner.build_suite'), \ - mock.patch('django.test.runner.DiscoverRunner.run_checks'), \ - mock.patch('django.test.runner.DiscoverRunner.teardown_databases', side_effect=ValueError) \ - as teardown_databases, \ - mock.patch('django.test.runner.DiscoverRunner.teardown_test_environment') as teardown_test_environment: + with mock.patch( + "django.test.runner.DiscoverRunner.setup_test_environment" + ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( + "django.test.runner.DiscoverRunner.build_suite" + ), mock.patch( + "django.test.runner.DiscoverRunner.run_checks" + ), mock.patch( + "django.test.runner.DiscoverRunner.teardown_databases", + side_effect=ValueError, + ) as teardown_databases, mock.patch( + "django.test.runner.DiscoverRunner.teardown_test_environment" + ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(ValueError): # Suppress the output when running TestDjangoTestCase. - with mock.patch('sys.stderr'): - runner.run_tests(['test_runner_apps.sample.tests_sample.TestDjangoTestCase']) + with mock.patch("sys.stderr"): + runner.run_tests( + ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] + ) self.assertTrue(teardown_databases.called) self.assertFalse(teardown_test_environment.called) @@ -836,7 +990,7 @@ class NoOpTestRunner(DiscoverRunner): class DiscoverRunnerExtraTestsDeprecationTests(SimpleTestCase): - msg = 'The extra_tests argument is deprecated.' + msg = "The extra_tests argument is deprecated." def get_runner(self): return NoOpTestRunner(verbosity=0, interactive=False) @@ -851,6 +1005,6 @@ class DiscoverRunnerExtraTestsDeprecationTests(SimpleTestCase): with captured_stderr(): with self.assertWarnsMessage(RemovedInDjango50Warning, self.msg): runner.run_tests( - test_labels=['test_runner_apps.sample.tests_sample.EmptyTestCase'], + test_labels=["test_runner_apps.sample.tests_sample.EmptyTestCase"], extra_tests=[], ) |