Refs #33476 -- Reformatted code with Black.

2 files changed, 132 insertions, 66 deletions

diff --git a/tests/raw_query/models.py b/tests/raw_query/models.py
index f0e6c3abb2..a8ccc11147 100644
--- a/tests/raw_query/models.py
+++ b/tests/raw_query/models.py
@@ -12,8 +12,9 @@ class Author(models.Model):
         # this'll make the test suite get angry if annotations aren't
         # treated differently than fields.
         for k in kwargs:
-            assert k in [f.attname for f in self._meta.fields], \
+            assert k in [f.attname for f in self._meta.fields], (
                 "Author.__init__ got an unexpected parameter: %s" % k
+            )
 
 
 class Book(models.Model):
@@ -24,7 +25,9 @@ class Book(models.Model):
 
 
 class BookFkAsPk(models.Model):
-    book = models.ForeignKey(Book, models.CASCADE, primary_key=True, db_column="not_the_default")
+    book = models.ForeignKey(
+        Book, models.CASCADE, primary_key=True, db_column="not_the_default"
+    )
 
 
 class Coffee(models.Model):
@@ -33,7 +36,7 @@ class Coffee(models.Model):
 
 
 class MixedCaseIDColumn(models.Model):
-    id = models.AutoField(primary_key=True, db_column='MiXeD_CaSe_Id')
+    id = models.AutoField(primary_key=True, db_column="MiXeD_CaSe_Id")
 
 
 class Reviewer(models.Model):
diff --git a/tests/raw_query/tests.py b/tests/raw_query/tests.py
index fdc16823c1..24c96b5954 100644
--- a/tests/raw_query/tests.py
+++ b/tests/raw_query/tests.py
@@ -6,51 +6,80 @@ from django.db.models.query import RawQuerySet
 from django.test import TestCase, skipUnlessDBFeature
 
 from .models import (
-    Author, Book, BookFkAsPk, Coffee, FriendlyAuthor, MixedCaseIDColumn,
+    Author,
+    Book,
+    BookFkAsPk,
+    Coffee,
+    FriendlyAuthor,
+    MixedCaseIDColumn,
     Reviewer,
 )
 
 
 class RawQueryTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
-        cls.a1 = Author.objects.create(first_name='Joe', last_name='Smith', dob=date(1950, 9, 20))
-        cls.a2 = Author.objects.create(first_name='Jill', last_name='Doe', dob=date(1920, 4, 2))
-        cls.a3 = Author.objects.create(first_name='Bob', last_name='Smith', dob=date(1986, 1, 25))
-        cls.a4 = Author.objects.create(first_name='Bill', last_name='Jones', dob=date(1932, 5, 10))
+        cls.a1 = Author.objects.create(
+            first_name="Joe", last_name="Smith", dob=date(1950, 9, 20)
+        )
+        cls.a2 = Author.objects.create(
+            first_name="Jill", last_name="Doe", dob=date(1920, 4, 2)
+        )
+        cls.a3 = Author.objects.create(
+            first_name="Bob", last_name="Smith", dob=date(1986, 1, 25)
+        )
+        cls.a4 = Author.objects.create(
+            first_name="Bill", last_name="Jones", dob=date(1932, 5, 10)
+        )
         cls.b1 = Book.objects.create(
-            title='The awesome book', author=cls.a1, paperback=False,
-            opening_line='It was a bright cold day in April and the clocks were striking thirteen.',
+            title="The awesome book",
+            author=cls.a1,
+            paperback=False,
+            opening_line="It was a bright cold day in April and the clocks were striking thirteen.",
         )
         cls.b2 = Book.objects.create(
-            title='The horrible book', author=cls.a1, paperback=True,
+            title="The horrible book",
+            author=cls.a1,
+            paperback=True,
             opening_line=(
-                'On an evening in the latter part of May a middle-aged man '
-                'was walking homeward from Shaston to the village of Marlott, '
-                'in the adjoining Vale of Blakemore, or Blackmoor.'
+                "On an evening in the latter part of May a middle-aged man "
+                "was walking homeward from Shaston to the village of Marlott, "
+                "in the adjoining Vale of Blakemore, or Blackmoor."
             ),
         )
         cls.b3 = Book.objects.create(
-            title='Another awesome book', author=cls.a1, paperback=False,
-            opening_line='A squat gray building of only thirty-four stories.',
+            title="Another awesome book",
+            author=cls.a1,
+            paperback=False,
+            opening_line="A squat gray building of only thirty-four stories.",
         )
         cls.b4 = Book.objects.create(
-            title='Some other book', author=cls.a3, paperback=True,
-            opening_line='It was the day my grandmother exploded.',
+            title="Some other book",
+            author=cls.a3,
+            paperback=True,
+            opening_line="It was the day my grandmother exploded.",
         )
-        cls.c1 = Coffee.objects.create(brand='dunkin doughnuts')
-        cls.c2 = Coffee.objects.create(brand='starbucks')
+        cls.c1 = Coffee.objects.create(brand="dunkin doughnuts")
+        cls.c2 = Coffee.objects.create(brand="starbucks")
         cls.r1 = Reviewer.objects.create()
         cls.r2 = Reviewer.objects.create()
         cls.r1.reviewed.add(cls.b2, cls.b3, cls.b4)
 
-    def assertSuccessfulRawQuery(self, model, query, expected_results,
-                                 expected_annotations=(), params=[], translations=None):
+    def assertSuccessfulRawQuery(
+        self,
+        model,
+        query,
+        expected_results,
+        expected_annotations=(),
+        params=[],
+        translations=None,
+    ):
         """
         Execute the passed query against the passed model and check the output
         """
-        results = list(model.objects.raw(query, params=params, translations=translations))
+        results = list(
+            model.objects.raw(query, params=params, translations=translations)
+        )
         self.assertProcessed(model, results, expected_results, expected_annotations)
         self.assertAnnotations(results, expected_annotations)
 
@@ -67,13 +96,12 @@ class RawQueryTests(TestCase):
             for field in model._meta.fields:
                 # All values on the model are equal
                 self.assertEqual(
-                    getattr(item, field.attname),
-                    getattr(orig_item, field.attname)
+                    getattr(item, field.attname), getattr(orig_item, field.attname)
                 )
                 # This includes checking that they are the same type
                 self.assertEqual(
                     type(getattr(item, field.attname)),
-                    type(getattr(orig_item, field.attname))
+                    type(getattr(orig_item, field.attname)),
                 )
 
     def assertNoAnnotations(self, results):
@@ -93,9 +121,13 @@ class RawQueryTests(TestCase):
                 self.assertEqual(getattr(result, annotation), value)
 
     def test_rawqueryset_repr(self):
-        queryset = RawQuerySet(raw_query='SELECT * FROM raw_query_author')
-        self.assertEqual(repr(queryset), '<RawQuerySet: SELECT * FROM raw_query_author>')
-        self.assertEqual(repr(queryset.query), '<RawQuery: SELECT * FROM raw_query_author>')
+        queryset = RawQuerySet(raw_query="SELECT * FROM raw_query_author")
+        self.assertEqual(
+            repr(queryset), "<RawQuerySet: SELECT * FROM raw_query_author>"
+        )
+        self.assertEqual(
+            repr(queryset.query), "<RawQuery: SELECT * FROM raw_query_author>"
+        )
 
     def test_simple_raw_query(self):
         """
@@ -110,7 +142,7 @@ class RawQueryTests(TestCase):
         Raw queries are lazy: they aren't actually executed until they're
         iterated over.
         """
-        q = Author.objects.raw('SELECT * FROM raw_query_author')
+        q = Author.objects.raw("SELECT * FROM raw_query_author")
         self.assertIsNone(q.query.cursor)
         list(q)
         self.assertIsNotNone(q.query.cursor)
@@ -146,9 +178,9 @@ class RawQueryTests(TestCase):
         order
         """
         selects = (
-            ('dob, last_name, first_name, id'),
-            ('last_name, dob, first_name, id'),
-            ('first_name, last_name, dob, id'),
+            ("dob, last_name, first_name, id"),
+            ("last_name, dob, first_name, id"),
+            ("first_name, last_name, dob, id"),
         )
 
         for select in selects:
@@ -162,7 +194,7 @@ class RawQueryTests(TestCase):
         column names to specific model fields
         """
         query = "SELECT first_name AS first, last_name AS last, dob, id FROM raw_query_author"
-        translations = {'first': 'first_name', 'last': 'last_name'}
+        translations = {"first": "first_name", "last": "last_name"}
         authors = Author.objects.all()
         self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
 
@@ -190,14 +222,14 @@ class RawQueryTests(TestCase):
         qset = Author.objects.raw(query)
         self.assertEqual(len(qset), 2)
 
-    @skipUnlessDBFeature('supports_paramstyle_pyformat')
+    @skipUnlessDBFeature("supports_paramstyle_pyformat")
     def test_pyformat_params(self):
         """
         Test passing optional query parameters
         """
         query = "SELECT * FROM raw_query_author WHERE first_name = %(first)s"
         author = Author.objects.all()[2]
-        params = {'first': author.first_name}
+        params = {"first": author.first_name}
         qset = Author.objects.raw(query, params=params)
         results = list(qset)
         self.assertProcessed(Author, results, [author])
@@ -210,14 +242,26 @@ class RawQueryTests(TestCase):
         Test representation of raw query with parameters
         """
         query = "SELECT * FROM raw_query_author WHERE last_name = %(last)s"
-        qset = Author.objects.raw(query, {'last': 'foo'})
-        self.assertEqual(repr(qset), "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>")
-        self.assertEqual(repr(qset.query), "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>")
+        qset = Author.objects.raw(query, {"last": "foo"})
+        self.assertEqual(
+            repr(qset),
+            "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>",
+        )
+        self.assertEqual(
+            repr(qset.query),
+            "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>",
+        )
 
         query = "SELECT * FROM raw_query_author WHERE last_name = %s"
-        qset = Author.objects.raw(query, {'foo'})
-        self.assertEqual(repr(qset), "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>")
-        self.assertEqual(repr(qset.query), "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>")
+        qset = Author.objects.raw(query, {"foo"})
+        self.assertEqual(
+            repr(qset),
+            "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>",
+        )
+        self.assertEqual(
+            repr(qset.query),
+            "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>",
+        )
 
     def test_many_to_many(self):
         """
@@ -230,7 +274,7 @@ class RawQueryTests(TestCase):
     def test_extra_conversions(self):
         """Extra translations are ignored."""
         query = "SELECT * FROM raw_query_author"
-        translations = {'something': 'else'}
+        translations = {"something": "else"}
         authors = Author.objects.all()
         self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
 
@@ -243,7 +287,7 @@ class RawQueryTests(TestCase):
 
     def test_missing_fields_without_PK(self):
         query = "SELECT first_name, dob FROM raw_query_author"
-        msg = 'Raw query must include the primary key'
+        msg = "Raw query must include the primary key"
         with self.assertRaisesMessage(FieldDoesNotExist, msg):
             list(Author.objects.raw(query))
 
@@ -255,10 +299,10 @@ class RawQueryTests(TestCase):
             "GROUP BY a.id, a.first_name, a.last_name, a.dob ORDER BY a.id"
         )
         expected_annotations = (
-            ('book_count', 3),
-            ('book_count', 0),
-            ('book_count', 1),
-            ('book_count', 0),
+            ("book_count", 3),
+            ("book_count", 0),
+            ("book_count", 1),
+            ("book_count", 0),
         )
         authors = Author.objects.all()
         self.assertSuccessfulRawQuery(Author, query, authors, expected_annotations)
@@ -291,26 +335,32 @@ class RawQueryTests(TestCase):
         # Indexing on RawQuerySets
         query = "SELECT * FROM raw_query_author ORDER BY id ASC"
         third_author = Author.objects.raw(query)[2]
-        self.assertEqual(third_author.first_name, 'Bob')
+        self.assertEqual(third_author.first_name, "Bob")
 
         first_two = Author.objects.raw(query)[0:2]
         self.assertEqual(len(first_two), 2)
 
         with self.assertRaises(TypeError):
-            Author.objects.raw(query)['test']
+            Author.objects.raw(query)["test"]
 
     def test_inheritance(self):
-        f = FriendlyAuthor.objects.create(first_name="Wesley", last_name="Chun", dob=date(1962, 10, 28))
-        query = "SELECT * FROM raw_query_friendlyauthor"
-        self.assertEqual(
-            [o.pk for o in FriendlyAuthor.objects.raw(query)], [f.pk]
+        f = FriendlyAuthor.objects.create(
+            first_name="Wesley", last_name="Chun", dob=date(1962, 10, 28)
         )
+        query = "SELECT * FROM raw_query_friendlyauthor"
+        self.assertEqual([o.pk for o in FriendlyAuthor.objects.raw(query)], [f.pk])
 
     def test_query_count(self):
-        self.assertNumQueries(1, list, Author.objects.raw("SELECT * FROM raw_query_author"))
+        self.assertNumQueries(
+            1, list, Author.objects.raw("SELECT * FROM raw_query_author")
+        )
 
     def test_subquery_in_raw_sql(self):
-        list(Book.objects.raw('SELECT id FROM (SELECT * FROM raw_query_book WHERE paperback IS NOT NULL) sq'))
+        list(
+            Book.objects.raw(
+                "SELECT id FROM (SELECT * FROM raw_query_book WHERE paperback IS NOT NULL) sq"
+            )
+        )
 
     def test_db_column_name_is_used_in_raw_query(self):
         """
@@ -321,29 +371,42 @@ class RawQueryTests(TestCase):
         same.
         """
         b = BookFkAsPk.objects.create(book=self.b1)
-        self.assertEqual(list(BookFkAsPk.objects.raw('SELECT not_the_default FROM raw_query_bookfkaspk')), [b])
+        self.assertEqual(
+            list(
+                BookFkAsPk.objects.raw(
+                    "SELECT not_the_default FROM raw_query_bookfkaspk"
+                )
+            ),
+            [b],
+        )
 
     def test_decimal_parameter(self):
-        c = Coffee.objects.create(brand='starbucks', price=20.5)
-        qs = Coffee.objects.raw("SELECT * FROM raw_query_coffee WHERE price >= %s", params=[Decimal(20)])
+        c = Coffee.objects.create(brand="starbucks", price=20.5)
+        qs = Coffee.objects.raw(
+            "SELECT * FROM raw_query_coffee WHERE price >= %s", params=[Decimal(20)]
+        )
         self.assertEqual(list(qs), [c])
 
     def test_result_caching(self):
         with self.assertNumQueries(1):
-            books = Book.objects.raw('SELECT * FROM raw_query_book')
+            books = Book.objects.raw("SELECT * FROM raw_query_book")
             list(books)
             list(books)
 
     def test_iterator(self):
         with self.assertNumQueries(2):
-            books = Book.objects.raw('SELECT * FROM raw_query_book')
+            books = Book.objects.raw("SELECT * FROM raw_query_book")
             list(books.iterator())
             list(books.iterator())
 
     def test_bool(self):
-        self.assertIs(bool(Book.objects.raw('SELECT * FROM raw_query_book')), True)
-        self.assertIs(bool(Book.objects.raw('SELECT * FROM raw_query_book WHERE id = 0')), False)
+        self.assertIs(bool(Book.objects.raw("SELECT * FROM raw_query_book")), True)
+        self.assertIs(
+            bool(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), False
+        )
 
     def test_len(self):
-        self.assertEqual(len(Book.objects.raw('SELECT * FROM raw_query_book')), 4)
-        self.assertEqual(len(Book.objects.raw('SELECT * FROM raw_query_book WHERE id = 0')), 0)
+        self.assertEqual(len(Book.objects.raw("SELECT * FROM raw_query_book")), 4)
+        self.assertEqual(
+            len(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), 0
+        )