Refs #33476 -- Reformatted code with Black.

4 files changed, 168 insertions, 108 deletions

diff --git a/tests/proxy_models/admin.py b/tests/proxy_models/admin.py
index ba67f7829f..0adcac3687 100644
--- a/tests/proxy_models/admin.py
+++ b/tests/proxy_models/admin.py
@@ -2,6 +2,6 @@ from django.contrib import admin
 
 from .models import ProxyTrackerUser, TrackerUser
 
-site = admin.AdminSite(name='admin_proxy')
+site = admin.AdminSite(name="admin_proxy")
 site.register(TrackerUser)
 site.register(ProxyTrackerUser)
diff --git a/tests/proxy_models/models.py b/tests/proxy_models/models.py
index 5e6fdd2b93..604136b5ac 100644
--- a/tests/proxy_models/models.py
+++ b/tests/proxy_models/models.py
@@ -23,6 +23,7 @@ class Person(models.Model):
     """
     A simple concrete base class.
     """
+
     name = models.CharField(max_length=50)
 
     objects = PersonManager()
@@ -35,6 +36,7 @@ class Abstract(models.Model):
     """
     A simple abstract base class, to be used for error checking.
     """
+
     data = models.CharField(max_length=10)
 
     class Meta:
@@ -46,12 +48,11 @@ class MyPerson(Person):
     A proxy subclass, this should not get a new table. Overrides the default
     manager.
     """
+
     class Meta:
         proxy = True
         ordering = ["name"]
-        permissions = (
-            ("display_users", "May display users information"),
-        )
+        permissions = (("display_users", "May display users information"),)
 
     objects = SubManager()
     other = PersonManager()
@@ -71,6 +72,7 @@ class OtherPerson(Person, ManagerMixin):
     """
     A class with the default manager from Person, plus a secondary manager.
     """
+
     class Meta:
         proxy = True
         ordering = ["name"]
@@ -80,10 +82,12 @@ class StatusPerson(MyPerson):
     """
     A non-proxy subclass of a proxy, it should get a new table.
     """
+
     status = models.CharField(max_length=80)
 
     objects = models.Manager()
 
+
 # We can even have proxies of proxies (and subclass of those).
 
 
@@ -124,6 +128,7 @@ class MultiUserProxy(UserProxy, AnotherUserProxy):
     class Meta:
         proxy = True
 
+
 # We can still use `select_related()` to include related models in our querysets.
 
 
@@ -143,6 +148,7 @@ class StateProxy(State):
     class Meta:
         proxy = True
 
+
 # Proxy models still works with filters (on related fields)
 # and select_related, even when mixed with model inheritance
 
@@ -151,7 +157,12 @@ class BaseUser(models.Model):
     name = models.CharField(max_length=255)
 
     def __str__(self):
-        return ':'.join((self.__class__.__name__, self.name,))
+        return ":".join(
+            (
+                self.__class__.__name__,
+                self.name,
+            )
+        )
 
 
 class TrackerUser(BaseUser):
@@ -165,10 +176,17 @@ class ProxyTrackerUser(TrackerUser):
 
 class Issue(models.Model):
     summary = models.CharField(max_length=255)
-    assignee = models.ForeignKey(ProxyTrackerUser, models.CASCADE, related_name='issues')
+    assignee = models.ForeignKey(
+        ProxyTrackerUser, models.CASCADE, related_name="issues"
+    )
 
     def __str__(self):
-        return ':'.join((self.__class__.__name__, self.summary,))
+        return ":".join(
+            (
+                self.__class__.__name__,
+                self.summary,
+            )
+        )
 
 
 class Bug(Issue):
@@ -180,6 +198,7 @@ class ProxyBug(Bug):
     """
     Proxy of an inherited class
     """
+
     class Meta:
         proxy = True
 
@@ -188,6 +207,7 @@ class ProxyProxyBug(ProxyBug):
     """
     A proxy of proxy model with related field
     """
+
     class Meta:
         proxy = True
 
@@ -197,6 +217,7 @@ class Improvement(Issue):
     A model that has relation to a proxy model
     or to a proxy of proxy model
     """
+
     version = models.CharField(max_length=50)
     reporter = models.ForeignKey(ProxyTrackerUser, models.CASCADE)
     associated_bug = models.ForeignKey(ProxyProxyBug, models.CASCADE)
diff --git a/tests/proxy_models/tests.py b/tests/proxy_models/tests.py
index 50d2c57dd4..f7c4a30496 100644
--- a/tests/proxy_models/tests.py
+++ b/tests/proxy_models/tests.py
@@ -10,10 +10,29 @@ from django.urls import reverse
 
 from .admin import admin as force_admin_model_registration  # NOQA
 from .models import (
-    Abstract, BaseUser, Bug, Country, Improvement, Issue, LowerStatusPerson,
-    MultiUserProxy, MyPerson, MyPersonProxy, OtherPerson, Person, ProxyBug,
-    ProxyImprovement, ProxyProxyBug, ProxyTrackerUser, State, StateProxy,
-    StatusPerson, TrackerUser, User, UserProxy, UserProxyProxy,
+    Abstract,
+    BaseUser,
+    Bug,
+    Country,
+    Improvement,
+    Issue,
+    LowerStatusPerson,
+    MultiUserProxy,
+    MyPerson,
+    MyPersonProxy,
+    OtherPerson,
+    Person,
+    ProxyBug,
+    ProxyImprovement,
+    ProxyProxyBug,
+    ProxyTrackerUser,
+    State,
+    StateProxy,
+    StatusPerson,
+    TrackerUser,
+    User,
+    UserProxy,
+    UserProxyProxy,
 )
 
 
@@ -23,10 +42,14 @@ class ProxyModelTests(TestCase):
         The MyPerson model should be generating the same database queries as
         the Person model (when the same manager is used in each case).
         """
-        my_person_sql = MyPerson.other.all().query.get_compiler(
-            DEFAULT_DB_ALIAS).as_sql()
-        person_sql = Person.objects.order_by("name").query.get_compiler(
-            DEFAULT_DB_ALIAS).as_sql()
+        my_person_sql = (
+            MyPerson.other.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+        )
+        person_sql = (
+            Person.objects.order_by("name")
+            .query.get_compiler(DEFAULT_DB_ALIAS)
+            .as_sql()
+        )
         self.assertEqual(my_person_sql, person_sql)
 
     def test_inheritance_new_table(self):
@@ -34,10 +57,10 @@ class ProxyModelTests(TestCase):
         The StatusPerson models should have its own table (it's using ORM-level
         inheritance).
         """
-        sp_sql = StatusPerson.objects.all().query.get_compiler(
-            DEFAULT_DB_ALIAS).as_sql()
-        p_sql = Person.objects.all().query.get_compiler(
-            DEFAULT_DB_ALIAS).as_sql()
+        sp_sql = (
+            StatusPerson.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+        )
+        p_sql = Person.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
         self.assertNotEqual(sp_sql, p_sql)
 
     def test_basic_proxy(self):
@@ -77,7 +100,7 @@ class ProxyModelTests(TestCase):
         MyPerson.objects.create(name="Bazza del Frob")
         LowerStatusPerson.objects.create(status="low", name="homer")
         pp = sorted(mpp.name for mpp in MyPersonProxy.objects.all())
-        self.assertEqual(pp, ['Bazza del Frob', 'Foo McBar', 'homer'])
+        self.assertEqual(pp, ["Bazza del Frob", "Foo McBar", "homer"])
 
     def test_proxy_included_in_ancestors(self):
         """
@@ -87,18 +110,18 @@ class ProxyModelTests(TestCase):
         Person.objects.create(name="Foo McBar")
         MyPerson.objects.create(name="Bazza del Frob")
         LowerStatusPerson.objects.create(status="low", name="homer")
-        max_id = Person.objects.aggregate(max_id=models.Max('id'))['max_id']
+        max_id = Person.objects.aggregate(max_id=models.Max("id"))["max_id"]
 
         with self.assertRaises(Person.DoesNotExist):
-            MyPersonProxy.objects.get(name='Zathras')
+            MyPersonProxy.objects.get(name="Zathras")
         with self.assertRaises(Person.MultipleObjectsReturned):
             MyPersonProxy.objects.get(id__lt=max_id + 1)
         with self.assertRaises(Person.DoesNotExist):
-            StatusPerson.objects.get(name='Zathras')
+            StatusPerson.objects.get(name="Zathras")
 
-        StatusPerson.objects.create(name='Bazza Jr.')
-        StatusPerson.objects.create(name='Foo Jr.')
-        max_id = Person.objects.aggregate(max_id=models.Max('id'))['max_id']
+        StatusPerson.objects.create(name="Bazza Jr.")
+        StatusPerson.objects.create(name="Foo Jr.")
+        max_id = Person.objects.aggregate(max_id=models.Max("id"))["max_id"]
 
         with self.assertRaises(Person.MultipleObjectsReturned):
             StatusPerson.objects.get(id__lt=max_id + 1)
@@ -106,6 +129,7 @@ class ProxyModelTests(TestCase):
     def test_abstract_base_with_model_fields(self):
         msg = "Abstract base class containing model fields not permitted for proxy model 'NoAbstract'."
         with self.assertRaisesMessage(TypeError, msg):
+
             class NoAbstract(Abstract):
                 class Meta:
                     proxy = True
@@ -113,6 +137,7 @@ class ProxyModelTests(TestCase):
     def test_too_many_concrete_classes(self):
         msg = "Proxy model 'TooManyBases' has more than one non-abstract model base class."
         with self.assertRaisesMessage(TypeError, msg):
+
             class TooManyBases(User, Person):
                 class Meta:
                     proxy = True
@@ -120,11 +145,12 @@ class ProxyModelTests(TestCase):
     def test_no_base_classes(self):
         msg = "Proxy model 'NoBaseClasses' has no non-abstract model base class."
         with self.assertRaisesMessage(TypeError, msg):
+
             class NoBaseClasses(models.Model):
                 class Meta:
                     proxy = True
 
-    @isolate_apps('proxy_models')
+    @isolate_apps("proxy_models")
     def test_new_fields(self):
         class NoNewFields(Person):
             newfield = models.BooleanField()
@@ -136,26 +162,25 @@ class ProxyModelTests(TestCase):
         expected = [
             checks.Error(
                 "Proxy model 'NoNewFields' contains model fields.",
-                id='models.E017',
+                id="models.E017",
             )
         ]
         self.assertEqual(errors, expected)
 
-    @override_settings(TEST_SWAPPABLE_MODEL='proxy_models.AlternateModel')
-    @isolate_apps('proxy_models')
+    @override_settings(TEST_SWAPPABLE_MODEL="proxy_models.AlternateModel")
+    @isolate_apps("proxy_models")
     def test_swappable(self):
         class SwappableModel(models.Model):
-
             class Meta:
-                swappable = 'TEST_SWAPPABLE_MODEL'
+                swappable = "TEST_SWAPPABLE_MODEL"
 
         class AlternateModel(models.Model):
             pass
 
         # You can't proxy a swapped model
         with self.assertRaises(TypeError):
-            class ProxyModel(SwappableModel):
 
+            class ProxyModel(SwappableModel):
                 class Meta:
                     proxy = True
 
@@ -165,10 +190,10 @@ class ProxyModelTests(TestCase):
         Person.objects.create(name="barney")
 
         resp = [p.name for p in MyPerson.objects.all()]
-        self.assertEqual(resp, ['barney', 'fred'])
+        self.assertEqual(resp, ["barney", "fred"])
 
         resp = [p.name for p in MyPerson._default_manager.all()]
-        self.assertEqual(resp, ['barney', 'fred'])
+        self.assertEqual(resp, ["barney", "fred"])
 
     def test_otherperson_manager(self):
         Person.objects.create(name="fred")
@@ -176,16 +201,17 @@ class ProxyModelTests(TestCase):
         Person.objects.create(name="barney")
 
         resp = [p.name for p in OtherPerson.objects.all()]
-        self.assertEqual(resp, ['barney', 'wilma'])
+        self.assertEqual(resp, ["barney", "wilma"])
 
         resp = [p.name for p in OtherPerson.excluder.all()]
-        self.assertEqual(resp, ['barney', 'fred'])
+        self.assertEqual(resp, ["barney", "fred"])
 
         resp = [p.name for p in OtherPerson._default_manager.all()]
-        self.assertEqual(resp, ['barney', 'wilma'])
+        self.assertEqual(resp, ["barney", "wilma"])
 
     def test_permissions_created(self):
         from django.contrib.auth.models import Permission
+
         Permission.objects.get(name="May display users information")
 
     def test_proxy_model_signals(self):
@@ -196,13 +222,14 @@ class ProxyModelTests(TestCase):
 
         def make_handler(model, event):
             def _handler(*args, **kwargs):
-                output.append('%s %s save' % (model, event))
+                output.append("%s %s save" % (model, event))
+
             return _handler
 
-        h1 = make_handler('MyPerson', 'pre')
-        h2 = make_handler('MyPerson', 'post')
-        h3 = make_handler('Person', 'pre')
-        h4 = make_handler('Person', 'post')
+        h1 = make_handler("MyPerson", "pre")
+        h2 = make_handler("MyPerson", "post")
+        h3 = make_handler("Person", "pre")
+        h4 = make_handler("Person", "post")
 
         signals.pre_save.connect(h1, sender=MyPerson)
         signals.post_save.connect(h2, sender=MyPerson)
@@ -210,25 +237,19 @@ class ProxyModelTests(TestCase):
         signals.post_save.connect(h4, sender=Person)
 
         MyPerson.objects.create(name="dino")
-        self.assertEqual(output, [
-            'MyPerson pre save',
-            'MyPerson post save'
-        ])
+        self.assertEqual(output, ["MyPerson pre save", "MyPerson post save"])
 
         output = []
 
-        h5 = make_handler('MyPersonProxy', 'pre')
-        h6 = make_handler('MyPersonProxy', 'post')
+        h5 = make_handler("MyPersonProxy", "pre")
+        h6 = make_handler("MyPersonProxy", "post")
 
         signals.pre_save.connect(h5, sender=MyPersonProxy)
         signals.post_save.connect(h6, sender=MyPersonProxy)
 
         MyPersonProxy.objects.create(name="pebbles")
 
-        self.assertEqual(output, [
-            'MyPersonProxy pre save',
-            'MyPersonProxy post save'
-        ])
+        self.assertEqual(output, ["MyPersonProxy pre save", "MyPersonProxy post save"])
 
         signals.pre_save.disconnect(h1, sender=MyPerson)
         signals.post_save.disconnect(h2, sender=MyPerson)
@@ -242,18 +263,18 @@ class ProxyModelTests(TestCase):
         self.assertIs(ctype(Person), ctype(OtherPerson))
 
     def test_user_proxy_models(self):
-        User.objects.create(name='Bruce')
+        User.objects.create(name="Bruce")
 
         resp = [u.name for u in User.objects.all()]
-        self.assertEqual(resp, ['Bruce'])
+        self.assertEqual(resp, ["Bruce"])
 
         resp = [u.name for u in UserProxy.objects.all()]
-        self.assertEqual(resp, ['Bruce'])
+        self.assertEqual(resp, ["Bruce"])
 
         resp = [u.name for u in UserProxyProxy.objects.all()]
-        self.assertEqual(resp, ['Bruce'])
+        self.assertEqual(resp, ["Bruce"])
 
-        self.assertEqual([u.name for u in MultiUserProxy.objects.all()], ['Bruce'])
+        self.assertEqual([u.name for u in MultiUserProxy.objects.all()], ["Bruce"])
 
     def test_proxy_for_model(self):
         self.assertEqual(UserProxy, UserProxyProxy._meta.proxy_for_model)
@@ -265,45 +286,47 @@ class ProxyModelTests(TestCase):
         """
         Proxy objects can be deleted
         """
-        User.objects.create(name='Bruce')
-        u2 = UserProxy.objects.create(name='George')
+        User.objects.create(name="Bruce")
+        u2 = UserProxy.objects.create(name="George")
 
         resp = [u.name for u in UserProxy.objects.all()]
-        self.assertEqual(resp, ['Bruce', 'George'])
+        self.assertEqual(resp, ["Bruce", "George"])
 
         u2.delete()
 
         resp = [u.name for u in UserProxy.objects.all()]
-        self.assertEqual(resp, ['Bruce'])
+        self.assertEqual(resp, ["Bruce"])
 
     def test_proxy_update(self):
-        user = User.objects.create(name='Bruce')
+        user = User.objects.create(name="Bruce")
         with self.assertNumQueries(1):
-            UserProxy.objects.filter(id=user.id).update(name='George')
+            UserProxy.objects.filter(id=user.id).update(name="George")
         user.refresh_from_db()
-        self.assertEqual(user.name, 'George')
+        self.assertEqual(user.name, "George")
 
     def test_select_related(self):
         """
         We can still use `select_related()` to include related models in our
         querysets.
         """
-        country = Country.objects.create(name='Australia')
-        State.objects.create(name='New South Wales', country=country)
+        country = Country.objects.create(name="Australia")
+        State.objects.create(name="New South Wales", country=country)
 
         resp = [s.name for s in State.objects.select_related()]
-        self.assertEqual(resp, ['New South Wales'])
+        self.assertEqual(resp, ["New South Wales"])
 
         resp = [s.name for s in StateProxy.objects.select_related()]
-        self.assertEqual(resp, ['New South Wales'])
+        self.assertEqual(resp, ["New South Wales"])
 
-        self.assertEqual(StateProxy.objects.get(name='New South Wales').name, 'New South Wales')
+        self.assertEqual(
+            StateProxy.objects.get(name="New South Wales").name, "New South Wales"
+        )
 
-        resp = StateProxy.objects.select_related().get(name='New South Wales')
-        self.assertEqual(resp.name, 'New South Wales')
+        resp = StateProxy.objects.select_related().get(name="New South Wales")
+        self.assertEqual(resp.name, "New South Wales")
 
     def test_filter_proxy_relation_reverse(self):
-        tu = TrackerUser.objects.create(name='Contributor', status='contrib')
+        tu = TrackerUser.objects.create(name="Contributor", status="contrib")
         ptu = ProxyTrackerUser.objects.get()
         issue = Issue.objects.create(assignee=tu)
         self.assertEqual(tu.issues.get(), issue)
@@ -312,64 +335,70 @@ class ProxyModelTests(TestCase):
         self.assertSequenceEqual(ProxyTrackerUser.objects.filter(issues=issue), [ptu])
 
     def test_proxy_bug(self):
-        contributor = ProxyTrackerUser.objects.create(name='Contributor', status='contrib')
-        someone = BaseUser.objects.create(name='Someone')
-        Bug.objects.create(summary='fix this', version='1.1beta', assignee=contributor, reporter=someone)
-        pcontributor = ProxyTrackerUser.objects.create(name='OtherContributor', status='proxy')
+        contributor = ProxyTrackerUser.objects.create(
+            name="Contributor", status="contrib"
+        )
+        someone = BaseUser.objects.create(name="Someone")
+        Bug.objects.create(
+            summary="fix this",
+            version="1.1beta",
+            assignee=contributor,
+            reporter=someone,
+        )
+        pcontributor = ProxyTrackerUser.objects.create(
+            name="OtherContributor", status="proxy"
+        )
         Improvement.objects.create(
-            summary='improve that', version='1.1beta',
-            assignee=contributor, reporter=pcontributor,
+            summary="improve that",
+            version="1.1beta",
+            assignee=contributor,
+            reporter=pcontributor,
             associated_bug=ProxyProxyBug.objects.all()[0],
         )
 
         # Related field filter on proxy
-        resp = ProxyBug.objects.get(version__icontains='beta')
-        self.assertEqual(repr(resp), '<ProxyBug: ProxyBug:fix this>')
+        resp = ProxyBug.objects.get(version__icontains="beta")
+        self.assertEqual(repr(resp), "<ProxyBug: ProxyBug:fix this>")
 
         # Select related + filter on proxy
-        resp = ProxyBug.objects.select_related().get(version__icontains='beta')
-        self.assertEqual(repr(resp), '<ProxyBug: ProxyBug:fix this>')
+        resp = ProxyBug.objects.select_related().get(version__icontains="beta")
+        self.assertEqual(repr(resp), "<ProxyBug: ProxyBug:fix this>")
 
         # Proxy of proxy, select_related + filter
-        resp = ProxyProxyBug.objects.select_related().get(
-            version__icontains='beta'
-        )
-        self.assertEqual(repr(resp), '<ProxyProxyBug: ProxyProxyBug:fix this>')
+        resp = ProxyProxyBug.objects.select_related().get(version__icontains="beta")
+        self.assertEqual(repr(resp), "<ProxyProxyBug: ProxyProxyBug:fix this>")
 
         # Select related + filter on a related proxy field
         resp = ProxyImprovement.objects.select_related().get(
-            reporter__name__icontains='butor'
+            reporter__name__icontains="butor"
         )
         self.assertEqual(
-            repr(resp),
-            '<ProxyImprovement: ProxyImprovement:improve that>'
+            repr(resp), "<ProxyImprovement: ProxyImprovement:improve that>"
         )
 
         # Select related + filter on a related proxy of proxy field
         resp = ProxyImprovement.objects.select_related().get(
-            associated_bug__summary__icontains='fix'
+            associated_bug__summary__icontains="fix"
         )
         self.assertEqual(
-            repr(resp),
-            '<ProxyImprovement: ProxyImprovement:improve that>'
+            repr(resp), "<ProxyImprovement: ProxyImprovement:improve that>"
         )
 
     def test_proxy_load_from_fixture(self):
-        management.call_command('loaddata', 'mypeople.json', verbosity=0)
+        management.call_command("loaddata", "mypeople.json", verbosity=0)
         p = MyPerson.objects.get(pk=100)
-        self.assertEqual(p.name, 'Elvis Presley')
+        self.assertEqual(p.name, "Elvis Presley")
 
     def test_eq(self):
         self.assertEqual(MyPerson(id=100), Person(id=100))
 
 
-@override_settings(ROOT_URLCONF='proxy_models.urls')
+@override_settings(ROOT_URLCONF="proxy_models.urls")
 class ProxyModelAdminTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         cls.superuser = AuthUser.objects.create(is_superuser=True, is_staff=True)
-        cls.tu1 = ProxyTrackerUser.objects.create(name='Django Pony', status='emperor')
+        cls.tu1 = ProxyTrackerUser.objects.create(name="Django Pony", status="emperor")
         cls.i1 = Issue.objects.create(summary="Pony's Issue", assignee=cls.tu1)
 
     def test_cascade_delete_proxy_model_admin_warning(self):
@@ -381,7 +410,7 @@ class ProxyModelAdminTests(TestCase):
         base_user = BaseUser.objects.all()[0]
         issue = Issue.objects.all()[0]
         with self.assertNumQueries(6):
-            collector = admin.utils.NestedObjects('default')
+            collector = admin.utils.NestedObjects("default")
             collector.collect(ProxyTrackerUser.objects.all())
         self.assertIn(tracker_user, collector.edges.get(None, ()))
         self.assertIn(base_user, collector.edges.get(None, ()))
@@ -392,20 +421,30 @@ class ProxyModelAdminTests(TestCase):
         Test if the admin delete page shows the correct string representation
         for a proxy model.
         """
-        user = TrackerUser.objects.get(name='Django Pony')
-        proxy = ProxyTrackerUser.objects.get(name='Django Pony')
+        user = TrackerUser.objects.get(name="Django Pony")
+        proxy = ProxyTrackerUser.objects.get(name="Django Pony")
 
         user_str = 'Tracker user: <a href="%s">%s</a>' % (
-            reverse('admin_proxy:proxy_models_trackeruser_change', args=(user.pk,)), user
+            reverse("admin_proxy:proxy_models_trackeruser_change", args=(user.pk,)),
+            user,
         )
         proxy_str = 'Proxy tracker user: <a href="%s">%s</a>' % (
-            reverse('admin_proxy:proxy_models_proxytrackeruser_change', args=(proxy.pk,)), proxy
+            reverse(
+                "admin_proxy:proxy_models_proxytrackeruser_change", args=(proxy.pk,)
+            ),
+            proxy,
         )
 
         self.client.force_login(self.superuser)
-        response = self.client.get(reverse('admin_proxy:proxy_models_trackeruser_delete', args=(user.pk,)))
-        delete_str = response.context['deleted_objects'][0]
+        response = self.client.get(
+            reverse("admin_proxy:proxy_models_trackeruser_delete", args=(user.pk,))
+        )
+        delete_str = response.context["deleted_objects"][0]
         self.assertEqual(delete_str, user_str)
-        response = self.client.get(reverse('admin_proxy:proxy_models_proxytrackeruser_delete', args=(proxy.pk,)))
-        delete_str = response.context['deleted_objects'][0]
+        response = self.client.get(
+            reverse(
+                "admin_proxy:proxy_models_proxytrackeruser_delete", args=(proxy.pk,)
+            )
+        )
+        delete_str = response.context["deleted_objects"][0]
         self.assertEqual(delete_str, proxy_str)
diff --git a/tests/proxy_models/urls.py b/tests/proxy_models/urls.py
index 13910ef999..50c12eace4 100644
--- a/tests/proxy_models/urls.py
+++ b/tests/proxy_models/urls.py
@@ -3,5 +3,5 @@ from django.urls import path
 from .admin import site
 
 urlpatterns = [
-    path('admin/', site.urls),
+    path("admin/", site.urls),
 ]