Refs #33476 -- Reformatted code with Black.

1 files changed, 278 insertions, 164 deletions

diff --git a/tests/admin_views/test_autocomplete_view.py b/tests/admin_views/test_autocomplete_view.py
index dfaba42009..febddc1547 100644
--- a/tests/admin_views/test_autocomplete_view.py
+++ b/tests/admin_views/test_autocomplete_view.py
@@ -14,8 +14,18 @@ from django.urls import reverse, reverse_lazy
 
 from .admin import AnswerAdmin, QuestionAdmin
 from .models import (
-    Answer, Author, Authorship, Bonus, Book, Employee, Manager, Parent,
-    PKChild, Question, Toy, WorkHour,
+    Answer,
+    Author,
+    Authorship,
+    Bonus,
+    Book,
+    Employee,
+    Manager,
+    Parent,
+    PKChild,
+    Question,
+    Toy,
+    WorkHour,
 )
 from .tests import AdminViewBasicTestCase
 
@@ -23,30 +33,30 @@ PAGINATOR_SIZE = AutocompleteJsonView.paginate_by
 
 
 class AuthorAdmin(admin.ModelAdmin):
-    ordering = ['id']
-    search_fields = ['id']
+    ordering = ["id"]
+    search_fields = ["id"]
 
 
 class AuthorshipInline(admin.TabularInline):
     model = Authorship
-    autocomplete_fields = ['author']
+    autocomplete_fields = ["author"]
 
 
 class BookAdmin(admin.ModelAdmin):
     inlines = [AuthorshipInline]
 
 
-site = admin.AdminSite(name='autocomplete_admin')
+site = admin.AdminSite(name="autocomplete_admin")
 site.register(Question, QuestionAdmin)
 site.register(Answer, AnswerAdmin)
 site.register(Author, AuthorAdmin)
 site.register(Book, BookAdmin)
-site.register(Employee, search_fields=['name'])
-site.register(WorkHour, autocomplete_fields=['employee'])
-site.register(Manager, search_fields=['name'])
-site.register(Bonus, autocomplete_fields=['recipient'])
-site.register(PKChild, search_fields=['name'])
-site.register(Toy, autocomplete_fields=['child'])
+site.register(Employee, search_fields=["name"])
+site.register(WorkHour, autocomplete_fields=["employee"])
+site.register(Manager, search_fields=["name"])
+site.register(Bonus, autocomplete_fields=["recipient"])
+site.register(PKChild, search_fields=["name"])
+site.register(Toy, autocomplete_fields=["child"])
 
 
 @contextmanager
@@ -63,70 +73,87 @@ def model_admin(model, model_admin, admin_site=site):
 
 
 class AutocompleteJsonViewTests(AdminViewBasicTestCase):
-    as_view_args = {'admin_site': site}
+    as_view_args = {"admin_site": site}
     opts = {
-        'app_label': Answer._meta.app_label,
-        'model_name': Answer._meta.model_name,
-        'field_name': 'question'
+        "app_label": Answer._meta.app_label,
+        "model_name": Answer._meta.model_name,
+        "field_name": "question",
     }
     factory = RequestFactory()
-    url = reverse_lazy('autocomplete_admin:autocomplete')
+    url = reverse_lazy("autocomplete_admin:autocomplete")
 
     @classmethod
     def setUpTestData(cls):
         cls.user = User.objects.create_user(
-            username='user', password='secret',
-            email='user@example.com', is_staff=True,
+            username="user",
+            password="secret",
+            email="user@example.com",
+            is_staff=True,
         )
         super().setUpTestData()
 
     def test_success(self):
-        q = Question.objects.create(question='Is this a question?')
-        request = self.factory.get(self.url, {'term': 'is', **self.opts})
+        q = Question.objects.create(question="Is this a question?")
+        request = self.factory.get(self.url, {"term": "is", **self.opts})
         request.user = self.superuser
         response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.pk), 'text': q.question}],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [{"id": str(q.pk), "text": q.question}],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_custom_to_field(self):
-        q = Question.objects.create(question='Is this a question?')
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'question_with_to_field'})
+        q = Question.objects.create(question="Is this a question?")
+        request = self.factory.get(
+            self.url,
+            {"term": "is", **self.opts, "field_name": "question_with_to_field"},
+        )
         request.user = self.superuser
         response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.uuid), 'text': q.question}],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [{"id": str(q.uuid), "text": q.question}],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_custom_to_field_permission_denied(self):
-        Question.objects.create(question='Is this a question?')
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'question_with_to_field'})
+        Question.objects.create(question="Is this a question?")
+        request = self.factory.get(
+            self.url,
+            {"term": "is", **self.opts, "field_name": "question_with_to_field"},
+        )
         request.user = self.user
         with self.assertRaises(PermissionDenied):
             AutocompleteJsonView.as_view(**self.as_view_args)(request)
 
     def test_custom_to_field_custom_pk(self):
-        q = Question.objects.create(question='Is this a question?')
+        q = Question.objects.create(question="Is this a question?")
         opts = {
-            'app_label': Question._meta.app_label,
-            'model_name': Question._meta.model_name,
-            'field_name': 'related_questions',
+            "app_label": Question._meta.app_label,
+            "model_name": Question._meta.model_name,
+            "field_name": "related_questions",
         }
-        request = self.factory.get(self.url, {'term': 'is', **opts})
+        request = self.factory.get(self.url, {"term": "is", **opts})
         request.user = self.superuser
         response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.big_id), 'text': q.question}],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [{"id": str(q.big_id), "text": q.question}],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_to_field_resolution_with_mti(self):
         """
@@ -134,59 +161,75 @@ class AutocompleteJsonViewTests(AdminViewBasicTestCase):
         MTI. Tests for single and multi-level cases.
         """
         tests = [
-            (Employee, WorkHour, 'employee'),
-            (Manager, Bonus, 'recipient'),
+            (Employee, WorkHour, "employee"),
+            (Manager, Bonus, "recipient"),
         ]
         for Target, Remote, related_name in tests:
-            with self.subTest(target_model=Target, remote_model=Remote, related_name=related_name):
-                o = Target.objects.create(name="Frida Kahlo", gender=2, code="painter", alive=False)
+            with self.subTest(
+                target_model=Target, remote_model=Remote, related_name=related_name
+            ):
+                o = Target.objects.create(
+                    name="Frida Kahlo", gender=2, code="painter", alive=False
+                )
                 opts = {
-                    'app_label': Remote._meta.app_label,
-                    'model_name': Remote._meta.model_name,
-                    'field_name': related_name,
+                    "app_label": Remote._meta.app_label,
+                    "model_name": Remote._meta.model_name,
+                    "field_name": related_name,
                 }
-                request = self.factory.get(self.url, {'term': 'frida', **opts})
+                request = self.factory.get(self.url, {"term": "frida", **opts})
                 request.user = self.superuser
                 response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
                 self.assertEqual(response.status_code, 200)
-                data = json.loads(response.content.decode('utf-8'))
-                self.assertEqual(data, {
-                    'results': [{'id': str(o.pk), 'text': o.name}],
-                    'pagination': {'more': False},
-                })
+                data = json.loads(response.content.decode("utf-8"))
+                self.assertEqual(
+                    data,
+                    {
+                        "results": [{"id": str(o.pk), "text": o.name}],
+                        "pagination": {"more": False},
+                    },
+                )
 
     def test_to_field_resolution_with_fk_pk(self):
         p = Parent.objects.create(name="Bertie")
         c = PKChild.objects.create(parent=p, name="Anna")
         opts = {
-            'app_label': Toy._meta.app_label,
-            'model_name': Toy._meta.model_name,
-            'field_name': 'child',
+            "app_label": Toy._meta.app_label,
+            "model_name": Toy._meta.model_name,
+            "field_name": "child",
         }
-        request = self.factory.get(self.url, {'term': 'anna', **opts})
+        request = self.factory.get(self.url, {"term": "anna", **opts})
         request.user = self.superuser
         response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(c.pk), 'text': c.name}],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [{"id": str(c.pk), "text": c.name}],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_field_does_not_exist(self):
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'does_not_exist'})
+        request = self.factory.get(
+            self.url, {"term": "is", **self.opts, "field_name": "does_not_exist"}
+        )
         request.user = self.superuser
         with self.assertRaises(PermissionDenied):
             AutocompleteJsonView.as_view(**self.as_view_args)(request)
 
     def test_field_no_related_field(self):
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'answer'})
+        request = self.factory.get(
+            self.url, {"term": "is", **self.opts, "field_name": "answer"}
+        )
         request.user = self.superuser
         with self.assertRaises(PermissionDenied):
             AutocompleteJsonView.as_view(**self.as_view_args)(request)
 
     def test_field_does_not_allowed(self):
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'related_questions'})
+        request = self.factory.get(
+            self.url, {"term": "is", **self.opts, "field_name": "related_questions"}
+        )
         request.user = self.superuser
         with self.assertRaises(PermissionDenied):
             AutocompleteJsonView.as_view(**self.as_view_args)(request)
@@ -194,23 +237,29 @@ class AutocompleteJsonViewTests(AdminViewBasicTestCase):
     def test_limit_choices_to(self):
         # Answer.question_with_to_field defines limit_choices_to to "those not
         # starting with 'not'".
-        q = Question.objects.create(question='Is this a question?')
-        Question.objects.create(question='Not a question.')
-        request = self.factory.get(self.url, {'term': 'is', **self.opts, 'field_name': 'question_with_to_field'})
+        q = Question.objects.create(question="Is this a question?")
+        Question.objects.create(question="Not a question.")
+        request = self.factory.get(
+            self.url,
+            {"term": "is", **self.opts, "field_name": "question_with_to_field"},
+        )
         request.user = self.superuser
         response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.uuid), 'text': q.question}],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [{"id": str(q.uuid), "text": q.question}],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_must_be_logged_in(self):
-        response = self.client.get(self.url, {'term': '', **self.opts})
+        response = self.client.get(self.url, {"term": "", **self.opts})
         self.assertEqual(response.status_code, 200)
         self.client.logout()
-        response = self.client.get(self.url, {'term': '', **self.opts})
+        response = self.client.get(self.url, {"term": "", **self.opts})
         self.assertEqual(response.status_code, 302)
 
     def test_has_view_or_change_permission_required(self):
@@ -218,16 +267,16 @@ class AutocompleteJsonViewTests(AdminViewBasicTestCase):
         Users require the change permission for the related model to the
         autocomplete view for it.
         """
-        request = self.factory.get(self.url, {'term': 'is', **self.opts})
+        request = self.factory.get(self.url, {"term": "is", **self.opts})
         request.user = self.user
         with self.assertRaises(PermissionDenied):
             AutocompleteJsonView.as_view(**self.as_view_args)(request)
-        for permission in ('view', 'change'):
+        for permission in ("view", "change"):
             with self.subTest(permission=permission):
                 self.user.user_permissions.clear()
                 p = Permission.objects.get(
                     content_type=ContentType.objects.get_for_model(Question),
-                    codename='%s_question' % permission,
+                    codename="%s_question" % permission,
                 )
                 self.user.user_permissions.add(p)
                 request.user = User.objects.get(pk=self.user.pk)
@@ -239,106 +288,134 @@ class AutocompleteJsonViewTests(AdminViewBasicTestCase):
         Searching across model relations use QuerySet.distinct() to avoid
         duplicates.
         """
-        q1 = Question.objects.create(question='question 1')
-        q2 = Question.objects.create(question='question 2')
+        q1 = Question.objects.create(question="question 1")
+        q2 = Question.objects.create(question="question 2")
         q2.related_questions.add(q1)
-        q3 = Question.objects.create(question='question 3')
+        q3 = Question.objects.create(question="question 3")
         q3.related_questions.add(q1)
-        request = self.factory.get(self.url, {'term': 'question', **self.opts})
+        request = self.factory.get(self.url, {"term": "question", **self.opts})
         request.user = self.superuser
 
         class DistinctQuestionAdmin(QuestionAdmin):
-            search_fields = ['related_questions__question', 'question']
+            search_fields = ["related_questions__question", "question"]
 
         with model_admin(Question, DistinctQuestionAdmin):
             response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(len(data['results']), 3)
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(len(data["results"]), 3)
 
     def test_missing_search_fields(self):
         class EmptySearchAdmin(QuestionAdmin):
             search_fields = []
 
         with model_admin(Question, EmptySearchAdmin):
-            msg = 'EmptySearchAdmin must have search_fields for the autocomplete_view.'
+            msg = "EmptySearchAdmin must have search_fields for the autocomplete_view."
             with self.assertRaisesMessage(Http404, msg):
-                site.autocomplete_view(self.factory.get(self.url, {'term': '', **self.opts}))
+                site.autocomplete_view(
+                    self.factory.get(self.url, {"term": "", **self.opts})
+                )
 
     def test_get_paginator(self):
         """Search results are paginated."""
+
         class PKOrderingQuestionAdmin(QuestionAdmin):
-            ordering = ['pk']
+            ordering = ["pk"]
 
-        Question.objects.bulk_create(Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10))
+        Question.objects.bulk_create(
+            Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10)
+        )
         # The first page of results.
-        request = self.factory.get(self.url, {'term': '', **self.opts})
+        request = self.factory.get(self.url, {"term": "", **self.opts})
         request.user = self.superuser
         with model_admin(Question, PKOrderingQuestionAdmin):
             response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.pk), 'text': q.question} for q in Question.objects.all()[:PAGINATOR_SIZE]],
-            'pagination': {'more': True},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [
+                    {"id": str(q.pk), "text": q.question}
+                    for q in Question.objects.all()[:PAGINATOR_SIZE]
+                ],
+                "pagination": {"more": True},
+            },
+        )
         # The second page of results.
-        request = self.factory.get(self.url, {'term': '', 'page': '2', **self.opts})
+        request = self.factory.get(self.url, {"term": "", "page": "2", **self.opts})
         request.user = self.superuser
         with model_admin(Question, PKOrderingQuestionAdmin):
             response = AutocompleteJsonView.as_view(**self.as_view_args)(request)
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [{'id': str(q.pk), 'text': q.question} for q in Question.objects.all()[PAGINATOR_SIZE:]],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [
+                    {"id": str(q.pk), "text": q.question}
+                    for q in Question.objects.all()[PAGINATOR_SIZE:]
+                ],
+                "pagination": {"more": False},
+            },
+        )
 
     def test_serialize_result(self):
         class AutocompleteJsonSerializeResultView(AutocompleteJsonView):
             def serialize_result(self, obj, to_field_name):
                 return {
                     **super().serialize_result(obj, to_field_name),
-                    'posted': str(obj.posted),
+                    "posted": str(obj.posted),
                 }
 
-        Question.objects.create(question='Question 1', posted=datetime.date(2021, 8, 9))
-        Question.objects.create(question='Question 2', posted=datetime.date(2021, 8, 7))
-        request = self.factory.get(self.url, {'term': 'question', **self.opts})
+        Question.objects.create(question="Question 1", posted=datetime.date(2021, 8, 9))
+        Question.objects.create(question="Question 2", posted=datetime.date(2021, 8, 7))
+        request = self.factory.get(self.url, {"term": "question", **self.opts})
         request.user = self.superuser
-        response = AutocompleteJsonSerializeResultView.as_view(**self.as_view_args)(request)
+        response = AutocompleteJsonSerializeResultView.as_view(**self.as_view_args)(
+            request
+        )
         self.assertEqual(response.status_code, 200)
-        data = json.loads(response.content.decode('utf-8'))
-        self.assertEqual(data, {
-            'results': [
-                {'id': str(q.pk), 'text': q.question, 'posted': str(q.posted)}
-                for q in Question.objects.order_by('-posted')
-            ],
-            'pagination': {'more': False},
-        })
+        data = json.loads(response.content.decode("utf-8"))
+        self.assertEqual(
+            data,
+            {
+                "results": [
+                    {"id": str(q.pk), "text": q.question, "posted": str(q.posted)}
+                    for q in Question.objects.order_by("-posted")
+                ],
+                "pagination": {"more": False},
+            },
+        )
 
 
-@override_settings(ROOT_URLCONF='admin_views.urls')
+@override_settings(ROOT_URLCONF="admin_views.urls")
 class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ['admin_views'] + AdminSeleniumTestCase.available_apps
+    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
-            username='super', password='secret', email='super@example.com',
+            username="super",
+            password="secret",
+            email="super@example.com",
+        )
+        self.admin_login(
+            username="super",
+            password="secret",
+            login_url=reverse("autocomplete_admin:index"),
         )
-        self.admin_login(username='super', password='secret', login_url=reverse('autocomplete_admin:index'))
 
     @contextmanager
     def select2_ajax_wait(self, timeout=10):
         from selenium.common.exceptions import NoSuchElementException
         from selenium.webdriver.common.by import By
         from selenium.webdriver.support import expected_conditions as ec
+
         yield
         with self.disable_implicit_wait():
             try:
                 loading_element = self.selenium.find_element(
-                    By.CSS_SELECTOR,
-                    'li.select2-results__option.loading-results'
+                    By.CSS_SELECTOR, "li.select2-results__option.loading-results"
                 )
             except NoSuchElementException:
                 pass
@@ -349,109 +426,146 @@ class SeleniumTests(AdminSeleniumTestCase):
         from selenium.webdriver.common.by import By
         from selenium.webdriver.common.keys import Keys
         from selenium.webdriver.support.ui import Select
-        self.selenium.get(self.live_server_url + reverse('autocomplete_admin:admin_views_answer_add'))
-        elem = self.selenium.find_element(By.CSS_SELECTOR, '.select2-selection')
+
+        self.selenium.get(
+            self.live_server_url + reverse("autocomplete_admin:admin_views_answer_add")
+        )
+        elem = self.selenium.find_element(By.CSS_SELECTOR, ".select2-selection")
         elem.click()  # Open the autocomplete dropdown.
-        results = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results')
+        results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
         self.assertTrue(results.is_displayed())
-        option = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results__option')
-        self.assertEqual(option.text, 'No results found')
+        option = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results__option")
+        self.assertEqual(option.text, "No results found")
         elem.click()  # Close the autocomplete dropdown.
-        q1 = Question.objects.create(question='Who am I?')
-        Question.objects.bulk_create(Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10))
+        q1 = Question.objects.create(question="Who am I?")
+        Question.objects.bulk_create(
+            Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10)
+        )
         elem.click()  # Reopen the dropdown now that some objects exist.
-        result_container = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results')
+        result_container = self.selenium.find_element(
+            By.CSS_SELECTOR, ".select2-results"
+        )
         self.assertTrue(result_container.is_displayed())
         # PAGINATOR_SIZE results and "Loading more results".
-        self.assertCountSeleniumElements('.select2-results__option', PAGINATOR_SIZE + 1, root_element=result_container)
-        search = self.selenium.find_element(By.CSS_SELECTOR, '.select2-search__field')
+        self.assertCountSeleniumElements(
+            ".select2-results__option",
+            PAGINATOR_SIZE + 1,
+            root_element=result_container,
+        )
+        search = self.selenium.find_element(By.CSS_SELECTOR, ".select2-search__field")
         # Load next page of results by scrolling to the bottom of the list.
         with self.select2_ajax_wait():
             for _ in range(PAGINATOR_SIZE + 1):
                 search.send_keys(Keys.ARROW_DOWN)
         # All objects are now loaded.
         self.assertCountSeleniumElements(
-            '.select2-results__option',
+            ".select2-results__option",
             PAGINATOR_SIZE + 11,
             root_element=result_container,
         )
         # Limit the results with the search field.
         with self.select2_ajax_wait():
-            search.send_keys('Who')
+            search.send_keys("Who")
             # Ajax request is delayed.
             self.assertTrue(result_container.is_displayed())
             self.assertCountSeleniumElements(
-                '.select2-results__option',
+                ".select2-results__option",
                 PAGINATOR_SIZE + 12,
                 root_element=result_container,
             )
         self.assertTrue(result_container.is_displayed())
-        self.assertCountSeleniumElements('.select2-results__option', 1, root_element=result_container)
+        self.assertCountSeleniumElements(
+            ".select2-results__option", 1, root_element=result_container
+        )
         # Select the result.
         search.send_keys(Keys.RETURN)
-        select = Select(self.selenium.find_element(By.ID, 'id_question'))
-        self.assertEqual(select.first_selected_option.get_attribute('value'), str(q1.pk))
+        select = Select(self.selenium.find_element(By.ID, "id_question"))
+        self.assertEqual(
+            select.first_selected_option.get_attribute("value"), str(q1.pk)
+        )
 
     def test_select_multiple(self):
         from selenium.webdriver.common.by import By
         from selenium.webdriver.common.keys import Keys
         from selenium.webdriver.support.ui import Select
-        self.selenium.get(self.live_server_url + reverse('autocomplete_admin:admin_views_question_add'))
-        elem = self.selenium.find_element(By.CSS_SELECTOR, '.select2-selection')
+
+        self.selenium.get(
+            self.live_server_url
+            + reverse("autocomplete_admin:admin_views_question_add")
+        )
+        elem = self.selenium.find_element(By.CSS_SELECTOR, ".select2-selection")
         elem.click()  # Open the autocomplete dropdown.
-        results = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results')
+        results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
         self.assertTrue(results.is_displayed())
-        option = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results__option')
-        self.assertEqual(option.text, 'No results found')
+        option = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results__option")
+        self.assertEqual(option.text, "No results found")
         elem.click()  # Close the autocomplete dropdown.
-        Question.objects.create(question='Who am I?')
-        Question.objects.bulk_create(Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10))
+        Question.objects.create(question="Who am I?")
+        Question.objects.bulk_create(
+            Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10)
+        )
         elem.click()  # Reopen the dropdown now that some objects exist.
-        result_container = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results')
+        result_container = self.selenium.find_element(
+            By.CSS_SELECTOR, ".select2-results"
+        )
         self.assertTrue(result_container.is_displayed())
-        self.assertCountSeleniumElements('.select2-results__option', PAGINATOR_SIZE + 1, root_element=result_container)
-        search = self.selenium.find_element(By.CSS_SELECTOR, '.select2-search__field')
+        self.assertCountSeleniumElements(
+            ".select2-results__option",
+            PAGINATOR_SIZE + 1,
+            root_element=result_container,
+        )
+        search = self.selenium.find_element(By.CSS_SELECTOR, ".select2-search__field")
         # Load next page of results by scrolling to the bottom of the list.
         with self.select2_ajax_wait():
             for _ in range(PAGINATOR_SIZE + 1):
                 search.send_keys(Keys.ARROW_DOWN)
-        self.assertCountSeleniumElements('.select2-results__option', 31, root_element=result_container)
+        self.assertCountSeleniumElements(
+            ".select2-results__option", 31, root_element=result_container
+        )
         # Limit the results with the search field.
         with self.select2_ajax_wait():
-            search.send_keys('Who')
+            search.send_keys("Who")
             # Ajax request is delayed.
             self.assertTrue(result_container.is_displayed())
-            self.assertCountSeleniumElements('.select2-results__option', 32, root_element=result_container)
+            self.assertCountSeleniumElements(
+                ".select2-results__option", 32, root_element=result_container
+            )
         self.assertTrue(result_container.is_displayed())
 
-        self.assertCountSeleniumElements('.select2-results__option', 1, root_element=result_container)
+        self.assertCountSeleniumElements(
+            ".select2-results__option", 1, root_element=result_container
+        )
         # Select the result.
         search.send_keys(Keys.RETURN)
         # Reopen the dropdown and add the first result to the selection.
         elem.click()
         search.send_keys(Keys.ARROW_DOWN)
         search.send_keys(Keys.RETURN)
-        select = Select(self.selenium.find_element(By.ID, 'id_related_questions'))
+        select = Select(self.selenium.find_element(By.ID, "id_related_questions"))
         self.assertEqual(len(select.all_selected_options), 2)
 
     def test_inline_add_another_widgets(self):
         from selenium.webdriver.common.by import By
 
         def assertNoResults(row):
-            elem = row.find_element(By.CSS_SELECTOR, '.select2-selection')
+            elem = row.find_element(By.CSS_SELECTOR, ".select2-selection")
             elem.click()  # Open the autocomplete dropdown.
-            results = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results')
+            results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
             self.assertTrue(results.is_displayed())
-            option = self.selenium.find_element(By.CSS_SELECTOR, '.select2-results__option')
-            self.assertEqual(option.text, 'No results found')
+            option = self.selenium.find_element(
+                By.CSS_SELECTOR, ".select2-results__option"
+            )
+            self.assertEqual(option.text, "No results found")
 
         # Autocomplete works in rows present when the page loads.
-        self.selenium.get(self.live_server_url + reverse('autocomplete_admin:admin_views_book_add'))
-        rows = self.selenium.find_elements(By.CSS_SELECTOR, '.dynamic-authorship_set')
+        self.selenium.get(
+            self.live_server_url + reverse("autocomplete_admin:admin_views_book_add")
+        )
+        rows = self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-authorship_set")
         self.assertEqual(len(rows), 3)
         assertNoResults(rows[0])
         # Autocomplete works in rows added using the "Add another" button.
-        self.selenium.find_element(By.LINK_TEXT, 'Add another Authorship').click()
-        rows = self.selenium.find_elements(By.CSS_SELECTOR, '.dynamic-authorship_set')
+        self.selenium.find_element(By.LINK_TEXT, "Add another Authorship").click()
+        rows = self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-authorship_set")
         self.assertEqual(len(rows), 4)
         assertNoResults(rows[-1])