Refs #33476 -- Reformatted code with Black.

9 files changed, 228 insertions, 169 deletions

diff --git a/tests/backends/base/app_unmigrated/migrations/0001_initial.py b/tests/backends/base/app_unmigrated/migrations/0001_initial.py
index 2481756a5c..38ecc948e4 100644
--- a/tests/backends/base/app_unmigrated/migrations/0001_initial.py
+++ b/tests/backends/base/app_unmigrated/migrations/0001_initial.py
@@ -8,10 +8,18 @@ class Migration(migrations.Migration):
 
     operations = [
         migrations.CreateModel(
-            name='Foo',
+            name="Foo",
             fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=255)),
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=255)),
             ],
         ),
     ]
diff --git a/tests/backends/base/app_unmigrated/models.py b/tests/backends/base/app_unmigrated/models.py
index 0c1f64f61d..4bb6074a84 100644
--- a/tests/backends/base/app_unmigrated/models.py
+++ b/tests/backends/base/app_unmigrated/models.py
@@ -5,4 +5,4 @@ class Foo(models.Model):
     name = models.CharField(max_length=255)
 
     class Meta:
-        app_label = 'app_unmigrated'
+        app_label = "app_unmigrated"
diff --git a/tests/backends/base/test_base.py b/tests/backends/base/test_base.py
index b2ebea5829..00ef766d5d 100644
--- a/tests/backends/base/test_base.py
+++ b/tests/backends/base/test_base.py
@@ -8,7 +8,6 @@ from ..models import Square
 
 
 class DatabaseWrapperTests(SimpleTestCase):
-
     def test_repr(self):
         conn = connections[DEFAULT_DB_ALIAS]
         self.assertEqual(
@@ -25,12 +24,12 @@ class DatabaseWrapperTests(SimpleTestCase):
         conn = connections[DEFAULT_DB_ALIAS]
         conn_class = type(conn)
         attr_names = [
-            ('client_class', 'client'),
-            ('creation_class', 'creation'),
-            ('features_class', 'features'),
-            ('introspection_class', 'introspection'),
-            ('ops_class', 'ops'),
-            ('validation_class', 'validation'),
+            ("client_class", "client"),
+            ("creation_class", "creation"),
+            ("features_class", "features"),
+            ("introspection_class", "introspection"),
+            ("ops_class", "ops"),
+            ("validation_class", "validation"),
         ]
         for class_attr_name, instance_attr_name in attr_names:
             class_attr_value = getattr(conn_class, class_attr_name)
@@ -39,23 +38,22 @@ class DatabaseWrapperTests(SimpleTestCase):
             self.assertIsInstance(instance_attr_value, class_attr_value)
 
     def test_initialization_display_name(self):
-        self.assertEqual(BaseDatabaseWrapper.display_name, 'unknown')
-        self.assertNotEqual(connection.display_name, 'unknown')
+        self.assertEqual(BaseDatabaseWrapper.display_name, "unknown")
+        self.assertNotEqual(connection.display_name, "unknown")
 
 
 class ExecuteWrapperTests(TestCase):
-
     @staticmethod
     def call_execute(connection, params=None):
-        ret_val = '1' if params is None else '%s'
-        sql = 'SELECT ' + ret_val + connection.features.bare_select_suffix
+        ret_val = "1" if params is None else "%s"
+        sql = "SELECT " + ret_val + connection.features.bare_select_suffix
         with connection.cursor() as cursor:
             cursor.execute(sql, params)
 
     def call_executemany(self, connection, params=None):
         # executemany() must use an update query. Make sure it does nothing
         # by putting a false condition in the WHERE clause.
-        sql = 'DELETE FROM {} WHERE 0=1 AND 0=%s'.format(Square._meta.db_table)
+        sql = "DELETE FROM {} WHERE 0=1 AND 0=%s".format(Square._meta.db_table)
         if params is None:
             params = [(i,) for i in range(3)]
         with connection.cursor() as cursor:
@@ -71,10 +69,10 @@ class ExecuteWrapperTests(TestCase):
             self.call_execute(connection)
         self.assertTrue(wrapper.called)
         (_, sql, params, many, context), _ = wrapper.call_args
-        self.assertIn('SELECT', sql)
+        self.assertIn("SELECT", sql)
         self.assertIsNone(params)
         self.assertIs(many, False)
-        self.assertEqual(context['connection'], connection)
+        self.assertEqual(context["connection"], connection)
 
     def test_wrapper_invoked_many(self):
         wrapper = self.mock_wrapper()
@@ -82,16 +80,16 @@ class ExecuteWrapperTests(TestCase):
             self.call_executemany(connection)
         self.assertTrue(wrapper.called)
         (_, sql, param_list, many, context), _ = wrapper.call_args
-        self.assertIn('DELETE', sql)
+        self.assertIn("DELETE", sql)
         self.assertIsInstance(param_list, (list, tuple))
         self.assertIs(many, True)
-        self.assertEqual(context['connection'], connection)
+        self.assertEqual(context["connection"], connection)
 
     def test_database_queried(self):
         wrapper = self.mock_wrapper()
         with connection.execute_wrapper(wrapper):
             with connection.cursor() as cursor:
-                sql = 'SELECT 17' + connection.features.bare_select_suffix
+                sql = "SELECT 17" + connection.features.bare_select_suffix
                 cursor.execute(sql)
                 seventeen = cursor.fetchall()
                 self.assertEqual(list(seventeen), [(17,)])
@@ -100,7 +98,9 @@ class ExecuteWrapperTests(TestCase):
     def test_nested_wrapper_invoked(self):
         outer_wrapper = self.mock_wrapper()
         inner_wrapper = self.mock_wrapper()
-        with connection.execute_wrapper(outer_wrapper), connection.execute_wrapper(inner_wrapper):
+        with connection.execute_wrapper(outer_wrapper), connection.execute_wrapper(
+            inner_wrapper
+        ):
             self.call_execute(connection)
             self.assertEqual(inner_wrapper.call_count, 1)
             self.call_executemany(connection)
@@ -109,9 +109,12 @@ class ExecuteWrapperTests(TestCase):
     def test_outer_wrapper_blocks(self):
         def blocker(*args):
             pass
+
         wrapper = self.mock_wrapper()
         c = connection  # This alias shortens the next line.
-        with c.execute_wrapper(wrapper), c.execute_wrapper(blocker), c.execute_wrapper(wrapper):
+        with c.execute_wrapper(wrapper), c.execute_wrapper(blocker), c.execute_wrapper(
+            wrapper
+        ):
             with c.cursor() as cursor:
                 cursor.execute("The database never sees this")
                 self.assertEqual(wrapper.call_count, 1)
@@ -128,16 +131,16 @@ class ExecuteWrapperTests(TestCase):
 
     def test_wrapper_connection_specific(self):
         wrapper = self.mock_wrapper()
-        with connections['other'].execute_wrapper(wrapper):
-            self.assertEqual(connections['other'].execute_wrappers, [wrapper])
+        with connections["other"].execute_wrapper(wrapper):
+            self.assertEqual(connections["other"].execute_wrappers, [wrapper])
             self.call_execute(connection)
         self.assertFalse(wrapper.called)
         self.assertEqual(connection.execute_wrappers, [])
-        self.assertEqual(connections['other'].execute_wrappers, [])
+        self.assertEqual(connections["other"].execute_wrappers, [])
 
 
 class ConnectionHealthChecksTests(SimpleTestCase):
-    databases = {'default'}
+    databases = {"default"}
 
     def setUp(self):
         # All test cases here need newly configured and created connections.
@@ -146,25 +149,28 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         self.addCleanup(connection.close)
 
     def patch_settings_dict(self, conn_health_checks):
-        self.settings_dict_patcher = patch.dict(connection.settings_dict, {
-            **connection.settings_dict,
-            'CONN_MAX_AGE': None,
-            'CONN_HEALTH_CHECKS': conn_health_checks,
-        })
+        self.settings_dict_patcher = patch.dict(
+            connection.settings_dict,
+            {
+                **connection.settings_dict,
+                "CONN_MAX_AGE": None,
+                "CONN_HEALTH_CHECKS": conn_health_checks,
+            },
+        )
         self.settings_dict_patcher.start()
         self.addCleanup(self.settings_dict_patcher.stop)
 
     def run_query(self):
         with connection.cursor() as cursor:
-            cursor.execute('SELECT 42' + connection.features.bare_select_suffix)
+            cursor.execute("SELECT 42" + connection.features.bare_select_suffix)
 
-    @skipUnlessDBFeature('test_db_allows_multiple_connections')
+    @skipUnlessDBFeature("test_db_allows_multiple_connections")
     def test_health_checks_enabled(self):
         self.patch_settings_dict(conn_health_checks=True)
         self.assertIsNone(connection.connection)
         # Newly created connections are considered healthy without performing
         # the health check.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             self.run_query()
 
         old_connection = connection.connection
@@ -173,7 +179,9 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         self.assertIs(old_connection, connection.connection)
 
         # Simulate connection health check failing.
-        with patch.object(connection, 'is_usable', return_value=False) as mocked_is_usable:
+        with patch.object(
+            connection, "is_usable", return_value=False
+        ) as mocked_is_usable:
             self.run_query()
             new_connection = connection.connection
             # A new connection is established.
@@ -194,13 +202,13 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         self.run_query()
         self.assertIs(new_connection, connection.connection)
 
-    @skipUnlessDBFeature('test_db_allows_multiple_connections')
+    @skipUnlessDBFeature("test_db_allows_multiple_connections")
     def test_health_checks_enabled_errors_occurred(self):
         self.patch_settings_dict(conn_health_checks=True)
         self.assertIsNone(connection.connection)
         # Newly created connections are considered healthy without performing
         # the health check.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             self.run_query()
 
         old_connection = connection.connection
@@ -213,16 +221,16 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         # No additional health checks after the one in
         # close_if_unusable_or_obsolete() are executed during this "request"
         # when running queries.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             self.run_query()
 
-    @skipUnlessDBFeature('test_db_allows_multiple_connections')
+    @skipUnlessDBFeature("test_db_allows_multiple_connections")
     def test_health_checks_disabled(self):
         self.patch_settings_dict(conn_health_checks=False)
         self.assertIsNone(connection.connection)
         # Newly created connections are considered healthy without performing
         # the health check.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             self.run_query()
 
         old_connection = connection.connection
@@ -231,7 +239,7 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         # Persistent connections are enabled (connection is not).
         self.assertIs(old_connection, connection.connection)
         # Health checks are not performed.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             self.run_query()
             # Health check wasn't performed and the connection is unchanged.
             self.assertIs(old_connection, connection.connection)
@@ -240,13 +248,13 @@ class ConnectionHealthChecksTests(SimpleTestCase):
             # the current "request".
             self.assertIs(old_connection, connection.connection)
 
-    @skipUnlessDBFeature('test_db_allows_multiple_connections')
+    @skipUnlessDBFeature("test_db_allows_multiple_connections")
     def test_set_autocommit_health_checks_enabled(self):
         self.patch_settings_dict(conn_health_checks=True)
         self.assertIsNone(connection.connection)
         # Newly created connections are considered healthy without performing
         # the health check.
-        with patch.object(connection, 'is_usable', side_effect=AssertionError):
+        with patch.object(connection, "is_usable", side_effect=AssertionError):
             # Simulate outermost atomic block: changing autocommit for
             # a connection.
             connection.set_autocommit(False)
@@ -261,7 +269,9 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         self.assertIs(old_connection, connection.connection)
 
         # Simulate connection health check failing.
-        with patch.object(connection, 'is_usable', return_value=False) as mocked_is_usable:
+        with patch.object(
+            connection, "is_usable", return_value=False
+        ) as mocked_is_usable:
             # Simulate outermost atomic block: changing autocommit for
             # a connection.
             connection.set_autocommit(False)
diff --git a/tests/backends/base/test_client.py b/tests/backends/base/test_client.py
index d9e5cc8883..7ed0604c32 100644
--- a/tests/backends/base/test_client.py
+++ b/tests/backends/base/test_client.py
@@ -11,8 +11,8 @@ class SimpleDatabaseClientTests(SimpleTestCase):
 
     def test_settings_to_cmd_args_env(self):
         msg = (
-            'subclasses of BaseDatabaseClient must provide a '
-            'settings_to_cmd_args_env() method or override a runshell().'
+            "subclasses of BaseDatabaseClient must provide a "
+            "settings_to_cmd_args_env() method or override a runshell()."
         )
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.client.settings_to_cmd_args_env(None, None)
@@ -20,10 +20,10 @@ class SimpleDatabaseClientTests(SimpleTestCase):
     def test_runshell_use_environ(self):
         for env in [None, {}]:
             with self.subTest(env=env):
-                with mock.patch('subprocess.run') as run:
+                with mock.patch("subprocess.run") as run:
                     with mock.patch.object(
                         BaseDatabaseClient,
-                        'settings_to_cmd_args_env',
+                        "settings_to_cmd_args_env",
                         return_value=([], env),
                     ):
                         self.client.runshell(None)
diff --git a/tests/backends/base/test_creation.py b/tests/backends/base/test_creation.py
index 825fb872ed..9593e13462 100644
--- a/tests/backends/base/test_creation.py
+++ b/tests/backends/base/test_creation.py
@@ -4,14 +4,16 @@ import os
 from unittest import mock
 
 from django.db import DEFAULT_DB_ALIAS, connection, connections
-from django.db.backends.base.creation import (
-    TEST_DATABASE_PREFIX, BaseDatabaseCreation,
-)
+from django.db.backends.base.creation import TEST_DATABASE_PREFIX, BaseDatabaseCreation
 from django.test import SimpleTestCase, TransactionTestCase
 from django.test.utils import override_settings
 
 from ..models import (
-    CircularA, CircularB, Object, ObjectReference, ObjectSelfReference,
+    CircularA,
+    CircularB,
+    Object,
+    ObjectReference,
+    ObjectSelfReference,
     SchoolClass,
 )
 
@@ -29,135 +31,146 @@ def get_connection_copy():
 class TestDbSignatureTests(SimpleTestCase):
     def test_default_name(self):
         # A test db name isn't set.
-        prod_name = 'hodor'
+        prod_name = "hodor"
         test_connection = get_connection_copy()
-        test_connection.settings_dict['NAME'] = prod_name
-        test_connection.settings_dict['TEST'] = {'NAME': None}
+        test_connection.settings_dict["NAME"] = prod_name
+        test_connection.settings_dict["TEST"] = {"NAME": None}
         signature = BaseDatabaseCreation(test_connection).test_db_signature()
         self.assertEqual(signature[3], TEST_DATABASE_PREFIX + prod_name)
 
     def test_custom_test_name(self):
         # A regular test db name is set.
-        test_name = 'hodor'
+        test_name = "hodor"
         test_connection = get_connection_copy()
-        test_connection.settings_dict['TEST'] = {'NAME': test_name}
+        test_connection.settings_dict["TEST"] = {"NAME": test_name}
         signature = BaseDatabaseCreation(test_connection).test_db_signature()
         self.assertEqual(signature[3], test_name)
 
     def test_custom_test_name_with_test_prefix(self):
         # A test db name prefixed with TEST_DATABASE_PREFIX is set.
-        test_name = TEST_DATABASE_PREFIX + 'hodor'
+        test_name = TEST_DATABASE_PREFIX + "hodor"
         test_connection = get_connection_copy()
-        test_connection.settings_dict['TEST'] = {'NAME': test_name}
+        test_connection.settings_dict["TEST"] = {"NAME": test_name}
         signature = BaseDatabaseCreation(test_connection).test_db_signature()
         self.assertEqual(signature[3], test_name)
 
 
-@override_settings(INSTALLED_APPS=['backends.base.app_unmigrated'])
-@mock.patch.object(connection, 'ensure_connection')
-@mock.patch.object(connection, 'prepare_database')
-@mock.patch('django.db.migrations.recorder.MigrationRecorder.has_table', return_value=False)
-@mock.patch('django.core.management.commands.migrate.Command.sync_apps')
+@override_settings(INSTALLED_APPS=["backends.base.app_unmigrated"])
+@mock.patch.object(connection, "ensure_connection")
+@mock.patch.object(connection, "prepare_database")
+@mock.patch(
+    "django.db.migrations.recorder.MigrationRecorder.has_table", return_value=False
+)
+@mock.patch("django.core.management.commands.migrate.Command.sync_apps")
 class TestDbCreationTests(SimpleTestCase):
-    available_apps = ['backends.base.app_unmigrated']
+    available_apps = ["backends.base.app_unmigrated"]
 
-    @mock.patch('django.db.migrations.executor.MigrationExecutor.migrate')
-    def test_migrate_test_setting_false(self, mocked_migrate, mocked_sync_apps, *mocked_objects):
+    @mock.patch("django.db.migrations.executor.MigrationExecutor.migrate")
+    def test_migrate_test_setting_false(
+        self, mocked_migrate, mocked_sync_apps, *mocked_objects
+    ):
         test_connection = get_connection_copy()
-        test_connection.settings_dict['TEST']['MIGRATE'] = False
+        test_connection.settings_dict["TEST"]["MIGRATE"] = False
         creation = test_connection.creation_class(test_connection)
-        if connection.vendor == 'oracle':
+        if connection.vendor == "oracle":
             # Don't close connection on Oracle.
             creation.connection.close = mock.Mock()
-        old_database_name = test_connection.settings_dict['NAME']
+        old_database_name = test_connection.settings_dict["NAME"]
         try:
-            with mock.patch.object(creation, '_create_test_db'):
+            with mock.patch.object(creation, "_create_test_db"):
                 creation.create_test_db(verbosity=0, autoclobber=True, serialize=False)
             # Migrations don't run.
             mocked_migrate.assert_called()
             args, kwargs = mocked_migrate.call_args
             self.assertEqual(args, ([],))
-            self.assertEqual(kwargs['plan'], [])
+            self.assertEqual(kwargs["plan"], [])
             # App is synced.
             mocked_sync_apps.assert_called()
             mocked_args, _ = mocked_sync_apps.call_args
-            self.assertEqual(mocked_args[1], {'app_unmigrated'})
+            self.assertEqual(mocked_args[1], {"app_unmigrated"})
         finally:
-            with mock.patch.object(creation, '_destroy_test_db'):
+            with mock.patch.object(creation, "_destroy_test_db"):
                 creation.destroy_test_db(old_database_name, verbosity=0)
 
-    @mock.patch('django.db.migrations.executor.MigrationRecorder.ensure_schema')
+    @mock.patch("django.db.migrations.executor.MigrationRecorder.ensure_schema")
     def test_migrate_test_setting_false_ensure_schema(
-        self, mocked_ensure_schema, mocked_sync_apps, *mocked_objects,
+        self,
+        mocked_ensure_schema,
+        mocked_sync_apps,
+        *mocked_objects,
     ):
         test_connection = get_connection_copy()
-        test_connection.settings_dict['TEST']['MIGRATE'] = False
+        test_connection.settings_dict["TEST"]["MIGRATE"] = False
         creation = test_connection.creation_class(test_connection)
-        if connection.vendor == 'oracle':
+        if connection.vendor == "oracle":
             # Don't close connection on Oracle.
             creation.connection.close = mock.Mock()
-        old_database_name = test_connection.settings_dict['NAME']
+        old_database_name = test_connection.settings_dict["NAME"]
         try:
-            with mock.patch.object(creation, '_create_test_db'):
+            with mock.patch.object(creation, "_create_test_db"):
                 creation.create_test_db(verbosity=0, autoclobber=True, serialize=False)
             # The django_migrations table is not created.
             mocked_ensure_schema.assert_not_called()
             # App is synced.
             mocked_sync_apps.assert_called()
             mocked_args, _ = mocked_sync_apps.call_args
-            self.assertEqual(mocked_args[1], {'app_unmigrated'})
+            self.assertEqual(mocked_args[1], {"app_unmigrated"})
         finally:
-            with mock.patch.object(creation, '_destroy_test_db'):
+            with mock.patch.object(creation, "_destroy_test_db"):
                 creation.destroy_test_db(old_database_name, verbosity=0)
 
-    @mock.patch('django.db.migrations.executor.MigrationExecutor.migrate')
-    def test_migrate_test_setting_true(self, mocked_migrate, mocked_sync_apps, *mocked_objects):
+    @mock.patch("django.db.migrations.executor.MigrationExecutor.migrate")
+    def test_migrate_test_setting_true(
+        self, mocked_migrate, mocked_sync_apps, *mocked_objects
+    ):
         test_connection = get_connection_copy()
-        test_connection.settings_dict['TEST']['MIGRATE'] = True
+        test_connection.settings_dict["TEST"]["MIGRATE"] = True
         creation = test_connection.creation_class(test_connection)
-        if connection.vendor == 'oracle':
+        if connection.vendor == "oracle":
             # Don't close connection on Oracle.
             creation.connection.close = mock.Mock()
-        old_database_name = test_connection.settings_dict['NAME']
+        old_database_name = test_connection.settings_dict["NAME"]
         try:
-            with mock.patch.object(creation, '_create_test_db'):
+            with mock.patch.object(creation, "_create_test_db"):
                 creation.create_test_db(verbosity=0, autoclobber=True, serialize=False)
             # Migrations run.
             mocked_migrate.assert_called()
             args, kwargs = mocked_migrate.call_args
-            self.assertEqual(args, ([('app_unmigrated', '0001_initial')],))
-            self.assertEqual(len(kwargs['plan']), 1)
+            self.assertEqual(args, ([("app_unmigrated", "0001_initial")],))
+            self.assertEqual(len(kwargs["plan"]), 1)
             # App is not synced.
             mocked_sync_apps.assert_not_called()
         finally:
-            with mock.patch.object(creation, '_destroy_test_db'):
+            with mock.patch.object(creation, "_destroy_test_db"):
                 creation.destroy_test_db(old_database_name, verbosity=0)
 
-    @mock.patch.dict(os.environ, {'RUNNING_DJANGOS_TEST_SUITE': ''})
-    @mock.patch('django.db.migrations.executor.MigrationExecutor.migrate')
-    @mock.patch.object(BaseDatabaseCreation, 'mark_expected_failures_and_skips')
-    def test_mark_expected_failures_and_skips_call(self, mark_expected_failures_and_skips, *mocked_objects):
+    @mock.patch.dict(os.environ, {"RUNNING_DJANGOS_TEST_SUITE": ""})
+    @mock.patch("django.db.migrations.executor.MigrationExecutor.migrate")
+    @mock.patch.object(BaseDatabaseCreation, "mark_expected_failures_and_skips")
+    def test_mark_expected_failures_and_skips_call(
+        self, mark_expected_failures_and_skips, *mocked_objects
+    ):
         """
         mark_expected_failures_and_skips() isn't called unless
         RUNNING_DJANGOS_TEST_SUITE is 'true'.
         """
         test_connection = get_connection_copy()
         creation = test_connection.creation_class(test_connection)
-        if connection.vendor == 'oracle':
+        if connection.vendor == "oracle":
             # Don't close connection on Oracle.
             creation.connection.close = mock.Mock()
-        old_database_name = test_connection.settings_dict['NAME']
+        old_database_name = test_connection.settings_dict["NAME"]
         try:
-            with mock.patch.object(creation, '_create_test_db'):
+            with mock.patch.object(creation, "_create_test_db"):
                 creation.create_test_db(verbosity=0, autoclobber=True, serialize=False)
             self.assertIs(mark_expected_failures_and_skips.called, False)
         finally:
-            with mock.patch.object(creation, '_destroy_test_db'):
+            with mock.patch.object(creation, "_destroy_test_db"):
                 creation.destroy_test_db(old_database_name, verbosity=0)
 
 
 class TestDeserializeDbFromString(TransactionTestCase):
-    available_apps = ['backends']
+    available_apps = ["backends"]
 
     def test_circular_reference(self):
         # deserialize_db_from_string() handles circular references.
@@ -184,38 +197,38 @@ class TestDeserializeDbFromString(TransactionTestCase):
     def test_self_reference(self):
         # serialize_db_to_string() and deserialize_db_from_string() handles
         # self references.
-        obj_1 = ObjectSelfReference.objects.create(key='X')
-        obj_2 = ObjectSelfReference.objects.create(key='Y', obj=obj_1)
+        obj_1 = ObjectSelfReference.objects.create(key="X")
+        obj_2 = ObjectSelfReference.objects.create(key="Y", obj=obj_1)
         obj_1.obj = obj_2
         obj_1.save()
         # Serialize objects.
-        with mock.patch('django.db.migrations.loader.MigrationLoader') as loader:
+        with mock.patch("django.db.migrations.loader.MigrationLoader") as loader:
             # serialize_db_to_string() serializes only migrated apps, so mark
             # the backends app as migrated.
             loader_instance = loader.return_value
-            loader_instance.migrated_apps = {'backends'}
+            loader_instance.migrated_apps = {"backends"}
             data = connection.creation.serialize_db_to_string()
         ObjectSelfReference.objects.all().delete()
         # Deserialize objects.
         connection.creation.deserialize_db_from_string(data)
-        obj_1 = ObjectSelfReference.objects.get(key='X')
-        obj_2 = ObjectSelfReference.objects.get(key='Y')
+        obj_1 = ObjectSelfReference.objects.get(key="X")
+        obj_2 = ObjectSelfReference.objects.get(key="Y")
         self.assertEqual(obj_1.obj, obj_2)
         self.assertEqual(obj_2.obj, obj_1)
 
     def test_circular_reference_with_natural_key(self):
         # serialize_db_to_string() and deserialize_db_from_string() handles
         # circular references for models with natural keys.
-        obj_a = CircularA.objects.create(key='A')
-        obj_b = CircularB.objects.create(key='B', obj=obj_a)
+        obj_a = CircularA.objects.create(key="A")
+        obj_b = CircularB.objects.create(key="B", obj=obj_a)
         obj_a.obj = obj_b
         obj_a.save()
         # Serialize objects.
-        with mock.patch('django.db.migrations.loader.MigrationLoader') as loader:
+        with mock.patch("django.db.migrations.loader.MigrationLoader") as loader:
             # serialize_db_to_string() serializes only migrated apps, so mark
             # the backends app as migrated.
             loader_instance = loader.return_value
-            loader_instance.migrated_apps = {'backends'}
+            loader_instance.migrated_apps = {"backends"}
             data = connection.creation.serialize_db_to_string()
         CircularA.objects.all().delete()
         CircularB.objects.all().delete()
@@ -228,11 +241,11 @@ class TestDeserializeDbFromString(TransactionTestCase):
 
     def test_serialize_db_to_string_base_manager(self):
         SchoolClass.objects.create(year=1000, last_updated=datetime.datetime.now())
-        with mock.patch('django.db.migrations.loader.MigrationLoader') as loader:
+        with mock.patch("django.db.migrations.loader.MigrationLoader") as loader:
             # serialize_db_to_string() serializes only migrated apps, so mark
             # the backends app as migrated.
             loader_instance = loader.return_value
-            loader_instance.migrated_apps = {'backends'}
+            loader_instance.migrated_apps = {"backends"}
             data = connection.creation.serialize_db_to_string()
         self.assertIn('"model": "backends.schoolclass"', data)
         self.assertIn('"year": 1000', data)
@@ -256,14 +269,14 @@ class TestMarkTests(SimpleTestCase):
         test_connection = get_connection_copy()
         creation = BaseDatabaseCreation(test_connection)
         creation.connection.features.django_test_expected_failures = {
-            'backends.base.test_creation.expected_failure_test_function',
+            "backends.base.test_creation.expected_failure_test_function",
         }
         creation.connection.features.django_test_skips = {
-            'skip test class': {
-                'backends.base.test_creation.SkipTestClass',
+            "skip test class": {
+                "backends.base.test_creation.SkipTestClass",
             },
-            'skip test function': {
-                'backends.base.test_creation.skip_test_function',
+            "skip test function": {
+                "backends.base.test_creation.skip_test_function",
             },
         }
         creation.mark_expected_failures_and_skips()
@@ -274,10 +287,10 @@ class TestMarkTests(SimpleTestCase):
         self.assertIs(SkipTestClass.__unittest_skip__, True)
         self.assertEqual(
             SkipTestClass.__unittest_skip_why__,
-            'skip test class',
+            "skip test class",
         )
         self.assertIs(skip_test_function.__unittest_skip__, True)
         self.assertEqual(
             skip_test_function.__unittest_skip_why__,
-            'skip test function',
+            "skip test function",
         )
diff --git a/tests/backends/base/test_features.py b/tests/backends/base/test_features.py
index 9b67cfec47..f8a8e945e0 100644
--- a/tests/backends/base/test_features.py
+++ b/tests/backends/base/test_features.py
@@ -3,6 +3,5 @@ from django.test import SimpleTestCase
 
 
 class TestDatabaseFeatures(SimpleTestCase):
-
     def test_nonexistent_feature(self):
-        self.assertFalse(hasattr(connection.features, 'nonexistent'))
+        self.assertFalse(hasattr(connection.features, "nonexistent"))
diff --git a/tests/backends/base/test_introspection.py b/tests/backends/base/test_introspection.py
index 636d6683c0..284e98f2ae 100644
--- a/tests/backends/base/test_introspection.py
+++ b/tests/backends/base/test_introspection.py
@@ -5,33 +5,33 @@ from django.test import SimpleTestCase
 
 class SimpleDatabaseIntrospectionTests(SimpleTestCase):
     may_require_msg = (
-        'subclasses of BaseDatabaseIntrospection may require a %s() method'
+        "subclasses of BaseDatabaseIntrospection may require a %s() method"
     )
 
     def setUp(self):
         self.introspection = BaseDatabaseIntrospection(connection=connection)
 
     def test_get_table_list(self):
-        msg = self.may_require_msg % 'get_table_list'
+        msg = self.may_require_msg % "get_table_list"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.introspection.get_table_list(None)
 
     def test_get_table_description(self):
-        msg = self.may_require_msg % 'get_table_description'
+        msg = self.may_require_msg % "get_table_description"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.introspection.get_table_description(None, None)
 
     def test_get_sequences(self):
-        msg = self.may_require_msg % 'get_sequences'
+        msg = self.may_require_msg % "get_sequences"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.introspection.get_sequences(None, None)
 
     def test_get_relations(self):
-        msg = self.may_require_msg % 'get_relations'
+        msg = self.may_require_msg % "get_relations"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.introspection.get_relations(None, None)
 
     def test_get_constraints(self):
-        msg = self.may_require_msg % 'get_constraints'
+        msg = self.may_require_msg % "get_constraints"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.introspection.get_constraints(None, None)
diff --git a/tests/backends/base/test_operations.py b/tests/backends/base/test_operations.py
index 535cb20f41..b19b7ee558 100644
--- a/tests/backends/base/test_operations.py
+++ b/tests/backends/base/test_operations.py
@@ -5,7 +5,10 @@ from django.db import NotSupportedError, connection, transaction
 from django.db.backends.base.operations import BaseDatabaseOperations
 from django.db.models import DurationField, Value
 from django.test import (
-    SimpleTestCase, TestCase, TransactionTestCase, override_settings,
+    SimpleTestCase,
+    TestCase,
+    TransactionTestCase,
+    override_settings,
     skipIfDBFeature,
 )
 from django.utils import timezone
@@ -14,60 +17,70 @@ from ..models import Author, Book
 
 
 class SimpleDatabaseOperationTests(SimpleTestCase):
-    may_require_msg = 'subclasses of BaseDatabaseOperations may require a %s() method'
+    may_require_msg = "subclasses of BaseDatabaseOperations may require a %s() method"
 
     def setUp(self):
         self.ops = BaseDatabaseOperations(connection=connection)
 
     def test_deferrable_sql(self):
-        self.assertEqual(self.ops.deferrable_sql(), '')
+        self.assertEqual(self.ops.deferrable_sql(), "")
 
     def test_end_transaction_rollback(self):
-        self.assertEqual(self.ops.end_transaction_sql(success=False), 'ROLLBACK;')
+        self.assertEqual(self.ops.end_transaction_sql(success=False), "ROLLBACK;")
 
     def test_no_limit_value(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'no_limit_value'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "no_limit_value"
+        ):
             self.ops.no_limit_value()
 
     def test_quote_name(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'quote_name'):
-            self.ops.quote_name('a')
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "quote_name"
+        ):
+            self.ops.quote_name("a")
 
     def test_regex_lookup(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'regex_lookup'):
-            self.ops.regex_lookup(lookup_type='regex')
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "regex_lookup"
+        ):
+            self.ops.regex_lookup(lookup_type="regex")
 
     def test_set_time_zone_sql(self):
-        self.assertEqual(self.ops.set_time_zone_sql(), '')
+        self.assertEqual(self.ops.set_time_zone_sql(), "")
 
     def test_sql_flush(self):
-        msg = 'subclasses of BaseDatabaseOperations must provide an sql_flush() method'
+        msg = "subclasses of BaseDatabaseOperations must provide an sql_flush() method"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.ops.sql_flush(None, None)
 
     def test_pk_default_value(self):
-        self.assertEqual(self.ops.pk_default_value(), 'DEFAULT')
+        self.assertEqual(self.ops.pk_default_value(), "DEFAULT")
 
     def test_tablespace_sql(self):
-        self.assertEqual(self.ops.tablespace_sql(None), '')
+        self.assertEqual(self.ops.tablespace_sql(None), "")
 
     def test_sequence_reset_by_name_sql(self):
         self.assertEqual(self.ops.sequence_reset_by_name_sql(None, []), [])
 
     def test_adapt_unknown_value_decimal(self):
-        value = decimal.Decimal('3.14')
+        value = decimal.Decimal("3.14")
         self.assertEqual(
             self.ops.adapt_unknown_value(value),
-            self.ops.adapt_decimalfield_value(value)
+            self.ops.adapt_decimalfield_value(value),
         )
 
     def test_adapt_unknown_value_date(self):
         value = timezone.now().date()
-        self.assertEqual(self.ops.adapt_unknown_value(value), self.ops.adapt_datefield_value(value))
+        self.assertEqual(
+            self.ops.adapt_unknown_value(value), self.ops.adapt_datefield_value(value)
+        )
 
     def test_adapt_unknown_value_time(self):
         value = timezone.now().time()
-        self.assertEqual(self.ops.adapt_unknown_value(value), self.ops.adapt_timefield_value(value))
+        self.assertEqual(
+            self.ops.adapt_unknown_value(value), self.ops.adapt_timefield_value(value)
+        )
 
     def test_adapt_timefield_value_none(self):
         self.assertIsNone(self.ops.adapt_timefield_value(None))
@@ -84,7 +97,7 @@ class SimpleDatabaseOperationTests(SimpleTestCase):
         self.assertEqual(self.ops.adapt_datetimefield_value(value), value)
 
     def test_adapt_timefield_value(self):
-        msg = 'Django does not support timezone-aware times.'
+        msg = "Django does not support timezone-aware times."
         with self.assertRaisesMessage(ValueError, msg):
             self.ops.adapt_timefield_value(timezone.make_aware(timezone.now()))
 
@@ -94,40 +107,56 @@ class SimpleDatabaseOperationTests(SimpleTestCase):
         self.assertEqual(self.ops.adapt_timefield_value(now), str(now))
 
     def test_format_for_duration_arithmetic(self):
-        msg = self.may_require_msg % 'format_for_duration_arithmetic'
+        msg = self.may_require_msg % "format_for_duration_arithmetic"
         with self.assertRaisesMessage(NotImplementedError, msg):
             self.ops.format_for_duration_arithmetic(None)
 
     def test_date_extract_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'date_extract_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "date_extract_sql"
+        ):
             self.ops.date_extract_sql(None, None)
 
     def test_time_extract_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'date_extract_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "date_extract_sql"
+        ):
             self.ops.time_extract_sql(None, None)
 
     def test_date_trunc_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'date_trunc_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "date_trunc_sql"
+        ):
             self.ops.date_trunc_sql(None, None)
 
     def test_time_trunc_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'time_trunc_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "time_trunc_sql"
+        ):
             self.ops.time_trunc_sql(None, None)
 
     def test_datetime_trunc_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'datetime_trunc_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "datetime_trunc_sql"
+        ):
             self.ops.datetime_trunc_sql(None, None, None)
 
     def test_datetime_cast_date_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'datetime_cast_date_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "datetime_cast_date_sql"
+        ):
             self.ops.datetime_cast_date_sql(None, None)
 
     def test_datetime_cast_time_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'datetime_cast_time_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "datetime_cast_time_sql"
+        ):
             self.ops.datetime_cast_time_sql(None, None)
 
     def test_datetime_extract_sql(self):
-        with self.assertRaisesMessage(NotImplementedError, self.may_require_msg % 'datetime_extract_sql'):
+        with self.assertRaisesMessage(
+            NotImplementedError, self.may_require_msg % "datetime_extract_sql"
+        ):
             self.ops.datetime_extract_sql(None, None, None)
 
 
@@ -135,41 +164,41 @@ class DatabaseOperationTests(TestCase):
     def setUp(self):
         self.ops = BaseDatabaseOperations(connection=connection)
 
-    @skipIfDBFeature('supports_over_clause')
+    @skipIfDBFeature("supports_over_clause")
     def test_window_frame_raise_not_supported_error(self):
-        msg = 'This backend does not support window expressions.'
+        msg = "This backend does not support window expressions."
         with self.assertRaisesMessage(NotSupportedError, msg):
             self.ops.window_frame_rows_start_end()
 
-    @skipIfDBFeature('can_distinct_on_fields')
+    @skipIfDBFeature("can_distinct_on_fields")
     def test_distinct_on_fields(self):
-        msg = 'DISTINCT ON fields is not supported by this database backend'
+        msg = "DISTINCT ON fields is not supported by this database backend"
         with self.assertRaisesMessage(NotSupportedError, msg):
-            self.ops.distinct_sql(['a', 'b'], None)
+            self.ops.distinct_sql(["a", "b"], None)
 
-    @skipIfDBFeature('supports_temporal_subtraction')
+    @skipIfDBFeature("supports_temporal_subtraction")
     def test_subtract_temporals(self):
         duration_field = DurationField()
         duration_field_internal_type = duration_field.get_internal_type()
         msg = (
-            'This backend does not support %s subtraction.' %
-            duration_field_internal_type
+            "This backend does not support %s subtraction."
+            % duration_field_internal_type
         )
         with self.assertRaisesMessage(NotSupportedError, msg):
             self.ops.subtract_temporals(duration_field_internal_type, None, None)
 
 
 class SqlFlushTests(TransactionTestCase):
-    available_apps = ['backends']
+    available_apps = ["backends"]
 
     def test_sql_flush_no_tables(self):
         self.assertEqual(connection.ops.sql_flush(no_style(), []), [])
 
     def test_execute_sql_flush_statements(self):
         with transaction.atomic():
-            author = Author.objects.create(name='George Orwell')
+            author = Author.objects.create(name="George Orwell")
             Book.objects.create(author=author)
-            author = Author.objects.create(name='Harper Lee')
+            author = Author.objects.create(name="Harper Lee")
             Book.objects.create(author=author)
             Book.objects.create(author=author)
             self.assertIs(Author.objects.exists(), True)
@@ -187,7 +216,7 @@ class SqlFlushTests(TransactionTestCase):
             self.assertIs(Author.objects.exists(), False)
             self.assertIs(Book.objects.exists(), False)
             if connection.features.supports_sequence_reset:
-                author = Author.objects.create(name='F. Scott Fitzgerald')
+                author = Author.objects.create(name="F. Scott Fitzgerald")
                 self.assertEqual(author.pk, 1)
                 book = Book.objects.create(author=author)
                 self.assertEqual(book.pk, 1)
diff --git a/tests/backends/base/test_schema.py b/tests/backends/base/test_schema.py
index 2ecad098a6..5409789b13 100644
--- a/tests/backends/base/test_schema.py
+++ b/tests/backends/base/test_schema.py
@@ -4,9 +4,9 @@ from django.test import SimpleTestCase
 
 
 class SchemaEditorTests(SimpleTestCase):
-
     def test_effective_default_callable(self):
         """SchemaEditor.effective_default() shouldn't call callable defaults."""
+
         class MyStr(str):
             def __call__(self):
                 return self