Refs #33476 -- Reformatted code with Black.

18 files changed, 274 insertions, 224 deletions

diff --git a/tests/user_commands/management/commands/common_args.py b/tests/user_commands/management/commands/common_args.py
index d7b288a267..ffc895b9fa 100644
--- a/tests/user_commands/management/commands/common_args.py
+++ b/tests/user_commands/management/commands/common_args.py
@@ -6,11 +6,11 @@ from django.core.management.base import BaseCommand, CommandError
 class Command(BaseCommand):
     def add_arguments(self, parser):
         try:
-            parser.add_argument('--version', action='version', version='A.B.C')
+            parser.add_argument("--version", action="version", version="A.B.C")
         except ArgumentError:
             pass
         else:
-            raise CommandError('--version argument does no yet exist')
+            raise CommandError("--version argument does no yet exist")
 
     def handle(self, *args, **options):
-        return 'Detected that --version already exists'
+        return "Detected that --version already exists"
diff --git a/tests/user_commands/management/commands/dance.py b/tests/user_commands/management/commands/dance.py
index efa1bc0d8a..2bb8c11309 100644
--- a/tests/user_commands/management/commands/dance.py
+++ b/tests/user_commands/management/commands/dance.py
@@ -3,21 +3,23 @@ from django.core.management.base import BaseCommand, CommandError
 
 class Command(BaseCommand):
     help = "Dance around like a madman."
-    args = ''
-    requires_system_checks = '__all__'
+    args = ""
+    requires_system_checks = "__all__"
 
     def add_arguments(self, parser):
-        parser.add_argument("integer", nargs='?', type=int, default=0)
+        parser.add_argument("integer", nargs="?", type=int, default=0)
         parser.add_argument("-s", "--style", default="Rock'n'Roll")
         parser.add_argument("-x", "--example")
-        parser.add_argument("--opt-3", action='store_true', dest='option3')
+        parser.add_argument("--opt-3", action="store_true", dest="option3")
 
     def handle(self, *args, **options):
         example = options["example"]
         if example == "raise":
             raise CommandError(returncode=3)
-        if options['verbosity'] > 0:
+        if options["verbosity"] > 0:
             self.stdout.write("I don't feel like dancing %s." % options["style"])
-            self.stdout.write(','.join(options))
-        if options['integer'] > 0:
-            self.stdout.write("You passed %d as a positional argument." % options['integer'])
+            self.stdout.write(",".join(options))
+        if options["integer"] > 0:
+            self.stdout.write(
+                "You passed %d as a positional argument." % options["integer"]
+            )
diff --git a/tests/user_commands/management/commands/hal.py b/tests/user_commands/management/commands/hal.py
index 5791e5fae0..6b9588b053 100644
--- a/tests/user_commands/management/commands/hal.py
+++ b/tests/user_commands/management/commands/hal.py
@@ -5,13 +5,18 @@ class Command(BaseCommand):
     help = "Useless command."
 
     def add_arguments(self, parser):
-        parser.add_argument('args', metavar='app_label', nargs='*', help='Specify the app label(s) to works on.')
-        parser.add_argument('--empty', action='store_true', help="Do nothing.")
+        parser.add_argument(
+            "args",
+            metavar="app_label",
+            nargs="*",
+            help="Specify the app label(s) to works on.",
+        )
+        parser.add_argument("--empty", action="store_true", help="Do nothing.")
 
     def handle(self, *app_labels, **options):
         app_labels = set(app_labels)
 
-        if options['empty']:
+        if options["empty"]:
             self.stdout.write()
             self.stdout.write("Dave, I can't do that.")
             return
@@ -21,7 +26,7 @@ class Command(BaseCommand):
 
         # raise an error if some --parameter is flowing from options to args
         for app_label in app_labels:
-            if app_label.startswith('--'):
+            if app_label.startswith("--"):
                 raise CommandError("Sorry, Dave, I can't let you do that.")
 
         self.stdout.write("Dave, my mind is going. I can feel it. I can feel it.")
diff --git a/tests/user_commands/management/commands/mutually_exclusive_required.py b/tests/user_commands/management/commands/mutually_exclusive_required.py
index 8e48f12658..421b3cbbdd 100644
--- a/tests/user_commands/management/commands/mutually_exclusive_required.py
+++ b/tests/user_commands/management/commands/mutually_exclusive_required.py
@@ -2,19 +2,18 @@ from django.core.management.base import BaseCommand
 
 
 class Command(BaseCommand):
-
     def add_arguments(self, parser):
         group = parser.add_mutually_exclusive_group(required=True)
-        group.add_argument('--foo-id', type=int, nargs='?', default=None)
-        group.add_argument('--foo-name', type=str, nargs='?', default=None)
-        group.add_argument('--foo-list', type=int, nargs='+')
-        group.add_argument('--append_const', action='append_const', const=42)
-        group.add_argument('--const', action='store_const', const=31)
-        group.add_argument('--count', action='count')
-        group.add_argument('--flag_false', action='store_false')
-        group.add_argument('--flag_true', action='store_true')
+        group.add_argument("--foo-id", type=int, nargs="?", default=None)
+        group.add_argument("--foo-name", type=str, nargs="?", default=None)
+        group.add_argument("--foo-list", type=int, nargs="+")
+        group.add_argument("--append_const", action="append_const", const=42)
+        group.add_argument("--const", action="store_const", const=31)
+        group.add_argument("--count", action="count")
+        group.add_argument("--flag_false", action="store_false")
+        group.add_argument("--flag_true", action="store_true")
 
     def handle(self, *args, **options):
         for option, value in options.items():
             if value is not None:
-                self.stdout.write('%s=%s' % (option, value))
+                self.stdout.write("%s=%s" % (option, value))
diff --git a/tests/user_commands/management/commands/mutually_exclusive_required_with_same_dest.py b/tests/user_commands/management/commands/mutually_exclusive_required_with_same_dest.py
index 1a9ab5576d..f6c9fc63a1 100644
--- a/tests/user_commands/management/commands/mutually_exclusive_required_with_same_dest.py
+++ b/tests/user_commands/management/commands/mutually_exclusive_required_with_same_dest.py
@@ -4,10 +4,10 @@ from django.core.management.base import BaseCommand
 class Command(BaseCommand):
     def add_arguments(self, parser):
         group = parser.add_mutually_exclusive_group(required=True)
-        group.add_argument('--for', dest='until', action='store')
-        group.add_argument('--until', action='store')
+        group.add_argument("--for", dest="until", action="store")
+        group.add_argument("--until", action="store")
 
     def handle(self, *args, **options):
         for option, value in options.items():
             if value is not None:
-                self.stdout.write('%s=%s' % (option, value))
+                self.stdout.write("%s=%s" % (option, value))
diff --git a/tests/user_commands/management/commands/no_translations.py b/tests/user_commands/management/commands/no_translations.py
index 2a8af6605b..fd1b6255f7 100644
--- a/tests/user_commands/management/commands/no_translations.py
+++ b/tests/user_commands/management/commands/no_translations.py
@@ -3,7 +3,6 @@ from django.utils import translation
 
 
 class Command(BaseCommand):
-
     @no_translations
     def handle(self, *args, **options):
         return translation.get_language()
diff --git a/tests/user_commands/management/commands/outputwrapper.py b/tests/user_commands/management/commands/outputwrapper.py
index bafc30d128..0bff3a49fb 100644
--- a/tests/user_commands/management/commands/outputwrapper.py
+++ b/tests/user_commands/management/commands/outputwrapper.py
@@ -3,6 +3,6 @@ from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
     def handle(self, **options):
-        self.stdout.write('Working...')
+        self.stdout.write("Working...")
         self.stdout.flush()
-        self.stdout.write('OK')
+        self.stdout.write("OK")
diff --git a/tests/user_commands/management/commands/required_constant_option.py b/tests/user_commands/management/commands/required_constant_option.py
index 121bfcc28c..5395aac236 100644
--- a/tests/user_commands/management/commands/required_constant_option.py
+++ b/tests/user_commands/management/commands/required_constant_option.py
@@ -4,17 +4,17 @@ from django.core.management.base import BaseCommand
 class Command(BaseCommand):
     def add_arguments(self, parser):
         parser.add_argument(
-            '--append_const',
-            action='append_const',
+            "--append_const",
+            action="append_const",
             const=42,
             required=True,
         )
-        parser.add_argument('--const', action='store_const', const=31, required=True)
-        parser.add_argument('--count', action='count', required=True)
-        parser.add_argument('--flag_false', action='store_false', required=True)
-        parser.add_argument('--flag_true', action='store_true', required=True)
+        parser.add_argument("--const", action="store_const", const=31, required=True)
+        parser.add_argument("--count", action="count", required=True)
+        parser.add_argument("--flag_false", action="store_false", required=True)
+        parser.add_argument("--flag_true", action="store_true", required=True)
 
     def handle(self, *args, **options):
         for option, value in options.items():
             if value is not None:
-                self.stdout.write('%s=%s' % (option, value))
+                self.stdout.write("%s=%s" % (option, value))
diff --git a/tests/user_commands/management/commands/required_list_option.py b/tests/user_commands/management/commands/required_list_option.py
index 84f39f0142..bbff9b53f6 100644
--- a/tests/user_commands/management/commands/required_list_option.py
+++ b/tests/user_commands/management/commands/required_list_option.py
@@ -3,8 +3,8 @@ from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
     def add_arguments(self, parser):
-        parser.add_argument('--foo-list', nargs='+', type=int, required=True)
+        parser.add_argument("--foo-list", nargs="+", type=int, required=True)
 
     def handle(self, *args, **options):
         for option, value in options.items():
-            self.stdout.write('%s=%s' % (option, value))
+            self.stdout.write("%s=%s" % (option, value))
diff --git a/tests/user_commands/management/commands/required_option.py b/tests/user_commands/management/commands/required_option.py
index 3b30ed942e..da84702189 100644
--- a/tests/user_commands/management/commands/required_option.py
+++ b/tests/user_commands/management/commands/required_option.py
@@ -2,10 +2,9 @@ from django.core.management.base import BaseCommand
 
 
 class Command(BaseCommand):
-
     def add_arguments(self, parser):
-        parser.add_argument('-n', '--need-me', required=True)
-        parser.add_argument('-t', '--need-me-too', required=True, dest='needme2')
+        parser.add_argument("-n", "--need-me", required=True)
+        parser.add_argument("-t", "--need-me-too", required=True, dest="needme2")
 
     def handle(self, *args, **options):
-        self.stdout.write(','.join(options))
+        self.stdout.write(",".join(options))
diff --git a/tests/user_commands/management/commands/reverse_url.py b/tests/user_commands/management/commands/reverse_url.py
index 2f88eda62e..b1fb5ad8ec 100644
--- a/tests/user_commands/management/commands/reverse_url.py
+++ b/tests/user_commands/management/commands/reverse_url.py
@@ -6,5 +6,6 @@ class Command(BaseCommand):
     """
     This command returns a URL from a reverse() call.
     """
+
     def handle(self, *args, **options):
-        return reverse('some_url')
+        return reverse("some_url")
diff --git a/tests/user_commands/management/commands/set_option.py b/tests/user_commands/management/commands/set_option.py
index a6e3c9bb6a..5f8c01e541 100644
--- a/tests/user_commands/management/commands/set_option.py
+++ b/tests/user_commands/management/commands/set_option.py
@@ -2,9 +2,8 @@ from django.core.management.base import BaseCommand
 
 
 class Command(BaseCommand):
-
     def add_arguments(self, parser):
-        parser.add_argument('--set')
+        parser.add_argument("--set")
 
     def handle(self, **options):
-        self.stdout.write('Set %s' % options['set'])
+        self.stdout.write("Set %s" % options["set"])
diff --git a/tests/user_commands/management/commands/subparser.py b/tests/user_commands/management/commands/subparser.py
index d3006bd3e8..908a9f2976 100644
--- a/tests/user_commands/management/commands/subparser.py
+++ b/tests/user_commands/management/commands/subparser.py
@@ -2,11 +2,10 @@ from django.core.management.base import BaseCommand
 
 
 class Command(BaseCommand):
-
     def add_arguments(self, parser):
         subparsers = parser.add_subparsers()
-        parser_foo = subparsers.add_parser('foo')
-        parser_foo.add_argument('bar', type=int)
+        parser_foo = subparsers.add_parser("foo")
+        parser_foo.add_argument("bar", type=int)
 
     def handle(self, *args, **options):
-        self.stdout.write(','.join(options))
+        self.stdout.write(",".join(options))
diff --git a/tests/user_commands/management/commands/subparser_dest.py b/tests/user_commands/management/commands/subparser_dest.py
index 000078911d..cc2ebb5272 100644
--- a/tests/user_commands/management/commands/subparser_dest.py
+++ b/tests/user_commands/management/commands/subparser_dest.py
@@ -3,9 +3,9 @@ from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
     def add_arguments(self, parser):
-        subparsers = parser.add_subparsers(dest='subcommand', required=True)
-        parser_foo = subparsers.add_parser('foo')
-        parser_foo.add_argument('--bar')
+        subparsers = parser.add_subparsers(dest="subcommand", required=True)
+        parser_foo = subparsers.add_parser("foo")
+        parser_foo.add_argument("--bar")
 
     def handle(self, *args, **options):
-        self.stdout.write(','.join(options))
+        self.stdout.write(",".join(options))
diff --git a/tests/user_commands/management/commands/subparser_required.py b/tests/user_commands/management/commands/subparser_required.py
index 995b0dce66..e9bff79752 100644
--- a/tests/user_commands/management/commands/subparser_required.py
+++ b/tests/user_commands/management/commands/subparser_required.py
@@ -3,11 +3,11 @@ from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
     def add_arguments(self, parser):
-        subparsers_1 = parser.add_subparsers(dest='subcommand_1')
-        parser_foo_1 = subparsers_1.add_parser('foo_1')
-        subparsers_2 = parser_foo_1.add_subparsers(dest='subcommand_2')
-        parser_foo_2 = subparsers_2.add_parser('foo_2')
-        parser_foo_2.add_argument('--bar', required=True)
+        subparsers_1 = parser.add_subparsers(dest="subcommand_1")
+        parser_foo_1 = subparsers_1.add_parser("foo_1")
+        subparsers_2 = parser_foo_1.add_subparsers(dest="subcommand_2")
+        parser_foo_2 = subparsers_2.add_parser("foo_2")
+        parser_foo_2.add_argument("--bar", required=True)
 
     def handle(self, *args, **options):
-        self.stdout.write(','.join(options))
+        self.stdout.write(",".join(options))
diff --git a/tests/user_commands/management/commands/transaction.py b/tests/user_commands/management/commands/transaction.py
index ca531b2b97..f8e28ff7ea 100644
--- a/tests/user_commands/management/commands/transaction.py
+++ b/tests/user_commands/management/commands/transaction.py
@@ -3,8 +3,8 @@ from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
     help = "Say hello."
-    args = ''
+    args = ""
     output_transaction = True
 
     def handle(self, *args, **options):
-        return 'Hello!'
+        return "Hello!"
diff --git a/tests/user_commands/tests.py b/tests/user_commands/tests.py
index 8da4e887d3..c128c52f69 100644
--- a/tests/user_commands/tests.py
+++ b/tests/user_commands/tests.py
@@ -9,8 +9,11 @@ from django.core import management
 from django.core.checks import Tags
 from django.core.management import BaseCommand, CommandError, find_commands
 from django.core.management.utils import (
-    find_command, get_random_secret_key, is_ignored_path,
-    normalize_path_patterns, popen_wrapper,
+    find_command,
+    get_random_secret_key,
+    is_ignored_path,
+    normalize_path_patterns,
+    popen_wrapper,
 )
 from django.db import connection
 from django.test import SimpleTestCase, override_settings
@@ -23,49 +26,51 @@ from .management.commands import dance
 # A minimal set of apps to avoid system checks running on all apps.
 @override_settings(
     INSTALLED_APPS=[
-        'django.contrib.auth',
-        'django.contrib.contenttypes',
-        'user_commands',
+        "django.contrib.auth",
+        "django.contrib.contenttypes",
+        "user_commands",
     ],
 )
 class CommandTests(SimpleTestCase):
     def test_command(self):
         out = StringIO()
-        management.call_command('dance', stdout=out)
+        management.call_command("dance", stdout=out)
         self.assertIn("I don't feel like dancing Rock'n'Roll.\n", out.getvalue())
 
     def test_command_style(self):
         out = StringIO()
-        management.call_command('dance', style='Jive', stdout=out)
+        management.call_command("dance", style="Jive", stdout=out)
         self.assertIn("I don't feel like dancing Jive.\n", out.getvalue())
         # Passing options as arguments also works (thanks argparse)
-        management.call_command('dance', '--style', 'Jive', stdout=out)
+        management.call_command("dance", "--style", "Jive", stdout=out)
         self.assertIn("I don't feel like dancing Jive.\n", out.getvalue())
 
     def test_language_preserved(self):
-        with translation.override('fr'):
-            management.call_command('dance', verbosity=0)
-            self.assertEqual(translation.get_language(), 'fr')
+        with translation.override("fr"):
+            management.call_command("dance", verbosity=0)
+            self.assertEqual(translation.get_language(), "fr")
 
     def test_explode(self):
-        """ An unknown command raises CommandError """
+        """An unknown command raises CommandError"""
         with self.assertRaisesMessage(CommandError, "Unknown command: 'explode'"):
-            management.call_command(('explode',))
+            management.call_command(("explode",))
 
     def test_system_exit(self):
-        """ Exception raised in a command should raise CommandError with
-            call_command, but SystemExit when run from command line
+        """Exception raised in a command should raise CommandError with
+        call_command, but SystemExit when run from command line
         """
         with self.assertRaises(CommandError) as cm:
-            management.call_command('dance', example="raise")
+            management.call_command("dance", example="raise")
         self.assertEqual(cm.exception.returncode, 3)
         dance.Command.requires_system_checks = []
         try:
             with captured_stderr() as stderr, self.assertRaises(SystemExit) as cm:
-                management.ManagementUtility(['manage.py', 'dance', '--example=raise']).execute()
+                management.ManagementUtility(
+                    ["manage.py", "dance", "--example=raise"]
+                ).execute()
             self.assertEqual(cm.exception.code, 3)
         finally:
-            dance.Command.requires_system_checks = '__all__'
+            dance.Command.requires_system_checks = "__all__"
         self.assertIn("CommandError", stderr.getvalue())
 
     def test_no_translations_deactivate_translations(self):
@@ -74,8 +79,8 @@ class CommandTests(SimpleTestCase):
         translations are deactivated inside the command.
         """
         current_locale = translation.get_language()
-        with translation.override('pl'):
-            result = management.call_command('no_translations')
+        with translation.override("pl"):
+            result = management.call_command("no_translations")
             self.assertIsNone(result)
         self.assertEqual(translation.get_language(), current_locale)
 
@@ -84,24 +89,26 @@ class CommandTests(SimpleTestCase):
         find_command should still work when the PATH environment variable
         doesn't exist (#22256).
         """
-        current_path = os.environ.pop('PATH', None)
+        current_path = os.environ.pop("PATH", None)
 
         try:
-            self.assertIsNone(find_command('_missing_'))
+            self.assertIsNone(find_command("_missing_"))
         finally:
             if current_path is not None:
-                os.environ['PATH'] = current_path
+                os.environ["PATH"] = current_path
 
     def test_discover_commands_in_eggs(self):
         """
         Management commands can also be loaded from Python eggs.
         """
-        egg_dir = '%s/eggs' % os.path.dirname(__file__)
-        egg_name = '%s/basic.egg' % egg_dir
+        egg_dir = "%s/eggs" % os.path.dirname(__file__)
+        egg_name = "%s/basic.egg" % egg_dir
         with extend_sys_path(egg_name):
-            with self.settings(INSTALLED_APPS=['commandegg']):
-                cmds = find_commands(os.path.join(apps.get_app_config('commandegg').path, 'management'))
-        self.assertEqual(cmds, ['eggcommand'])
+            with self.settings(INSTALLED_APPS=["commandegg"]):
+                cmds = find_commands(
+                    os.path.join(apps.get_app_config("commandegg").path, "management")
+                )
+        self.assertEqual(cmds, ["eggcommand"])
 
     def test_call_command_option_parsing(self):
         """
@@ -109,7 +116,7 @@ class CommandTests(SimpleTestCase):
         key is the option dest name (#22985).
         """
         out = StringIO()
-        management.call_command('dance', stdout=out, opt_3=True)
+        management.call_command("dance", stdout=out, opt_3=True)
         self.assertIn("option3", out.getvalue())
         self.assertNotIn("opt_3", out.getvalue())
         self.assertNotIn("opt-3", out.getvalue())
@@ -119,31 +126,43 @@ class CommandTests(SimpleTestCase):
         It should be possible to pass non-string arguments to call_command.
         """
         out = StringIO()
-        management.call_command('dance', 1, verbosity=0, stdout=out)
+        management.call_command("dance", 1, verbosity=0, stdout=out)
         self.assertIn("You passed 1 as a positional argument.", out.getvalue())
 
     def test_calling_a_command_with_only_empty_parameter_should_ends_gracefully(self):
         out = StringIO()
-        management.call_command('hal', "--empty", stdout=out)
+        management.call_command("hal", "--empty", stdout=out)
         self.assertEqual(out.getvalue(), "\nDave, I can't do that.\n")
 
     def test_calling_command_with_app_labels_and_parameters_should_be_ok(self):
         out = StringIO()
-        management.call_command('hal', 'myapp', "--verbosity", "3", stdout=out)
-        self.assertIn("Dave, my mind is going. I can feel it. I can feel it.\n", out.getvalue())
+        management.call_command("hal", "myapp", "--verbosity", "3", stdout=out)
+        self.assertIn(
+            "Dave, my mind is going. I can feel it. I can feel it.\n", out.getvalue()
+        )
 
-    def test_calling_command_with_parameters_and_app_labels_at_the_end_should_be_ok(self):
+    def test_calling_command_with_parameters_and_app_labels_at_the_end_should_be_ok(
+        self,
+    ):
         out = StringIO()
-        management.call_command('hal', "--verbosity", "3", "myapp", stdout=out)
-        self.assertIn("Dave, my mind is going. I can feel it. I can feel it.\n", out.getvalue())
+        management.call_command("hal", "--verbosity", "3", "myapp", stdout=out)
+        self.assertIn(
+            "Dave, my mind is going. I can feel it. I can feel it.\n", out.getvalue()
+        )
 
-    def test_calling_a_command_with_no_app_labels_and_parameters_should_raise_a_command_error(self):
+    def test_calling_a_command_with_no_app_labels_and_parameters_should_raise_a_command_error(
+        self,
+    ):
         with self.assertRaises(CommandError):
-            management.call_command('hal')
+            management.call_command("hal")
 
     def test_output_transaction(self):
-        output = management.call_command('transaction', stdout=StringIO(), no_color=True)
-        self.assertTrue(output.strip().startswith(connection.ops.start_transaction_sql()))
+        output = management.call_command(
+            "transaction", stdout=StringIO(), no_color=True
+        )
+        self.assertTrue(
+            output.strip().startswith(connection.ops.start_transaction_sql())
+        )
         self.assertTrue(output.strip().endswith(connection.ops.end_transaction_sql()))
 
     def test_call_command_no_checks(self):
@@ -169,20 +188,24 @@ class CommandTests(SimpleTestCase):
             BaseCommand.check = saved_check
 
     def test_requires_system_checks_empty(self):
-        with mock.patch('django.core.management.base.BaseCommand.check') as mocked_check:
-            management.call_command('no_system_checks')
+        with mock.patch(
+            "django.core.management.base.BaseCommand.check"
+        ) as mocked_check:
+            management.call_command("no_system_checks")
         self.assertIs(mocked_check.called, False)
 
     def test_requires_system_checks_specific(self):
-        with mock.patch('django.core.management.base.BaseCommand.check') as mocked_check:
-            management.call_command('specific_system_checks')
+        with mock.patch(
+            "django.core.management.base.BaseCommand.check"
+        ) as mocked_check:
+            management.call_command("specific_system_checks")
         mocked_check.called_once_with(tags=[Tags.staticfiles, Tags.models])
 
     def test_requires_system_checks_invalid(self):
         class Command(BaseCommand):
-            requires_system_checks = 'x'
+            requires_system_checks = "x"
 
-        msg = 'requires_system_checks must be a list or tuple.'
+        msg = "requires_system_checks must be a list or tuple."
         with self.assertRaisesMessage(TypeError, msg):
             Command()
 
@@ -190,94 +213,100 @@ class CommandTests(SimpleTestCase):
         requires_migrations_checks = dance.Command.requires_migrations_checks
         self.assertIs(requires_migrations_checks, False)
         try:
-            with mock.patch.object(BaseCommand, 'check_migrations') as check_migrations:
-                management.call_command('dance', verbosity=0)
+            with mock.patch.object(BaseCommand, "check_migrations") as check_migrations:
+                management.call_command("dance", verbosity=0)
                 self.assertFalse(check_migrations.called)
                 dance.Command.requires_migrations_checks = True
-                management.call_command('dance', verbosity=0)
+                management.call_command("dance", verbosity=0)
                 self.assertTrue(check_migrations.called)
         finally:
             dance.Command.requires_migrations_checks = requires_migrations_checks
 
     def test_call_command_unrecognized_option(self):
         msg = (
-            'Unknown option(s) for dance command: unrecognized. Valid options '
-            'are: example, force_color, help, integer, no_color, opt_3, '
-            'option3, pythonpath, settings, skip_checks, stderr, stdout, '
-            'style, traceback, verbosity, version.'
+            "Unknown option(s) for dance command: unrecognized. Valid options "
+            "are: example, force_color, help, integer, no_color, opt_3, "
+            "option3, pythonpath, settings, skip_checks, stderr, stdout, "
+            "style, traceback, verbosity, version."
         )
         with self.assertRaisesMessage(TypeError, msg):
-            management.call_command('dance', unrecognized=1)
+            management.call_command("dance", unrecognized=1)
 
         msg = (
-            'Unknown option(s) for dance command: unrecognized, unrecognized2. '
-            'Valid options are: example, force_color, help, integer, no_color, '
-            'opt_3, option3, pythonpath, settings, skip_checks, stderr, '
-            'stdout, style, traceback, verbosity, version.'
+            "Unknown option(s) for dance command: unrecognized, unrecognized2. "
+            "Valid options are: example, force_color, help, integer, no_color, "
+            "opt_3, option3, pythonpath, settings, skip_checks, stderr, "
+            "stdout, style, traceback, verbosity, version."
         )
         with self.assertRaisesMessage(TypeError, msg):
-            management.call_command('dance', unrecognized=1, unrecognized2=1)
+            management.call_command("dance", unrecognized=1, unrecognized2=1)
 
     def test_call_command_with_required_parameters_in_options(self):
         out = StringIO()
-        management.call_command('required_option', need_me='foo', needme2='bar', stdout=out)
-        self.assertIn('need_me', out.getvalue())
-        self.assertIn('needme2', out.getvalue())
+        management.call_command(
+            "required_option", need_me="foo", needme2="bar", stdout=out
+        )
+        self.assertIn("need_me", out.getvalue())
+        self.assertIn("needme2", out.getvalue())
 
     def test_call_command_with_required_parameters_in_mixed_options(self):
         out = StringIO()
-        management.call_command('required_option', '--need-me=foo', needme2='bar', stdout=out)
-        self.assertIn('need_me', out.getvalue())
-        self.assertIn('needme2', out.getvalue())
+        management.call_command(
+            "required_option", "--need-me=foo", needme2="bar", stdout=out
+        )
+        self.assertIn("need_me", out.getvalue())
+        self.assertIn("needme2", out.getvalue())
 
     def test_command_add_arguments_after_common_arguments(self):
         out = StringIO()
-        management.call_command('common_args', stdout=out)
-        self.assertIn('Detected that --version already exists', out.getvalue())
+        management.call_command("common_args", stdout=out)
+        self.assertIn("Detected that --version already exists", out.getvalue())
 
     def test_mutually_exclusive_group_required_options(self):
         out = StringIO()
-        management.call_command('mutually_exclusive_required', foo_id=1, stdout=out)
-        self.assertIn('foo_id', out.getvalue())
-        management.call_command('mutually_exclusive_required', foo_name='foo', stdout=out)
-        self.assertIn('foo_name', out.getvalue())
+        management.call_command("mutually_exclusive_required", foo_id=1, stdout=out)
+        self.assertIn("foo_id", out.getvalue())
+        management.call_command(
+            "mutually_exclusive_required", foo_name="foo", stdout=out
+        )
+        self.assertIn("foo_name", out.getvalue())
         msg = (
-            'Error: one of the arguments --foo-id --foo-name --foo-list '
-            '--append_const --const --count --flag_false --flag_true is '
-            'required'
+            "Error: one of the arguments --foo-id --foo-name --foo-list "
+            "--append_const --const --count --flag_false --flag_true is "
+            "required"
         )
         with self.assertRaisesMessage(CommandError, msg):
-            management.call_command('mutually_exclusive_required', stdout=out)
+            management.call_command("mutually_exclusive_required", stdout=out)
 
     def test_mutually_exclusive_group_required_const_options(self):
         tests = [
-            ('append_const', [42]),
-            ('const', 31),
-            ('count', 1),
-            ('flag_false', False),
-            ('flag_true', True),
+            ("append_const", [42]),
+            ("const", 31),
+            ("count", 1),
+            ("flag_false", False),
+            ("flag_true", True),
         ]
         for arg, value in tests:
             out = StringIO()
-            expected_output = '%s=%s' % (arg, value)
+            expected_output = "%s=%s" % (arg, value)
             with self.subTest(arg=arg):
                 management.call_command(
-                    'mutually_exclusive_required',
-                    '--%s' % arg,
+                    "mutually_exclusive_required",
+                    "--%s" % arg,
                     stdout=out,
                 )
                 self.assertIn(expected_output, out.getvalue())
                 out.truncate(0)
                 management.call_command(
-                    'mutually_exclusive_required',
-                    **{arg: value, 'stdout': out},
+                    "mutually_exclusive_required",
+                    **{arg: value, "stdout": out},
                 )
                 self.assertIn(expected_output, out.getvalue())
 
     def test_mutually_exclusive_group_required_with_same_dest_options(self):
         tests = [
-            {'until': '2'},
-            {'for': '1', 'until': '2'},
+            {"until": "2"},
+            {"for": "1", "until": "2"},
         ]
         msg = (
             "Cannot pass the dest 'until' that matches multiple arguments via "
@@ -287,104 +316,106 @@ class CommandTests(SimpleTestCase):
             with self.subTest(options=options):
                 with self.assertRaisesMessage(TypeError, msg):
                     management.call_command(
-                        'mutually_exclusive_required_with_same_dest',
+                        "mutually_exclusive_required_with_same_dest",
                         **options,
                     )
 
     def test_mutually_exclusive_group_required_with_same_dest_args(self):
         tests = [
-            ('--until=1',),
-            ('--until', 1),
-            ('--for=1',),
-            ('--for', 1),
+            ("--until=1",),
+            ("--until", 1),
+            ("--for=1",),
+            ("--for", 1),
         ]
         for args in tests:
             out = StringIO()
             with self.subTest(options=args):
                 management.call_command(
-                    'mutually_exclusive_required_with_same_dest',
+                    "mutually_exclusive_required_with_same_dest",
                     *args,
                     stdout=out,
                 )
                 output = out.getvalue()
-                self.assertIn('until=1', output)
+                self.assertIn("until=1", output)
 
     def test_required_list_option(self):
         tests = [
-            (('--foo-list', [1, 2]), {}),
-            ((), {'foo_list': [1, 2]}),
+            (("--foo-list", [1, 2]), {}),
+            ((), {"foo_list": [1, 2]}),
         ]
-        for command in ['mutually_exclusive_required', 'required_list_option']:
+        for command in ["mutually_exclusive_required", "required_list_option"]:
             for args, kwargs in tests:
                 with self.subTest(command=command, args=args, kwargs=kwargs):
                     out = StringIO()
                     management.call_command(
                         command,
                         *args,
-                        **{**kwargs, 'stdout': out},
+                        **{**kwargs, "stdout": out},
                     )
-                    self.assertIn('foo_list=[1, 2]', out.getvalue())
+                    self.assertIn("foo_list=[1, 2]", out.getvalue())
 
     def test_required_const_options(self):
         args = {
-            'append_const': [42],
-            'const': 31,
-            'count': 1,
-            'flag_false': False,
-            'flag_true': True,
+            "append_const": [42],
+            "const": 31,
+            "count": 1,
+            "flag_false": False,
+            "flag_true": True,
         }
-        expected_output = '\n'.join(
-            '%s=%s' % (arg, value) for arg, value in args.items()
+        expected_output = "\n".join(
+            "%s=%s" % (arg, value) for arg, value in args.items()
         )
         out = StringIO()
         management.call_command(
-            'required_constant_option',
-            '--append_const',
-            '--const',
-            '--count',
-            '--flag_false',
-            '--flag_true',
+            "required_constant_option",
+            "--append_const",
+            "--const",
+            "--count",
+            "--flag_false",
+            "--flag_true",
             stdout=out,
         )
         self.assertIn(expected_output, out.getvalue())
         out.truncate(0)
-        management.call_command('required_constant_option', **{**args, 'stdout': out})
+        management.call_command("required_constant_option", **{**args, "stdout": out})
         self.assertIn(expected_output, out.getvalue())
 
     def test_subparser(self):
         out = StringIO()
-        management.call_command('subparser', 'foo', 12, stdout=out)
-        self.assertIn('bar', out.getvalue())
+        management.call_command("subparser", "foo", 12, stdout=out)
+        self.assertIn("bar", out.getvalue())
 
     def test_subparser_dest_args(self):
         out = StringIO()
-        management.call_command('subparser_dest', 'foo', bar=12, stdout=out)
-        self.assertIn('bar', out.getvalue())
+        management.call_command("subparser_dest", "foo", bar=12, stdout=out)
+        self.assertIn("bar", out.getvalue())
 
     def test_subparser_dest_required_args(self):
         out = StringIO()
-        management.call_command('subparser_required', 'foo_1', 'foo_2', bar=12, stdout=out)
-        self.assertIn('bar', out.getvalue())
+        management.call_command(
+            "subparser_required", "foo_1", "foo_2", bar=12, stdout=out
+        )
+        self.assertIn("bar", out.getvalue())
 
     def test_subparser_invalid_option(self):
         msg = "invalid choice: 'test' (choose from 'foo')"
         with self.assertRaisesMessage(CommandError, msg):
-            management.call_command('subparser', 'test', 12)
-        msg = 'Error: the following arguments are required: subcommand'
+            management.call_command("subparser", "test", 12)
+        msg = "Error: the following arguments are required: subcommand"
         with self.assertRaisesMessage(CommandError, msg):
-            management.call_command('subparser_dest', subcommand='foo', bar=12)
+            management.call_command("subparser_dest", subcommand="foo", bar=12)
 
     def test_create_parser_kwargs(self):
         """BaseCommand.create_parser() passes kwargs to CommandParser."""
-        epilog = 'some epilog text'
-        parser = BaseCommand().create_parser('prog_name', 'subcommand', epilog=epilog)
+        epilog = "some epilog text"
+        parser = BaseCommand().create_parser("prog_name", "subcommand", epilog=epilog)
         self.assertEqual(parser.epilog, epilog)
 
     def test_outputwrapper_flush(self):
         out = StringIO()
-        with mock.patch.object(out, 'flush') as mocked_flush:
-            management.call_command('outputwrapper', stdout=out)
-        self.assertIn('Working...', out.getvalue())
+        with mock.patch.object(out, "flush") as mocked_flush:
+            management.call_command("outputwrapper", stdout=out)
+        self.assertIn("Working...", out.getvalue())
         self.assertIs(mocked_flush.called, True)
 
 
@@ -392,67 +423,83 @@ class CommandRunTests(AdminScriptTestCase):
     """
     Tests that need to run by simulating the command line, not by call_command.
     """
+
     def test_script_prefix_set_in_commands(self):
-        self.write_settings('settings.py', apps=['user_commands'], sdict={
-            'ROOT_URLCONF': '"user_commands.urls"',
-            'FORCE_SCRIPT_NAME': '"/PREFIX/"',
-        })
-        out, err = self.run_manage(['reverse_url'])
+        self.write_settings(
+            "settings.py",
+            apps=["user_commands"],
+            sdict={
+                "ROOT_URLCONF": '"user_commands.urls"',
+                "FORCE_SCRIPT_NAME": '"/PREFIX/"',
+            },
+        )
+        out, err = self.run_manage(["reverse_url"])
         self.assertNoOutput(err)
-        self.assertEqual(out.strip(), '/PREFIX/some/url/')
+        self.assertEqual(out.strip(), "/PREFIX/some/url/")
 
     def test_disallowed_abbreviated_options(self):
         """
         To avoid conflicts with custom options, commands don't allow
         abbreviated forms of the --setting and --pythonpath options.
         """
-        self.write_settings('settings.py', apps=['user_commands'])
-        out, err = self.run_manage(['set_option', '--set', 'foo'])
+        self.write_settings("settings.py", apps=["user_commands"])
+        out, err = self.run_manage(["set_option", "--set", "foo"])
         self.assertNoOutput(err)
-        self.assertEqual(out.strip(), 'Set foo')
+        self.assertEqual(out.strip(), "Set foo")
 
     def test_skip_checks(self):
-        self.write_settings('settings.py', apps=['django.contrib.staticfiles', 'user_commands'], sdict={
-            # (staticfiles.E001) The STATICFILES_DIRS setting is not a tuple or
-            # list.
-            'STATICFILES_DIRS': '"foo"',
-        })
-        out, err = self.run_manage(['set_option', '--skip-checks', '--set', 'foo'])
+        self.write_settings(
+            "settings.py",
+            apps=["django.contrib.staticfiles", "user_commands"],
+            sdict={
+                # (staticfiles.E001) The STATICFILES_DIRS setting is not a tuple or
+                # list.
+                "STATICFILES_DIRS": '"foo"',
+            },
+        )
+        out, err = self.run_manage(["set_option", "--skip-checks", "--set", "foo"])
         self.assertNoOutput(err)
-        self.assertEqual(out.strip(), 'Set foo')
+        self.assertEqual(out.strip(), "Set foo")
 
 
 class UtilsTests(SimpleTestCase):
-
     def test_no_existent_external_program(self):
-        msg = 'Error executing a_42_command_that_doesnt_exist_42'
+        msg = "Error executing a_42_command_that_doesnt_exist_42"
         with self.assertRaisesMessage(CommandError, msg):
-            popen_wrapper(['a_42_command_that_doesnt_exist_42'])
+            popen_wrapper(["a_42_command_that_doesnt_exist_42"])
 
     def test_get_random_secret_key(self):
         key = get_random_secret_key()
         self.assertEqual(len(key), 50)
         for char in key:
-            self.assertIn(char, 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)')
+            self.assertIn(char, "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)")
 
     def test_is_ignored_path_true(self):
         patterns = (
-            ['foo/bar/baz'],
-            ['baz'],
-            ['foo/bar/baz'],
-            ['*/baz'],
-            ['*'],
-            ['b?z'],
-            ['[abc]az'],
-            ['*/ba[!z]/baz'],
+            ["foo/bar/baz"],
+            ["baz"],
+            ["foo/bar/baz"],
+            ["*/baz"],
+            ["*"],
+            ["b?z"],
+            ["[abc]az"],
+            ["*/ba[!z]/baz"],
         )
         for ignore_patterns in patterns:
             with self.subTest(ignore_patterns=ignore_patterns):
-                self.assertIs(is_ignored_path('foo/bar/baz', ignore_patterns=ignore_patterns), True)
+                self.assertIs(
+                    is_ignored_path("foo/bar/baz", ignore_patterns=ignore_patterns),
+                    True,
+                )
 
     def test_is_ignored_path_false(self):
-        self.assertIs(is_ignored_path('foo/bar/baz', ignore_patterns=['foo/bar/bat', 'bar', 'flub/blub']), False)
+        self.assertIs(
+            is_ignored_path(
+                "foo/bar/baz", ignore_patterns=["foo/bar/bat", "bar", "flub/blub"]
+            ),
+            False,
+        )
 
     def test_normalize_path_patterns_truncates_wildcard_base(self):
-        expected = [os.path.normcase(p) for p in ['foo/bar', 'bar/*/']]
-        self.assertEqual(normalize_path_patterns(['foo/bar/*', 'bar/*/']), expected)
+        expected = [os.path.normcase(p) for p in ["foo/bar", "bar/*/"]]
+        self.assertEqual(normalize_path_patterns(["foo/bar/*", "bar/*/"]), expected)
diff --git a/tests/user_commands/urls.py b/tests/user_commands/urls.py
index 50d7d96d51..6e82c7dcb3 100644
--- a/tests/user_commands/urls.py
+++ b/tests/user_commands/urls.py
@@ -1,5 +1,5 @@
 from django.urls import path
 
 urlpatterns = [
-    path('some/url/', lambda req:req, name='some_url'),
+    path("some/url/", lambda req: req, name="some_url"),
 ]