Refs #33476 -- Reformatted code with Black.

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)