[4.0.x] Refs #33476 -- Reformatted code with Black.

Backport of 9c19aff7c7561e3a82978a272ecdaad40dda5c00 from main.

1 files changed, 34 insertions, 30 deletions

diff --git a/tests/model_fields/test_foreignkey.py b/tests/model_fields/test_foreignkey.py
index 0cd6d62a55..2c15dea720 100644
--- a/tests/model_fields/test_foreignkey.py
+++ b/tests/model_fields/test_foreignkey.py
@@ -11,24 +11,25 @@ from .models import Bar, FkToChar, Foo, PrimaryKeyCharModel
 
 
 class ForeignKeyTests(TestCase):
-
     def test_callable_default(self):
         """A lazy callable may be used for ForeignKey.default."""
-        a = Foo.objects.create(id=1, a='abc', d=Decimal('12.34'))
-        b = Bar.objects.create(b='bcd')
+        a = Foo.objects.create(id=1, a="abc", d=Decimal("12.34"))
+        b = Bar.objects.create(b="bcd")
         self.assertEqual(b.a, a)
 
-    @skipIfDBFeature('interprets_empty_strings_as_nulls')
+    @skipIfDBFeature("interprets_empty_strings_as_nulls")
     def test_empty_string_fk(self):
         """
         Empty strings foreign key values don't get converted to None (#19299).
         """
-        char_model_empty = PrimaryKeyCharModel.objects.create(string='')
+        char_model_empty = PrimaryKeyCharModel.objects.create(string="")
         fk_model_empty = FkToChar.objects.create(out=char_model_empty)
-        fk_model_empty = FkToChar.objects.select_related('out').get(id=fk_model_empty.pk)
+        fk_model_empty = FkToChar.objects.select_related("out").get(
+            id=fk_model_empty.pk
+        )
         self.assertEqual(fk_model_empty.out, char_model_empty)
 
-    @isolate_apps('model_fields')
+    @isolate_apps("model_fields")
     def test_warning_when_unique_true_on_fk(self):
         class Foo(models.Model):
             pass
@@ -39,17 +40,17 @@ class ForeignKeyTests(TestCase):
         model = FKUniqueTrue()
         expected_warnings = [
             checks.Warning(
-                'Setting unique=True on a ForeignKey has the same effect as using a OneToOneField.',
-                hint='ForeignKey(unique=True) is usually better served by a OneToOneField.',
+                "Setting unique=True on a ForeignKey has the same effect as using a OneToOneField.",
+                hint="ForeignKey(unique=True) is usually better served by a OneToOneField.",
                 obj=FKUniqueTrue.fk_field.field,
-                id='fields.W342',
+                id="fields.W342",
             )
         ]
         warnings = model.check()
         self.assertEqual(warnings, expected_warnings)
 
     def test_related_name_converted_to_text(self):
-        rel_name = Bar._meta.get_field('a').remote_field.related_name
+        rel_name = Bar._meta.get_field("a").remote_field.related_name
         self.assertIsInstance(rel_name, str)
 
     def test_abstract_model_pending_operations(self):
@@ -60,7 +61,7 @@ class ForeignKeyTests(TestCase):
         pending_ops_before = list(apps._pending_operations.items())
 
         class AbstractForeignKeyModel(models.Model):
-            fk = models.ForeignKey('missing.FK', models.CASCADE)
+            fk = models.ForeignKey("missing.FK", models.CASCADE)
 
             class Meta:
                 abstract = True
@@ -69,16 +70,16 @@ class ForeignKeyTests(TestCase):
         self.assertEqual(
             pending_ops_before,
             list(apps._pending_operations.items()),
-            'Pending lookup added for a foreign key on an abstract model'
+            "Pending lookup added for a foreign key on an abstract model",
         )
 
-    @isolate_apps('model_fields', 'model_fields.tests')
+    @isolate_apps("model_fields", "model_fields.tests")
     def test_abstract_model_app_relative_foreign_key(self):
         class AbstractReferent(models.Model):
-            reference = models.ForeignKey('Referred', on_delete=models.CASCADE)
+            reference = models.ForeignKey("Referred", on_delete=models.CASCADE)
 
             class Meta:
-                app_label = 'model_fields'
+                app_label = "model_fields"
                 abstract = True
 
         def assert_app_model_resolved(label):
@@ -90,12 +91,14 @@ class ForeignKeyTests(TestCase):
                 class Meta:
                     app_label = label
 
-            self.assertEqual(ConcreteReferent._meta.get_field('reference').related_model, Referred)
+            self.assertEqual(
+                ConcreteReferent._meta.get_field("reference").related_model, Referred
+            )
 
-        assert_app_model_resolved('model_fields')
-        assert_app_model_resolved('tests')
+        assert_app_model_resolved("model_fields")
+        assert_app_model_resolved("tests")
 
-    @isolate_apps('model_fields')
+    @isolate_apps("model_fields")
     def test_to_python(self):
         class Foo(models.Model):
             pass
@@ -103,9 +106,9 @@ class ForeignKeyTests(TestCase):
         class Bar(models.Model):
             fk = models.ForeignKey(Foo, models.CASCADE)
 
-        self.assertEqual(Bar._meta.get_field('fk').to_python('1'), 1)
+        self.assertEqual(Bar._meta.get_field("fk").to_python("1"), 1)
 
-    @isolate_apps('model_fields')
+    @isolate_apps("model_fields")
     def test_fk_to_fk_get_col_output_field(self):
         class Foo(models.Model):
             pass
@@ -116,21 +119,21 @@ class ForeignKeyTests(TestCase):
         class Baz(models.Model):
             bar = models.ForeignKey(Bar, models.CASCADE, primary_key=True)
 
-        col = Baz._meta.get_field('bar').get_col('alias')
+        col = Baz._meta.get_field("bar").get_col("alias")
         self.assertIs(col.output_field, Foo._meta.pk)
 
-    @isolate_apps('model_fields')
+    @isolate_apps("model_fields")
     def test_recursive_fks_get_col(self):
         class Foo(models.Model):
-            bar = models.ForeignKey('Bar', models.CASCADE, primary_key=True)
+            bar = models.ForeignKey("Bar", models.CASCADE, primary_key=True)
 
         class Bar(models.Model):
             foo = models.ForeignKey(Foo, models.CASCADE, primary_key=True)
 
-        with self.assertRaisesMessage(ValueError, 'Cannot resolve output_field'):
-            Foo._meta.get_field('bar').get_col('alias')
+        with self.assertRaisesMessage(ValueError, "Cannot resolve output_field"):
+            Foo._meta.get_field("bar").get_col("alias")
 
-    @isolate_apps('model_fields')
+    @isolate_apps("model_fields")
     def test_non_local_to_field(self):
         class Parent(models.Model):
             key = models.IntegerField(unique=True)
@@ -139,14 +142,14 @@ class ForeignKeyTests(TestCase):
             pass
 
         class Related(models.Model):
-            child = models.ForeignKey(Child, on_delete=models.CASCADE, to_field='key')
+            child = models.ForeignKey(Child, on_delete=models.CASCADE, to_field="key")
 
         msg = (
             "'model_fields.Related.child' refers to field 'key' which is not "
             "local to model 'model_fields.Child'."
         )
         with self.assertRaisesMessage(FieldError, msg):
-            Related._meta.get_field('child').related_fields
+            Related._meta.get_field("child").related_fields
 
     def test_invalid_to_parameter(self):
         msg = (
@@ -154,5 +157,6 @@ class ForeignKeyTests(TestCase):
             "either a model, a model name, or the string 'self'"
         )
         with self.assertRaisesMessage(TypeError, msg):
+
             class MyModel(models.Model):
                 child = models.ForeignKey(1, models.CASCADE)