Refs #33476 -- Reformatted code with Black.

5 files changed, 259 insertions, 224 deletions

diff --git a/tests/dbshell/test_mysql.py b/tests/dbshell/test_mysql.py
index b1e8e8a5c9..28410b05e1 100644
--- a/tests/dbshell/test_mysql.py
+++ b/tests/dbshell/test_mysql.py
@@ -19,153 +19,165 @@ class MySqlDbshellCommandTestCase(SimpleTestCase):
 
     def test_basic_params_specified_in_settings(self):
         expected_args = [
-            'mysql',
-            '--user=someuser',
-            '--host=somehost',
-            '--port=444',
-            'somedbname',
+            "mysql",
+            "--user=someuser",
+            "--host=somehost",
+            "--port=444",
+            "somedbname",
         ]
-        expected_env = {'MYSQL_PWD': 'somepassword'}
+        expected_env = {"MYSQL_PWD": "somepassword"}
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'somedbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': 'somehost',
-                'PORT': 444,
-                'OPTIONS': {},
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "somedbname",
+                    "USER": "someuser",
+                    "PASSWORD": "somepassword",
+                    "HOST": "somehost",
+                    "PORT": 444,
+                    "OPTIONS": {},
+                }
+            ),
             (expected_args, expected_env),
         )
 
     def test_options_override_settings_proper_values(self):
         settings_port = 444
         options_port = 555
-        self.assertNotEqual(settings_port, options_port, 'test pre-req')
+        self.assertNotEqual(settings_port, options_port, "test pre-req")
         expected_args = [
-            'mysql',
-            '--user=optionuser',
-            '--host=optionhost',
-            '--port=%s' % options_port,
-            'optiondbname',
+            "mysql",
+            "--user=optionuser",
+            "--host=optionhost",
+            "--port=%s" % options_port,
+            "optiondbname",
         ]
-        expected_env = {'MYSQL_PWD': 'optionpassword'}
-        for keys in [('database', 'password'), ('db', 'passwd')]:
+        expected_env = {"MYSQL_PWD": "optionpassword"}
+        for keys in [("database", "password"), ("db", "passwd")]:
             with self.subTest(keys=keys):
                 database, password = keys
                 self.assertEqual(
-                    self.settings_to_cmd_args_env({
-                        'NAME': 'settingdbname',
-                        'USER': 'settinguser',
-                        'PASSWORD': 'settingpassword',
-                        'HOST': 'settinghost',
-                        'PORT': settings_port,
-                        'OPTIONS': {
-                            database: 'optiondbname',
-                            'user': 'optionuser',
-                            password: 'optionpassword',
-                            'host': 'optionhost',
-                            'port': options_port,
-                        },
-                    }),
+                    self.settings_to_cmd_args_env(
+                        {
+                            "NAME": "settingdbname",
+                            "USER": "settinguser",
+                            "PASSWORD": "settingpassword",
+                            "HOST": "settinghost",
+                            "PORT": settings_port,
+                            "OPTIONS": {
+                                database: "optiondbname",
+                                "user": "optionuser",
+                                password: "optionpassword",
+                                "host": "optionhost",
+                                "port": options_port,
+                            },
+                        }
+                    ),
                     (expected_args, expected_env),
                 )
 
     def test_options_non_deprecated_keys_preferred(self):
         expected_args = [
-            'mysql',
-            '--user=someuser',
-            '--host=somehost',
-            '--port=444',
-            'optiondbname',
+            "mysql",
+            "--user=someuser",
+            "--host=somehost",
+            "--port=444",
+            "optiondbname",
         ]
-        expected_env = {'MYSQL_PWD': 'optionpassword'}
+        expected_env = {"MYSQL_PWD": "optionpassword"}
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'settingdbname',
-                'USER': 'someuser',
-                'PASSWORD': 'settingpassword',
-                'HOST': 'somehost',
-                'PORT': 444,
-                'OPTIONS': {
-                    'database': 'optiondbname',
-                    'db': 'deprecatedoptiondbname',
-                    'password': 'optionpassword',
-                    'passwd': 'deprecatedoptionpassword',
-                },
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "settingdbname",
+                    "USER": "someuser",
+                    "PASSWORD": "settingpassword",
+                    "HOST": "somehost",
+                    "PORT": 444,
+                    "OPTIONS": {
+                        "database": "optiondbname",
+                        "db": "deprecatedoptiondbname",
+                        "password": "optionpassword",
+                        "passwd": "deprecatedoptionpassword",
+                    },
+                }
+            ),
             (expected_args, expected_env),
         )
 
     def test_options_charset(self):
         expected_args = [
-            'mysql',
-            '--user=someuser',
-            '--host=somehost',
-            '--port=444',
-            '--default-character-set=utf8',
-            'somedbname',
+            "mysql",
+            "--user=someuser",
+            "--host=somehost",
+            "--port=444",
+            "--default-character-set=utf8",
+            "somedbname",
         ]
-        expected_env = {'MYSQL_PWD': 'somepassword'}
+        expected_env = {"MYSQL_PWD": "somepassword"}
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'somedbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': 'somehost',
-                'PORT': 444,
-                'OPTIONS': {'charset': 'utf8'},
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "somedbname",
+                    "USER": "someuser",
+                    "PASSWORD": "somepassword",
+                    "HOST": "somehost",
+                    "PORT": 444,
+                    "OPTIONS": {"charset": "utf8"},
+                }
+            ),
             (expected_args, expected_env),
         )
 
     def test_can_connect_using_sockets(self):
         expected_args = [
-            'mysql',
-            '--user=someuser',
-            '--socket=/path/to/mysql.socket.file',
-            'somedbname',
+            "mysql",
+            "--user=someuser",
+            "--socket=/path/to/mysql.socket.file",
+            "somedbname",
         ]
-        expected_env = {'MYSQL_PWD': 'somepassword'}
+        expected_env = {"MYSQL_PWD": "somepassword"}
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'somedbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': '/path/to/mysql.socket.file',
-                'PORT': None,
-                'OPTIONS': {},
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "somedbname",
+                    "USER": "someuser",
+                    "PASSWORD": "somepassword",
+                    "HOST": "/path/to/mysql.socket.file",
+                    "PORT": None,
+                    "OPTIONS": {},
+                }
+            ),
             (expected_args, expected_env),
         )
 
     def test_ssl_certificate_is_added(self):
         expected_args = [
-            'mysql',
-            '--user=someuser',
-            '--host=somehost',
-            '--port=444',
-            '--ssl-ca=sslca',
-            '--ssl-cert=sslcert',
-            '--ssl-key=sslkey',
-            'somedbname',
+            "mysql",
+            "--user=someuser",
+            "--host=somehost",
+            "--port=444",
+            "--ssl-ca=sslca",
+            "--ssl-cert=sslcert",
+            "--ssl-key=sslkey",
+            "somedbname",
         ]
-        expected_env = {'MYSQL_PWD': 'somepassword'}
+        expected_env = {"MYSQL_PWD": "somepassword"}
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'somedbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': 'somehost',
-                'PORT': 444,
-                'OPTIONS': {
-                    'ssl': {
-                        'ca': 'sslca',
-                        'cert': 'sslcert',
-                        'key': 'sslkey',
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "somedbname",
+                    "USER": "someuser",
+                    "PASSWORD": "somepassword",
+                    "HOST": "somehost",
+                    "PORT": 444,
+                    "OPTIONS": {
+                        "ssl": {
+                            "ca": "sslca",
+                            "cert": "sslcert",
+                            "key": "sslkey",
+                        },
                     },
-                },
-            }),
+                }
+            ),
             (expected_args, expected_env),
         )
 
@@ -173,16 +185,16 @@ class MySqlDbshellCommandTestCase(SimpleTestCase):
         self.assertEqual(
             self.settings_to_cmd_args_env(
                 {
-                    'NAME': 'somedbname',
-                    'USER': None,
-                    'PASSWORD': None,
-                    'HOST': None,
-                    'PORT': None,
-                    'OPTIONS': {},
+                    "NAME": "somedbname",
+                    "USER": None,
+                    "PASSWORD": None,
+                    "HOST": None,
+                    "PORT": None,
+                    "OPTIONS": {},
                 },
-                ['--help'],
+                ["--help"],
             ),
-            (['mysql', 'somedbname', '--help'], None),
+            (["mysql", "somedbname", "--help"], None),
         )
 
     def test_crash_password_does_not_leak(self):
@@ -190,19 +202,19 @@ class MySqlDbshellCommandTestCase(SimpleTestCase):
         # crash.
         args, env = DatabaseClient.settings_to_cmd_args_env(
             {
-                'NAME': 'somedbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': 'somehost',
-                'PORT': 444,
-                'OPTIONS': {},
+                "NAME": "somedbname",
+                "USER": "someuser",
+                "PASSWORD": "somepassword",
+                "HOST": "somehost",
+                "PORT": 444,
+                "OPTIONS": {},
             },
             [],
         )
         if env:
             env = {**os.environ, **env}
-        fake_client = Path(__file__).with_name('fake_client.py')
+        fake_client = Path(__file__).with_name("fake_client.py")
         args[0:1] = [sys.executable, str(fake_client)]
         with self.assertRaises(subprocess.CalledProcessError) as ctx:
             subprocess.run(args, check=True, env=env)
-        self.assertNotIn('somepassword', str(ctx.exception))
+        self.assertNotIn("somepassword", str(ctx.exception))
diff --git a/tests/dbshell/test_oracle.py b/tests/dbshell/test_oracle.py
index 34e96fb09b..b9a4592ad5 100644
--- a/tests/dbshell/test_oracle.py
+++ b/tests/dbshell/test_oracle.py
@@ -5,18 +5,20 @@ from django.db.backends.oracle.client import DatabaseClient
 from django.test import SimpleTestCase
 
 
-@skipUnless(connection.vendor == 'oracle', 'Requires cx_Oracle to be installed')
+@skipUnless(connection.vendor == "oracle", "Requires cx_Oracle to be installed")
 class OracleDbshellTests(SimpleTestCase):
     def settings_to_cmd_args_env(self, settings_dict, parameters=None, rlwrap=False):
         if parameters is None:
             parameters = []
-        with mock.patch('shutil.which', return_value='/usr/bin/rlwrap' if rlwrap else None):
+        with mock.patch(
+            "shutil.which", return_value="/usr/bin/rlwrap" if rlwrap else None
+        ):
             return DatabaseClient.settings_to_cmd_args_env(settings_dict, parameters)
 
     def test_without_rlwrap(self):
         expected_args = [
-            'sqlplus',
-            '-L',
+            "sqlplus",
+            "-L",
             connection.client.connect_string(connection.settings_dict),
         ]
         self.assertEqual(
@@ -26,9 +28,9 @@ class OracleDbshellTests(SimpleTestCase):
 
     def test_with_rlwrap(self):
         expected_args = [
-            '/usr/bin/rlwrap',
-            'sqlplus',
-            '-L',
+            "/usr/bin/rlwrap",
+            "sqlplus",
+            "-L",
             connection.client.connect_string(connection.settings_dict),
         ]
         self.assertEqual(
@@ -38,15 +40,15 @@ class OracleDbshellTests(SimpleTestCase):
 
     def test_parameters(self):
         expected_args = [
-            'sqlplus',
-            '-L',
+            "sqlplus",
+            "-L",
             connection.client.connect_string(connection.settings_dict),
-            '-HELP',
+            "-HELP",
         ]
         self.assertEqual(
             self.settings_to_cmd_args_env(
                 connection.settings_dict,
-                parameters=['-HELP'],
+                parameters=["-HELP"],
             ),
             (expected_args, None),
         )
diff --git a/tests/dbshell/test_postgresql.py b/tests/dbshell/test_postgresql.py
index 6aaf6c8f77..02924d0bcc 100644
--- a/tests/dbshell/test_postgresql.py
+++ b/tests/dbshell/test_postgresql.py
@@ -18,128 +18,149 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
 
     def test_basic(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': 'someuser',
-                'PASSWORD': 'somepassword',
-                'HOST': 'somehost',
-                'PORT': '444',
-            }), (
-                ['psql', '-U', 'someuser', '-h', 'somehost', '-p', '444', 'dbname'],
-                {'PGPASSWORD': 'somepassword'},
-            )
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "dbname",
+                    "USER": "someuser",
+                    "PASSWORD": "somepassword",
+                    "HOST": "somehost",
+                    "PORT": "444",
+                }
+            ),
+            (
+                ["psql", "-U", "someuser", "-h", "somehost", "-p", "444", "dbname"],
+                {"PGPASSWORD": "somepassword"},
+            ),
         )
 
     def test_nopass(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': 'someuser',
-                'HOST': 'somehost',
-                'PORT': '444',
-            }), (
-                ['psql', '-U', 'someuser', '-h', 'somehost', '-p', '444', 'dbname'],
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "dbname",
+                    "USER": "someuser",
+                    "HOST": "somehost",
+                    "PORT": "444",
+                }
+            ),
+            (
+                ["psql", "-U", "someuser", "-h", "somehost", "-p", "444", "dbname"],
                 None,
-            )
+            ),
         )
 
     def test_ssl_certificate(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': 'someuser',
-                'HOST': 'somehost',
-                'PORT': '444',
-                'OPTIONS': {
-                    'sslmode': 'verify-ca',
-                    'sslrootcert': 'root.crt',
-                    'sslcert': 'client.crt',
-                    'sslkey': 'client.key',
-                },
-            }), (
-                ['psql', '-U', 'someuser', '-h', 'somehost', '-p', '444', 'dbname'],
+            self.settings_to_cmd_args_env(
                 {
-                    'PGSSLCERT': 'client.crt',
-                    'PGSSLKEY': 'client.key',
-                    'PGSSLMODE': 'verify-ca',
-                    'PGSSLROOTCERT': 'root.crt',
+                    "NAME": "dbname",
+                    "USER": "someuser",
+                    "HOST": "somehost",
+                    "PORT": "444",
+                    "OPTIONS": {
+                        "sslmode": "verify-ca",
+                        "sslrootcert": "root.crt",
+                        "sslcert": "client.crt",
+                        "sslkey": "client.key",
+                    },
+                }
+            ),
+            (
+                ["psql", "-U", "someuser", "-h", "somehost", "-p", "444", "dbname"],
+                {
+                    "PGSSLCERT": "client.crt",
+                    "PGSSLKEY": "client.key",
+                    "PGSSLMODE": "verify-ca",
+                    "PGSSLROOTCERT": "root.crt",
                 },
-            )
+            ),
         )
 
     def test_service(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({'OPTIONS': {'service': 'django_test'}}),
-            (['psql'], {'PGSERVICE': 'django_test'}),
+            self.settings_to_cmd_args_env({"OPTIONS": {"service": "django_test"}}),
+            (["psql"], {"PGSERVICE": "django_test"}),
         )
 
     def test_passfile(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': 'someuser',
-                'HOST': 'somehost',
-                'PORT': '444',
-                'OPTIONS': {
-                    'passfile': '~/.custompgpass',
-                },
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "dbname",
+                    "USER": "someuser",
+                    "HOST": "somehost",
+                    "PORT": "444",
+                    "OPTIONS": {
+                        "passfile": "~/.custompgpass",
+                    },
+                }
+            ),
             (
-                ['psql', '-U', 'someuser', '-h', 'somehost', '-p', '444', 'dbname'],
-                {'PGPASSFILE': '~/.custompgpass'},
+                ["psql", "-U", "someuser", "-h", "somehost", "-p", "444", "dbname"],
+                {"PGPASSFILE": "~/.custompgpass"},
             ),
         )
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'OPTIONS': {
-                    'service': 'django_test',
-                    'passfile': '~/.custompgpass',
-                },
-            }),
+            self.settings_to_cmd_args_env(
+                {
+                    "OPTIONS": {
+                        "service": "django_test",
+                        "passfile": "~/.custompgpass",
+                    },
+                }
+            ),
             (
-                ['psql'], {'PGSERVICE': 'django_test', 'PGPASSFILE': '~/.custompgpass'},
+                ["psql"],
+                {"PGSERVICE": "django_test", "PGPASSFILE": "~/.custompgpass"},
             ),
         )
 
     def test_column(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': 'some:user',
-                'PASSWORD': 'some:password',
-                'HOST': '::1',
-                'PORT': '444',
-            }), (
-                ['psql', '-U', 'some:user', '-h', '::1', '-p', '444', 'dbname'],
-                {'PGPASSWORD': 'some:password'},
-            )
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "dbname",
+                    "USER": "some:user",
+                    "PASSWORD": "some:password",
+                    "HOST": "::1",
+                    "PORT": "444",
+                }
+            ),
+            (
+                ["psql", "-U", "some:user", "-h", "::1", "-p", "444", "dbname"],
+                {"PGPASSWORD": "some:password"},
+            ),
         )
 
     def test_accent(self):
-        username = 'rôle'
-        password = 'sésame'
+        username = "rôle"
+        password = "sésame"
         self.assertEqual(
-            self.settings_to_cmd_args_env({
-                'NAME': 'dbname',
-                'USER': username,
-                'PASSWORD': password,
-                'HOST': 'somehost',
-                'PORT': '444',
-            }), (
-                ['psql', '-U', username, '-h', 'somehost', '-p', '444', 'dbname'],
-                {'PGPASSWORD': password},
-            )
+            self.settings_to_cmd_args_env(
+                {
+                    "NAME": "dbname",
+                    "USER": username,
+                    "PASSWORD": password,
+                    "HOST": "somehost",
+                    "PORT": "444",
+                }
+            ),
+            (
+                ["psql", "-U", username, "-h", "somehost", "-p", "444", "dbname"],
+                {"PGPASSWORD": password},
+            ),
         )
 
     def test_parameters(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({'NAME': 'dbname'}, ['--help']),
-            (['psql', 'dbname', '--help'], None),
+            self.settings_to_cmd_args_env({"NAME": "dbname"}, ["--help"]),
+            (["psql", "dbname", "--help"], None),
         )
 
-    @skipUnless(connection.vendor == 'postgresql', 'Requires a PostgreSQL connection')
+    @skipUnless(connection.vendor == "postgresql", "Requires a PostgreSQL connection")
     def test_sigint_handler(self):
         """SIGINT is ignored in Python and passed to psql to abort queries."""
+
         def _mock_subprocess_run(*args, **kwargs):
             handler = signal.getsignal(signal.SIGINT)
             self.assertEqual(handler, signal.SIG_IGN)
@@ -147,7 +168,7 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
         sigint_handler = signal.getsignal(signal.SIGINT)
         # The default handler isn't SIG_IGN.
         self.assertNotEqual(sigint_handler, signal.SIG_IGN)
-        with mock.patch('subprocess.run', new=_mock_subprocess_run):
+        with mock.patch("subprocess.run", new=_mock_subprocess_run):
             connection.client.runshell([])
         # dbshell restores the original handler.
         self.assertEqual(sigint_handler, signal.getsignal(signal.SIGINT))
@@ -155,11 +176,11 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
     def test_crash_password_does_not_leak(self):
         # The password doesn't leak in an exception that results from a client
         # crash.
-        args, env = self.settings_to_cmd_args_env({'PASSWORD': 'somepassword'}, [])
+        args, env = self.settings_to_cmd_args_env({"PASSWORD": "somepassword"}, [])
         if env:
             env = {**os.environ, **env}
-        fake_client = Path(__file__).with_name('fake_client.py')
+        fake_client = Path(__file__).with_name("fake_client.py")
         args[0:1] = [sys.executable, str(fake_client)]
         with self.assertRaises(subprocess.CalledProcessError) as ctx:
             subprocess.run(args, check=True, env=env)
-        self.assertNotIn('somepassword', str(ctx.exception))
+        self.assertNotIn("somepassword", str(ctx.exception))
diff --git a/tests/dbshell/test_sqlite.py b/tests/dbshell/test_sqlite.py
index ea4bdd62e1..7c39fd111e 100644
--- a/tests/dbshell/test_sqlite.py
+++ b/tests/dbshell/test_sqlite.py
@@ -12,12 +12,12 @@ class SqliteDbshellCommandTestCase(SimpleTestCase):
 
     def test_path_name(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({'NAME': Path('test.db.sqlite3')}),
-            (['sqlite3', Path('test.db.sqlite3')], None),
+            self.settings_to_cmd_args_env({"NAME": Path("test.db.sqlite3")}),
+            (["sqlite3", Path("test.db.sqlite3")], None),
         )
 
     def test_parameters(self):
         self.assertEqual(
-            self.settings_to_cmd_args_env({'NAME': 'test.db.sqlite3'}, ['-help']),
-            (['sqlite3', 'test.db.sqlite3', '-help'], None),
+            self.settings_to_cmd_args_env({"NAME": "test.db.sqlite3"}, ["-help"]),
+            (["sqlite3", "test.db.sqlite3", "-help"], None),
         )
diff --git a/tests/dbshell/tests.py b/tests/dbshell/tests.py
index 3d4ac2fce6..8dd3d22c98 100644
--- a/tests/dbshell/tests.py
+++ b/tests/dbshell/tests.py
@@ -9,9 +9,9 @@ from django.test import SimpleTestCase
 class DbshellCommandTestCase(SimpleTestCase):
     def test_command_missing(self):
         msg = (
-            'You appear not to have the %r program installed or on your path.'
+            "You appear not to have the %r program installed or on your path."
             % connection.client.executable_name
         )
         with self.assertRaisesMessage(CommandError, msg):
-            with mock.patch('subprocess.run', side_effect=FileNotFoundError):
-                call_command('dbshell')
+            with mock.patch("subprocess.run", side_effect=FileNotFoundError):
+                call_command("dbshell")