Refs #33476 -- Reformatted code with Black.

2 files changed, 292 insertions, 209 deletions

diff --git a/tests/indexes/models.py b/tests/indexes/models.py
index 97679225f5..241556ca69 100644
--- a/tests/indexes/models.py
+++ b/tests/indexes/models.py
@@ -5,21 +5,24 @@ class CurrentTranslation(models.ForeignObject):
     """
     Creates virtual relation to the translation with model cache enabled.
     """
+
     # Avoid validation
     requires_unique_target = False
 
     def __init__(self, to, on_delete, from_fields, to_fields, **kwargs):
         # Disable reverse relation
-        kwargs['related_name'] = '+'
+        kwargs["related_name"] = "+"
         # Set unique to enable model cache.
-        kwargs['unique'] = True
+        kwargs["unique"] = True
         super().__init__(to, on_delete, from_fields, to_fields, **kwargs)
 
 
 class ArticleTranslation(models.Model):
 
-    article = models.ForeignKey('indexes.Article', models.CASCADE)
-    article_no_constraint = models.ForeignKey('indexes.Article', models.CASCADE, db_constraint=False, related_name='+')
+    article = models.ForeignKey("indexes.Article", models.CASCADE)
+    article_no_constraint = models.ForeignKey(
+        "indexes.Article", models.CASCADE, db_constraint=False, related_name="+"
+    )
     language = models.CharField(max_length=10, unique=True)
     content = models.TextField()
 
@@ -30,7 +33,9 @@ class Article(models.Model):
     published = models.BooleanField(default=False)
 
     # Add virtual relation to the ArticleTranslation model.
-    translation = CurrentTranslation(ArticleTranslation, models.CASCADE, ['id'], ['article'])
+    translation = CurrentTranslation(
+        ArticleTranslation, models.CASCADE, ["id"], ["article"]
+    )
 
     class Meta:
         index_together = [
@@ -53,7 +58,7 @@ class IndexedArticle(models.Model):
     slug = models.CharField(max_length=40, unique=True)
 
     class Meta:
-        required_db_features = {'supports_index_on_text_field'}
+        required_db_features = {"supports_index_on_text_field"}
 
 
 class IndexedArticle2(models.Model):
diff --git a/tests/indexes/tests.py b/tests/indexes/tests.py
index e114a90fba..80202f37ed 100644
--- a/tests/indexes/tests.py
+++ b/tests/indexes/tests.py
@@ -5,13 +5,19 @@ from django.db import connection
 from django.db.models import CASCADE, ForeignKey, Index, Q
 from django.db.models.functions import Lower
 from django.test import (
-    TestCase, TransactionTestCase, skipIfDBFeature, skipUnlessDBFeature,
+    TestCase,
+    TransactionTestCase,
+    skipIfDBFeature,
+    skipUnlessDBFeature,
 )
 from django.test.utils import override_settings
 from django.utils import timezone
 
 from .models import (
-    Article, ArticleTranslation, IndexedArticle2, IndexTogetherSingleList,
+    Article,
+    ArticleTranslation,
+    IndexedArticle2,
+    IndexTogetherSingleList,
 )
 
 
@@ -39,21 +45,23 @@ class SchemaIndexesTests(TestCase):
             * Include all the column names.
             * Include a deterministic hash.
         """
-        long_name = 'l%sng' % ('o' * 100)
+        long_name = "l%sng" % ("o" * 100)
         editor = connection.schema_editor()
         index_name = editor._create_index_name(
             table_name=Article._meta.db_table,
-            column_names=('c1', 'c2', long_name),
-            suffix='ix',
+            column_names=("c1", "c2", long_name),
+            suffix="ix",
         )
         expected = {
-            'mysql': 'indexes_article_c1_c2_looooooooooooooooooo_255179b2ix',
-            'oracle': 'indexes_a_c1_c2_loo_255179b2ix',
-            'postgresql': 'indexes_article_c1_c2_loooooooooooooooooo_255179b2ix',
-            'sqlite': 'indexes_article_c1_c2_l%sng_255179b2ix' % ('o' * 100),
+            "mysql": "indexes_article_c1_c2_looooooooooooooooooo_255179b2ix",
+            "oracle": "indexes_a_c1_c2_loo_255179b2ix",
+            "postgresql": "indexes_article_c1_c2_loooooooooooooooooo_255179b2ix",
+            "sqlite": "indexes_article_c1_c2_l%sng_255179b2ix" % ("o" * 100),
         }
         if connection.vendor not in expected:
-            self.skipTest('This test is only supported on the built-in database backends.')
+            self.skipTest(
+                "This test is only supported on the built-in database backends."
+            )
         self.assertEqual(index_name, expected[connection.vendor])
 
     def test_index_together(self):
@@ -63,41 +71,45 @@ class SchemaIndexesTests(TestCase):
         # Ensure the index name is properly quoted
         self.assertIn(
             connection.ops.quote_name(
-                editor._create_index_name(Article._meta.db_table, ['headline', 'pub_date'], suffix='_idx')
+                editor._create_index_name(
+                    Article._meta.db_table, ["headline", "pub_date"], suffix="_idx"
+                )
             ),
-            index_sql[0]
+            index_sql[0],
         )
 
     def test_index_together_single_list(self):
         # Test for using index_together with a single list (#22172)
-        index_sql = connection.schema_editor()._model_indexes_sql(IndexTogetherSingleList)
+        index_sql = connection.schema_editor()._model_indexes_sql(
+            IndexTogetherSingleList
+        )
         self.assertEqual(len(index_sql), 1)
 
     def test_columns_list_sql(self):
-        index = Index(fields=['headline'], name='whitespace_idx')
+        index = Index(fields=["headline"], name="whitespace_idx")
         editor = connection.schema_editor()
         self.assertIn(
-            '(%s)' % editor.quote_name('headline'),
+            "(%s)" % editor.quote_name("headline"),
             str(index.create_sql(Article, editor)),
         )
 
     def test_descending_columns_list_sql(self):
-        index = Index(fields=['-headline'], name='whitespace_idx')
+        index = Index(fields=["-headline"], name="whitespace_idx")
         editor = connection.schema_editor()
         self.assertIn(
-            '(%s DESC)' % editor.quote_name('headline'),
+            "(%s DESC)" % editor.quote_name("headline"),
             str(index.create_sql(Article, editor)),
         )
 
 
 class SchemaIndexesNotPostgreSQLTests(TransactionTestCase):
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_create_index_ignores_opclasses(self):
         index = Index(
-            name='test_ops_class',
-            fields=['headline'],
-            opclasses=['varchar_pattern_ops'],
+            name="test_ops_class",
+            fields=["headline"],
+            opclasses=["varchar_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             # This would error if opclasses weren't ignored.
@@ -106,14 +118,14 @@ class SchemaIndexesNotPostgreSQLTests(TransactionTestCase):
 
 # The `condition` parameter is ignored by databases that don't support partial
 # indexes.
-@skipIfDBFeature('supports_partial_indexes')
+@skipIfDBFeature("supports_partial_indexes")
 class PartialIndexConditionIgnoredTests(TransactionTestCase):
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_condition_ignored(self):
         index = Index(
-            name='test_condition_ignored',
-            fields=['published'],
+            name="test_condition_ignored",
+            fields=["published"],
             condition=Q(published=True),
         )
         with connection.schema_editor() as editor:
@@ -121,25 +133,31 @@ class PartialIndexConditionIgnoredTests(TransactionTestCase):
             editor.add_index(Article, index)
 
         self.assertNotIn(
-            'WHERE %s' % editor.quote_name('published'),
-            str(index.create_sql(Article, editor))
+            "WHERE %s" % editor.quote_name("published"),
+            str(index.create_sql(Article, editor)),
         )
 
 
-@skipUnless(connection.vendor == 'postgresql', 'PostgreSQL tests')
+@skipUnless(connection.vendor == "postgresql", "PostgreSQL tests")
 class SchemaIndexesPostgreSQLTests(TransactionTestCase):
-    available_apps = ['indexes']
-    get_opclass_query = '''
+    available_apps = ["indexes"]
+    get_opclass_query = """
         SELECT opcname, c.relname FROM pg_opclass AS oc
         JOIN pg_index as i on oc.oid = ANY(i.indclass)
         JOIN pg_class as c on c.oid = i.indexrelid
         WHERE c.relname = '%s'
-    '''
+    """
 
     def test_text_indexes(self):
         """Test creation of PostgreSQL-specific text indexes (#12234)"""
         from .models import IndexedArticle
-        index_sql = [str(statement) for statement in connection.schema_editor()._model_indexes_sql(IndexedArticle)]
+
+        index_sql = [
+            str(statement)
+            for statement in connection.schema_editor()._model_indexes_sql(
+                IndexedArticle
+            )
+        ]
         self.assertEqual(len(index_sql), 5)
         self.assertIn('("headline" varchar_pattern_ops)', index_sql[1])
         self.assertIn('("body" text_pattern_ops)', index_sql[3])
@@ -154,112 +172,119 @@ class SchemaIndexesPostgreSQLTests(TransactionTestCase):
 
     def test_ops_class(self):
         index = Index(
-            name='test_ops_class',
-            fields=['headline'],
-            opclasses=['varchar_pattern_ops'],
+            name="test_ops_class",
+            fields=["headline"],
+            opclasses=["varchar_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
-            cursor.execute(self.get_opclass_query % 'test_ops_class')
-            self.assertEqual(cursor.fetchall(), [('varchar_pattern_ops', 'test_ops_class')])
+            cursor.execute(self.get_opclass_query % "test_ops_class")
+            self.assertEqual(
+                cursor.fetchall(), [("varchar_pattern_ops", "test_ops_class")]
+            )
 
     def test_ops_class_multiple_columns(self):
         index = Index(
-            name='test_ops_class_multiple',
-            fields=['headline', 'body'],
-            opclasses=['varchar_pattern_ops', 'text_pattern_ops'],
+            name="test_ops_class_multiple",
+            fields=["headline", "body"],
+            opclasses=["varchar_pattern_ops", "text_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
-            cursor.execute(self.get_opclass_query % 'test_ops_class_multiple')
+            cursor.execute(self.get_opclass_query % "test_ops_class_multiple")
             expected_ops_classes = (
-                ('varchar_pattern_ops', 'test_ops_class_multiple'),
-                ('text_pattern_ops', 'test_ops_class_multiple'),
+                ("varchar_pattern_ops", "test_ops_class_multiple"),
+                ("text_pattern_ops", "test_ops_class_multiple"),
             )
             self.assertCountEqual(cursor.fetchall(), expected_ops_classes)
 
     def test_ops_class_partial(self):
         index = Index(
-            name='test_ops_class_partial',
-            fields=['body'],
-            opclasses=['text_pattern_ops'],
-            condition=Q(headline__contains='China'),
+            name="test_ops_class_partial",
+            fields=["body"],
+            opclasses=["text_pattern_ops"],
+            condition=Q(headline__contains="China"),
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
-            cursor.execute(self.get_opclass_query % 'test_ops_class_partial')
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', 'test_ops_class_partial')])
+            cursor.execute(self.get_opclass_query % "test_ops_class_partial")
+            self.assertCountEqual(
+                cursor.fetchall(), [("text_pattern_ops", "test_ops_class_partial")]
+            )
 
     def test_ops_class_partial_tablespace(self):
-        indexname = 'test_ops_class_tblspace'
+        indexname = "test_ops_class_tblspace"
         index = Index(
             name=indexname,
-            fields=['body'],
-            opclasses=['text_pattern_ops'],
-            condition=Q(headline__contains='China'),
-            db_tablespace='pg_default',
+            fields=["body"],
+            opclasses=["text_pattern_ops"],
+            condition=Q(headline__contains="China"),
+            db_tablespace="pg_default",
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
-            self.assertIn('TABLESPACE "pg_default" ', str(index.create_sql(IndexedArticle2, editor)))
+            self.assertIn(
+                'TABLESPACE "pg_default" ',
+                str(index.create_sql(IndexedArticle2, editor)),
+            )
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query % indexname)
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', indexname)])
+            self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)])
 
     def test_ops_class_descending(self):
-        indexname = 'test_ops_class_ordered'
+        indexname = "test_ops_class_ordered"
         index = Index(
             name=indexname,
-            fields=['-body'],
-            opclasses=['text_pattern_ops'],
+            fields=["-body"],
+            opclasses=["text_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query % indexname)
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', indexname)])
+            self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)])
 
     def test_ops_class_descending_partial(self):
-        indexname = 'test_ops_class_ordered_partial'
+        indexname = "test_ops_class_ordered_partial"
         index = Index(
             name=indexname,
-            fields=['-body'],
-            opclasses=['text_pattern_ops'],
-            condition=Q(headline__contains='China'),
+            fields=["-body"],
+            opclasses=["text_pattern_ops"],
+            condition=Q(headline__contains="China"),
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query % indexname)
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', indexname)])
+            self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)])
 
-    @skipUnlessDBFeature('supports_covering_indexes')
+    @skipUnlessDBFeature("supports_covering_indexes")
     def test_ops_class_include(self):
-        index_name = 'test_ops_class_include'
+        index_name = "test_ops_class_include"
         index = Index(
             name=index_name,
-            fields=['body'],
-            opclasses=['text_pattern_ops'],
-            include=['headline'],
+            fields=["body"],
+            opclasses=["text_pattern_ops"],
+            include=["headline"],
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query % index_name)
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
+            self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
 
-    @skipUnlessDBFeature('supports_covering_indexes')
+    @skipUnlessDBFeature("supports_covering_indexes")
     def test_ops_class_include_tablespace(self):
-        index_name = 'test_ops_class_include_tblspace'
+        index_name = "test_ops_class_include_tblspace"
         index = Index(
             name=index_name,
-            fields=['body'],
-            opclasses=['text_pattern_ops'],
-            include=['headline'],
-            db_tablespace='pg_default',
+            fields=["body"],
+            opclasses=["text_pattern_ops"],
+            include=["headline"],
+            db_tablespace="pg_default",
         )
         with connection.schema_editor() as editor:
             editor.add_index(IndexedArticle2, index)
@@ -269,36 +294,36 @@ class SchemaIndexesPostgreSQLTests(TransactionTestCase):
             )
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query % index_name)
-            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
+            self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
 
     def test_ops_class_columns_lists_sql(self):
         index = Index(
-            fields=['headline'],
-            name='whitespace_idx',
-            opclasses=['text_pattern_ops'],
+            fields=["headline"],
+            name="whitespace_idx",
+            opclasses=["text_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             self.assertIn(
-                '(%s text_pattern_ops)' % editor.quote_name('headline'),
+                "(%s text_pattern_ops)" % editor.quote_name("headline"),
                 str(index.create_sql(Article, editor)),
             )
 
     def test_ops_class_descending_columns_list_sql(self):
         index = Index(
-            fields=['-headline'],
-            name='whitespace_idx',
-            opclasses=['text_pattern_ops'],
+            fields=["-headline"],
+            name="whitespace_idx",
+            opclasses=["text_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             self.assertIn(
-                '(%s text_pattern_ops DESC)' % editor.quote_name('headline'),
+                "(%s text_pattern_ops DESC)" % editor.quote_name("headline"),
                 str(index.create_sql(Article, editor)),
             )
 
 
-@skipUnless(connection.vendor == 'mysql', 'MySQL tests')
+@skipUnless(connection.vendor == "mysql", "MySQL tests")
 class SchemaIndexesMySQLTests(TransactionTestCase):
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_no_index_for_foreignkey(self):
         """
@@ -307,15 +332,24 @@ class SchemaIndexesMySQLTests(TransactionTestCase):
         """
         with connection.cursor() as cursor:
             storage = connection.introspection.get_storage_engine(
-                cursor, ArticleTranslation._meta.db_table,
+                cursor,
+                ArticleTranslation._meta.db_table,
             )
         if storage != "InnoDB":
             self.skip("This test only applies to the InnoDB storage engine")
-        index_sql = [str(statement) for statement in connection.schema_editor()._model_indexes_sql(ArticleTranslation)]
-        self.assertEqual(index_sql, [
-            'CREATE INDEX `indexes_articletranslation_article_no_constraint_id_d6c0806b` '
-            'ON `indexes_articletranslation` (`article_no_constraint_id`)'
-        ])
+        index_sql = [
+            str(statement)
+            for statement in connection.schema_editor()._model_indexes_sql(
+                ArticleTranslation
+            )
+        ]
+        self.assertEqual(
+            index_sql,
+            [
+                "CREATE INDEX `indexes_articletranslation_article_no_constraint_id_d6c0806b` "
+                "ON `indexes_articletranslation` (`article_no_constraint_id`)"
+            ],
+        )
 
         # The index also shouldn't be created if the ForeignKey is added after
         # the model was created.
@@ -323,7 +357,7 @@ class SchemaIndexesMySQLTests(TransactionTestCase):
         try:
             with connection.schema_editor() as editor:
                 new_field = ForeignKey(Article, CASCADE)
-                new_field.set_attributes_from_name('new_foreign_key')
+                new_field.set_attributes_from_name("new_foreign_key")
                 editor.add_field(ArticleTranslation, new_field)
                 field_created = True
                 # No deferred SQL. The FK constraint is included in the
@@ -335,129 +369,151 @@ class SchemaIndexesMySQLTests(TransactionTestCase):
                     editor.remove_field(ArticleTranslation, new_field)
 
 
-@skipUnlessDBFeature('supports_partial_indexes')
+@skipUnlessDBFeature("supports_partial_indexes")
 # SQLite doesn't support timezone-aware datetimes when USE_TZ is False.
 @override_settings(USE_TZ=True)
 class PartialIndexTests(TransactionTestCase):
     # Schema editor is used to create the index to test that it works.
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_partial_index(self):
         with connection.schema_editor() as editor:
             index = Index(
-                name='recent_article_idx',
-                fields=['pub_date'],
+                name="recent_article_idx",
+                fields=["pub_date"],
                 condition=Q(
                     pub_date__gt=datetime.datetime(
-                        year=2015, month=1, day=1,
+                        year=2015,
+                        month=1,
+                        day=1,
                         # PostgreSQL would otherwise complain about the lookup
                         # being converted to a mutable function (by removing
                         # the timezone in the cast) which is forbidden.
                         tzinfo=timezone.get_current_timezone(),
                     ),
-                )
+                ),
             )
             self.assertIn(
-                'WHERE %s' % editor.quote_name('pub_date'),
-                str(index.create_sql(Article, schema_editor=editor))
+                "WHERE %s" % editor.quote_name("pub_date"),
+                str(index.create_sql(Article, schema_editor=editor)),
             )
             editor.add_index(index=index, model=Article)
             with connection.cursor() as cursor:
-                self.assertIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
             editor.remove_index(index=index, model=Article)
 
     def test_integer_restriction_partial(self):
         with connection.schema_editor() as editor:
             index = Index(
-                name='recent_article_idx',
-                fields=['id'],
+                name="recent_article_idx",
+                fields=["id"],
                 condition=Q(pk__gt=1),
             )
             self.assertIn(
-                'WHERE %s' % editor.quote_name('id'),
-                str(index.create_sql(Article, schema_editor=editor))
+                "WHERE %s" % editor.quote_name("id"),
+                str(index.create_sql(Article, schema_editor=editor)),
             )
             editor.add_index(index=index, model=Article)
             with connection.cursor() as cursor:
-                self.assertIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
             editor.remove_index(index=index, model=Article)
 
     def test_boolean_restriction_partial(self):
         with connection.schema_editor() as editor:
             index = Index(
-                name='published_index',
-                fields=['published'],
+                name="published_index",
+                fields=["published"],
                 condition=Q(published=True),
             )
             self.assertIn(
-                'WHERE %s' % editor.quote_name('published'),
-                str(index.create_sql(Article, schema_editor=editor))
+                "WHERE %s" % editor.quote_name("published"),
+                str(index.create_sql(Article, schema_editor=editor)),
             )
             editor.add_index(index=index, model=Article)
             with connection.cursor() as cursor:
-                self.assertIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
             editor.remove_index(index=index, model=Article)
 
-    @skipUnlessDBFeature('supports_functions_in_partial_indexes')
+    @skipUnlessDBFeature("supports_functions_in_partial_indexes")
     def test_multiple_conditions(self):
         with connection.schema_editor() as editor:
             index = Index(
-                name='recent_article_idx',
-                fields=['pub_date', 'headline'],
+                name="recent_article_idx",
+                fields=["pub_date", "headline"],
                 condition=(
-                    Q(pub_date__gt=datetime.datetime(
-                        year=2015,
-                        month=1,
-                        day=1,
-                        tzinfo=timezone.get_current_timezone(),
-                    )) & Q(headline__contains='China')
+                    Q(
+                        pub_date__gt=datetime.datetime(
+                            year=2015,
+                            month=1,
+                            day=1,
+                            tzinfo=timezone.get_current_timezone(),
+                        )
+                    )
+                    & Q(headline__contains="China")
                 ),
             )
             sql = str(index.create_sql(Article, schema_editor=editor))
-            where = sql.find('WHERE')
-            self.assertIn(
-                'WHERE (%s' % editor.quote_name('pub_date'),
-                sql
-            )
+            where = sql.find("WHERE")
+            self.assertIn("WHERE (%s" % editor.quote_name("pub_date"), sql)
             # Because each backend has different syntax for the operators,
             # check ONLY the occurrence of headline in the SQL.
-            self.assertGreater(sql.rfind('headline'), where)
+            self.assertGreater(sql.rfind("headline"), where)
             editor.add_index(index=index, model=Article)
             with connection.cursor() as cursor:
-                self.assertIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
             editor.remove_index(index=index, model=Article)
 
     def test_is_null_condition(self):
         with connection.schema_editor() as editor:
             index = Index(
-                name='recent_article_idx',
-                fields=['pub_date'],
+                name="recent_article_idx",
+                fields=["pub_date"],
                 condition=Q(pub_date__isnull=False),
             )
             self.assertIn(
-                'WHERE %s IS NOT NULL' % editor.quote_name('pub_date'),
-                str(index.create_sql(Article, schema_editor=editor))
+                "WHERE %s IS NOT NULL" % editor.quote_name("pub_date"),
+                str(index.create_sql(Article, schema_editor=editor)),
             )
             editor.add_index(index=index, model=Article)
             with connection.cursor() as cursor:
-                self.assertIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
             editor.remove_index(index=index, model=Article)
 
-    @skipUnlessDBFeature('supports_expression_indexes')
+    @skipUnlessDBFeature("supports_expression_indexes")
     def test_partial_func_index(self):
-        index_name = 'partial_func_idx'
+        index_name = "partial_func_idx"
         index = Index(
-            Lower('headline').desc(),
+            Lower("headline").desc(),
             name=index_name,
             condition=Q(pub_date__isnull=False),
         )
@@ -465,136 +521,158 @@ class PartialIndexTests(TransactionTestCase):
             editor.add_index(index=index, model=Article)
             sql = index.create_sql(Article, schema_editor=editor)
         table = Article._meta.db_table
-        self.assertIs(sql.references_column(table, 'headline'), True)
+        self.assertIs(sql.references_column(table, "headline"), True)
         sql = str(sql)
-        self.assertIn('LOWER(%s)' % editor.quote_name('headline'), sql)
+        self.assertIn("LOWER(%s)" % editor.quote_name("headline"), sql)
         self.assertIn(
-            'WHERE %s IS NOT NULL' % editor.quote_name('pub_date'),
+            "WHERE %s IS NOT NULL" % editor.quote_name("pub_date"),
             sql,
         )
-        self.assertGreater(sql.find('WHERE'), sql.find('LOWER'))
+        self.assertGreater(sql.find("WHERE"), sql.find("LOWER"))
         with connection.cursor() as cursor:
             constraints = connection.introspection.get_constraints(
-                cursor=cursor, table_name=table,
+                cursor=cursor,
+                table_name=table,
             )
         self.assertIn(index_name, constraints)
         if connection.features.supports_index_column_ordering:
-            self.assertEqual(constraints[index_name]['orders'], ['DESC'])
+            self.assertEqual(constraints[index_name]["orders"], ["DESC"])
         with connection.schema_editor() as editor:
             editor.remove_index(Article, index)
         with connection.cursor() as cursor:
-            self.assertNotIn(index_name, connection.introspection.get_constraints(
-                cursor=cursor, table_name=table,
-            ))
+            self.assertNotIn(
+                index_name,
+                connection.introspection.get_constraints(
+                    cursor=cursor,
+                    table_name=table,
+                ),
+            )
 
 
-@skipUnlessDBFeature('supports_covering_indexes')
+@skipUnlessDBFeature("supports_covering_indexes")
 class CoveringIndexTests(TransactionTestCase):
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_covering_index(self):
         index = Index(
-            name='covering_headline_idx',
-            fields=['headline'],
-            include=['pub_date', 'published'],
+            name="covering_headline_idx",
+            fields=["headline"],
+            include=["pub_date", "published"],
         )
         with connection.schema_editor() as editor:
             self.assertIn(
-                '(%s) INCLUDE (%s, %s)' % (
-                    editor.quote_name('headline'),
-                    editor.quote_name('pub_date'),
-                    editor.quote_name('published'),
+                "(%s) INCLUDE (%s, %s)"
+                % (
+                    editor.quote_name("headline"),
+                    editor.quote_name("pub_date"),
+                    editor.quote_name("published"),
                 ),
                 str(index.create_sql(Article, editor)),
             )
             editor.add_index(Article, index)
             with connection.cursor() as cursor:
                 constraints = connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
+                    cursor=cursor,
+                    table_name=Article._meta.db_table,
                 )
                 self.assertIn(index.name, constraints)
                 self.assertEqual(
-                    constraints[index.name]['columns'],
-                    ['headline', 'pub_date', 'published'],
+                    constraints[index.name]["columns"],
+                    ["headline", "pub_date", "published"],
                 )
             editor.remove_index(Article, index)
             with connection.cursor() as cursor:
-                self.assertNotIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertNotIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
 
     def test_covering_partial_index(self):
         index = Index(
-            name='covering_partial_headline_idx',
-            fields=['headline'],
-            include=['pub_date'],
+            name="covering_partial_headline_idx",
+            fields=["headline"],
+            include=["pub_date"],
             condition=Q(pub_date__isnull=False),
         )
         with connection.schema_editor() as editor:
             self.assertIn(
-                '(%s) INCLUDE (%s) WHERE %s ' % (
-                    editor.quote_name('headline'),
-                    editor.quote_name('pub_date'),
-                    editor.quote_name('pub_date'),
+                "(%s) INCLUDE (%s) WHERE %s "
+                % (
+                    editor.quote_name("headline"),
+                    editor.quote_name("pub_date"),
+                    editor.quote_name("pub_date"),
                 ),
                 str(index.create_sql(Article, editor)),
             )
             editor.add_index(Article, index)
             with connection.cursor() as cursor:
                 constraints = connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
+                    cursor=cursor,
+                    table_name=Article._meta.db_table,
                 )
                 self.assertIn(index.name, constraints)
                 self.assertEqual(
-                    constraints[index.name]['columns'],
-                    ['headline', 'pub_date'],
+                    constraints[index.name]["columns"],
+                    ["headline", "pub_date"],
                 )
             editor.remove_index(Article, index)
             with connection.cursor() as cursor:
-                self.assertNotIn(index.name, connection.introspection.get_constraints(
-                    cursor=cursor, table_name=Article._meta.db_table,
-                ))
+                self.assertNotIn(
+                    index.name,
+                    connection.introspection.get_constraints(
+                        cursor=cursor,
+                        table_name=Article._meta.db_table,
+                    ),
+                )
 
-    @skipUnlessDBFeature('supports_expression_indexes')
+    @skipUnlessDBFeature("supports_expression_indexes")
     def test_covering_func_index(self):
-        index_name = 'covering_func_headline_idx'
-        index = Index(Lower('headline'), name=index_name, include=['pub_date'])
+        index_name = "covering_func_headline_idx"
+        index = Index(Lower("headline"), name=index_name, include=["pub_date"])
         with connection.schema_editor() as editor:
             editor.add_index(index=index, model=Article)
             sql = index.create_sql(Article, schema_editor=editor)
         table = Article._meta.db_table
-        self.assertIs(sql.references_column(table, 'headline'), True)
+        self.assertIs(sql.references_column(table, "headline"), True)
         sql = str(sql)
-        self.assertIn('LOWER(%s)' % editor.quote_name('headline'), sql)
-        self.assertIn('INCLUDE (%s)' % editor.quote_name('pub_date'), sql)
-        self.assertGreater(sql.find('INCLUDE'), sql.find('LOWER'))
+        self.assertIn("LOWER(%s)" % editor.quote_name("headline"), sql)
+        self.assertIn("INCLUDE (%s)" % editor.quote_name("pub_date"), sql)
+        self.assertGreater(sql.find("INCLUDE"), sql.find("LOWER"))
         with connection.cursor() as cursor:
             constraints = connection.introspection.get_constraints(
-                cursor=cursor, table_name=table,
+                cursor=cursor,
+                table_name=table,
             )
         self.assertIn(index_name, constraints)
-        self.assertIn('pub_date', constraints[index_name]['columns'])
+        self.assertIn("pub_date", constraints[index_name]["columns"])
         with connection.schema_editor() as editor:
             editor.remove_index(Article, index)
         with connection.cursor() as cursor:
-            self.assertNotIn(index_name, connection.introspection.get_constraints(
-                cursor=cursor, table_name=table,
-            ))
+            self.assertNotIn(
+                index_name,
+                connection.introspection.get_constraints(
+                    cursor=cursor,
+                    table_name=table,
+                ),
+            )
 
 
-@skipIfDBFeature('supports_covering_indexes')
+@skipIfDBFeature("supports_covering_indexes")
 class CoveringIndexIgnoredTests(TransactionTestCase):
-    available_apps = ['indexes']
+    available_apps = ["indexes"]
 
     def test_covering_ignored(self):
         index = Index(
-            name='test_covering_ignored',
-            fields=['headline'],
-            include=['pub_date'],
+            name="test_covering_ignored",
+            fields=["headline"],
+            include=["pub_date"],
         )
         with connection.schema_editor() as editor:
             editor.add_index(Article, index)
         self.assertNotIn(
-            'INCLUDE (%s)' % editor.quote_name('headline'),
+            "INCLUDE (%s)" % editor.quote_name("headline"),
             str(index.create_sql(Article, editor)),
         )