Refs #33476 -- Reformatted code with Black.

4 files changed, 255 insertions, 186 deletions

diff --git a/tests/middleware_exceptions/middleware.py b/tests/middleware_exceptions/middleware.py
index b87da84b9d..5a0c82afb1 100644
--- a/tests/middleware_exceptions/middleware.py
+++ b/tests/middleware_exceptions/middleware.py
@@ -4,7 +4,9 @@ from django.http import Http404, HttpResponse
 from django.template import engines
 from django.template.response import TemplateResponse
 from django.utils.decorators import (
-    async_only_middleware, sync_and_async_middleware, sync_only_middleware,
+    async_only_middleware,
+    sync_and_async_middleware,
+    sync_only_middleware,
 )
 
 log = []
@@ -23,58 +25,64 @@ class BaseMiddleware:
 
 class ProcessExceptionMiddleware(BaseMiddleware):
     def process_exception(self, request, exception):
-        return HttpResponse('Exception caught')
+        return HttpResponse("Exception caught")
 
 
 @async_only_middleware
 class AsyncProcessExceptionMiddleware(BaseMiddleware):
     async def process_exception(self, request, exception):
-        return HttpResponse('Exception caught')
+        return HttpResponse("Exception caught")
 
 
 class ProcessExceptionLogMiddleware(BaseMiddleware):
     def process_exception(self, request, exception):
-        log.append('process-exception')
+        log.append("process-exception")
 
 
 class ProcessExceptionExcMiddleware(BaseMiddleware):
     def process_exception(self, request, exception):
-        raise Exception('from process-exception')
+        raise Exception("from process-exception")
 
 
 class ProcessViewMiddleware(BaseMiddleware):
     def process_view(self, request, view_func, view_args, view_kwargs):
-        return HttpResponse('Processed view %s' % view_func.__name__)
+        return HttpResponse("Processed view %s" % view_func.__name__)
 
 
 @async_only_middleware
 class AsyncProcessViewMiddleware(BaseMiddleware):
     async def process_view(self, request, view_func, view_args, view_kwargs):
-        return HttpResponse('Processed view %s' % view_func.__name__)
+        return HttpResponse("Processed view %s" % view_func.__name__)
 
 
 class ProcessViewNoneMiddleware(BaseMiddleware):
     def process_view(self, request, view_func, view_args, view_kwargs):
-        log.append('processed view %s' % view_func.__name__)
+        log.append("processed view %s" % view_func.__name__)
         return None
 
 
 class ProcessViewTemplateResponseMiddleware(BaseMiddleware):
     def process_view(self, request, view_func, view_args, view_kwargs):
-        template = engines['django'].from_string('Processed view {{ view }}{% for m in mw %}\n{{ m }}{% endfor %}')
-        return TemplateResponse(request, template, {'mw': [self.__class__.__name__], 'view': view_func.__name__})
+        template = engines["django"].from_string(
+            "Processed view {{ view }}{% for m in mw %}\n{{ m }}{% endfor %}"
+        )
+        return TemplateResponse(
+            request,
+            template,
+            {"mw": [self.__class__.__name__], "view": view_func.__name__},
+        )
 
 
 class TemplateResponseMiddleware(BaseMiddleware):
     def process_template_response(self, request, response):
-        response.context_data['mw'].append(self.__class__.__name__)
+        response.context_data["mw"].append(self.__class__.__name__)
         return response
 
 
 @async_only_middleware
 class AsyncTemplateResponseMiddleware(BaseMiddleware):
     async def process_template_response(self, request, response):
-        response.context_data['mw'].append(self.__class__.__name__)
+        response.context_data["mw"].append(self.__class__.__name__)
         return response
 
 
@@ -98,7 +106,7 @@ class AsyncNoTemplateResponseMiddleware(BaseMiddleware):
 
 class NotFoundMiddleware(BaseMiddleware):
     def __call__(self, request):
-        raise Http404('not found')
+        raise Http404("not found")
 
 
 class PaymentMiddleware(BaseMiddleware):
@@ -130,6 +138,7 @@ class DecoratedPaymentMiddleware(PaymentMiddleware):
 
 class NotSyncOrAsyncMiddleware(BaseMiddleware):
     """Middleware that is deliberately neither sync or async."""
+
     sync_capable = False
     async_capable = False
 
diff --git a/tests/middleware_exceptions/tests.py b/tests/middleware_exceptions/tests.py
index a68775d173..b3b611e23f 100644
--- a/tests/middleware_exceptions/tests.py
+++ b/tests/middleware_exceptions/tests.py
@@ -6,113 +6,141 @@ from django.test import RequestFactory, SimpleTestCase, override_settings
 from . import middleware as mw
 
 
-@override_settings(ROOT_URLCONF='middleware_exceptions.urls')
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
 class MiddlewareTests(SimpleTestCase):
     def tearDown(self):
         mw.log = []
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.ProcessViewNoneMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewNoneMiddleware"]
+    )
     def test_process_view_return_none(self):
-        response = self.client.get('/middleware_exceptions/view/')
-        self.assertEqual(mw.log, ['processed view normal_view'])
-        self.assertEqual(response.content, b'OK')
+        response = self.client.get("/middleware_exceptions/view/")
+        self.assertEqual(mw.log, ["processed view normal_view"])
+        self.assertEqual(response.content, b"OK")
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.ProcessViewMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewMiddleware"]
+    )
     def test_process_view_return_response(self):
-        response = self.client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'Processed view normal_view')
+        response = self.client.get("/middleware_exceptions/view/")
+        self.assertEqual(response.content, b"Processed view normal_view")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware',
-        'middleware_exceptions.middleware.LogMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
+            "middleware_exceptions.middleware.LogMiddleware",
+        ]
+    )
     def test_templateresponse_from_process_view_rendered(self):
         """
         TemplateResponses returned from process_view() must be rendered before
         being passed to any middleware that tries to access response.content,
         such as middleware_exceptions.middleware.LogMiddleware.
         """
-        response = self.client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'Processed view normal_view\nProcessViewTemplateResponseMiddleware')
-
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware',
-        'middleware_exceptions.middleware.TemplateResponseMiddleware',
-    ])
-    def test_templateresponse_from_process_view_passed_to_process_template_response(self):
+        response = self.client.get("/middleware_exceptions/view/")
+        self.assertEqual(
+            response.content,
+            b"Processed view normal_view\nProcessViewTemplateResponseMiddleware",
+        )
+
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
+            "middleware_exceptions.middleware.TemplateResponseMiddleware",
+        ]
+    )
+    def test_templateresponse_from_process_view_passed_to_process_template_response(
+        self,
+    ):
         """
         TemplateResponses returned from process_view() should be passed to any
         template response middleware.
         """
-        response = self.client.get('/middleware_exceptions/view/')
+        response = self.client.get("/middleware_exceptions/view/")
         expected_lines = [
-            b'Processed view normal_view',
-            b'ProcessViewTemplateResponseMiddleware',
-            b'TemplateResponseMiddleware',
+            b"Processed view normal_view",
+            b"ProcessViewTemplateResponseMiddleware",
+            b"TemplateResponseMiddleware",
         ]
-        self.assertEqual(response.content, b'\n'.join(expected_lines))
+        self.assertEqual(response.content, b"\n".join(expected_lines))
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.TemplateResponseMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.TemplateResponseMiddleware"]
+    )
     def test_process_template_response(self):
-        response = self.client.get('/middleware_exceptions/template_response/')
-        self.assertEqual(response.content, b'template_response OK\nTemplateResponseMiddleware')
+        response = self.client.get("/middleware_exceptions/template_response/")
+        self.assertEqual(
+            response.content, b"template_response OK\nTemplateResponseMiddleware"
+        )
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.NoTemplateResponseMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.NoTemplateResponseMiddleware"]
+    )
     def test_process_template_response_returns_none(self):
         msg = (
             "NoTemplateResponseMiddleware.process_template_response didn't "
             "return an HttpResponse object. It returned None instead."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            self.client.get('/middleware_exceptions/template_response/')
+            self.client.get("/middleware_exceptions/template_response/")
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.LogMiddleware'])
+    @override_settings(MIDDLEWARE=["middleware_exceptions.middleware.LogMiddleware"])
     def test_view_exception_converted_before_middleware(self):
-        response = self.client.get('/middleware_exceptions/permission_denied/')
+        response = self.client.get("/middleware_exceptions/permission_denied/")
         self.assertEqual(mw.log, [(response.status_code, response.content)])
         self.assertEqual(response.status_code, 403)
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.ProcessExceptionMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
+    )
     def test_view_exception_handled_by_process_exception(self):
-        response = self.client.get('/middleware_exceptions/error/')
-        self.assertEqual(response.content, b'Exception caught')
+        response = self.client.get("/middleware_exceptions/error/")
+        self.assertEqual(response.content, b"Exception caught")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.ProcessExceptionLogMiddleware',
-        'middleware_exceptions.middleware.ProcessExceptionMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
+            "middleware_exceptions.middleware.ProcessExceptionMiddleware",
+        ]
+    )
     def test_response_from_process_exception_short_circuits_remainder(self):
-        response = self.client.get('/middleware_exceptions/error/')
+        response = self.client.get("/middleware_exceptions/error/")
         self.assertEqual(mw.log, [])
-        self.assertEqual(response.content, b'Exception caught')
+        self.assertEqual(response.content, b"Exception caught")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.ProcessExceptionMiddleware',
-        'middleware_exceptions.middleware.ProcessExceptionLogMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.ProcessExceptionMiddleware",
+            "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
+        ]
+    )
     def test_response_from_process_exception_when_return_response(self):
-        response = self.client.get('/middleware_exceptions/error/')
-        self.assertEqual(mw.log, ['process-exception'])
-        self.assertEqual(response.content, b'Exception caught')
-
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.LogMiddleware',
-        'middleware_exceptions.middleware.NotFoundMiddleware',
-    ])
+        response = self.client.get("/middleware_exceptions/error/")
+        self.assertEqual(mw.log, ["process-exception"])
+        self.assertEqual(response.content, b"Exception caught")
+
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.LogMiddleware",
+            "middleware_exceptions.middleware.NotFoundMiddleware",
+        ]
+    )
     def test_exception_in_middleware_converted_before_prior_middleware(self):
-        response = self.client.get('/middleware_exceptions/view/')
+        response = self.client.get("/middleware_exceptions/view/")
         self.assertEqual(mw.log, [(404, response.content)])
         self.assertEqual(response.status_code, 404)
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.middleware.ProcessExceptionMiddleware'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
+    )
     def test_exception_in_render_passed_to_process_exception(self):
-        response = self.client.get('/middleware_exceptions/exception_in_render/')
-        self.assertEqual(response.content, b'Exception caught')
+        response = self.client.get("/middleware_exceptions/exception_in_render/")
+        self.assertEqual(response.content, b"Exception caught")
 
 
-@override_settings(ROOT_URLCONF='middleware_exceptions.urls')
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
 class RootUrlconfTests(SimpleTestCase):
-
     @override_settings(ROOT_URLCONF=None)
     def test_missing_root_urlconf(self):
         # Removing ROOT_URLCONF is safe, as override_settings will restore
@@ -123,7 +151,6 @@ class RootUrlconfTests(SimpleTestCase):
 
 
 class MyMiddleware:
-
     def __init__(self, get_response):
         raise MiddlewareNotUsed
 
@@ -132,9 +159,8 @@ class MyMiddleware:
 
 
 class MyMiddlewareWithExceptionMessage:
-
     def __init__(self, get_response):
-        raise MiddlewareNotUsed('spam eggs')
+        raise MiddlewareNotUsed("spam eggs")
 
     def process_request(self, request):
         pass
@@ -142,57 +168,61 @@ class MyMiddlewareWithExceptionMessage:
 
 @override_settings(
     DEBUG=True,
-    ROOT_URLCONF='middleware_exceptions.urls',
-    MIDDLEWARE=['django.middleware.common.CommonMiddleware'],
+    ROOT_URLCONF="middleware_exceptions.urls",
+    MIDDLEWARE=["django.middleware.common.CommonMiddleware"],
 )
 class MiddlewareNotUsedTests(SimpleTestCase):
 
     rf = RequestFactory()
 
     def test_raise_exception(self):
-        request = self.rf.get('middleware_exceptions/view/')
+        request = self.rf.get("middleware_exceptions/view/")
         with self.assertRaises(MiddlewareNotUsed):
             MyMiddleware(lambda req: HttpResponse()).process_request(request)
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.tests.MyMiddleware'])
+    @override_settings(MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"])
     def test_log(self):
-        with self.assertLogs('django.request', 'DEBUG') as cm:
-            self.client.get('/middleware_exceptions/view/')
+        with self.assertLogs("django.request", "DEBUG") as cm:
+            self.client.get("/middleware_exceptions/view/")
         self.assertEqual(
             cm.records[0].getMessage(),
-            "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'"
+            "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'",
         )
 
-    @override_settings(MIDDLEWARE=['middleware_exceptions.tests.MyMiddlewareWithExceptionMessage'])
+    @override_settings(
+        MIDDLEWARE=["middleware_exceptions.tests.MyMiddlewareWithExceptionMessage"]
+    )
     def test_log_custom_message(self):
-        with self.assertLogs('django.request', 'DEBUG') as cm:
-            self.client.get('/middleware_exceptions/view/')
+        with self.assertLogs("django.request", "DEBUG") as cm:
+            self.client.get("/middleware_exceptions/view/")
         self.assertEqual(
             cm.records[0].getMessage(),
-            "MiddlewareNotUsed('middleware_exceptions.tests.MyMiddlewareWithExceptionMessage'): spam eggs"
+            "MiddlewareNotUsed('middleware_exceptions.tests.MyMiddlewareWithExceptionMessage'): spam eggs",
         )
 
     @override_settings(
         DEBUG=False,
-        MIDDLEWARE=['middleware_exceptions.tests.MyMiddleware'],
+        MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"],
     )
     def test_do_not_log_when_debug_is_false(self):
-        with self.assertNoLogs('django.request', 'DEBUG'):
-            self.client.get('/middleware_exceptions/view/')
+        with self.assertNoLogs("django.request", "DEBUG"):
+            self.client.get("/middleware_exceptions/view/")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.SyncAndAsyncMiddleware',
-        'middleware_exceptions.tests.MyMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+            "middleware_exceptions.tests.MyMiddleware",
+        ]
+    )
     async def test_async_and_sync_middleware_chain_async_call(self):
-        with self.assertLogs('django.request', 'DEBUG') as cm:
-            response = await self.async_client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'OK')
+        with self.assertLogs("django.request", "DEBUG") as cm:
+            response = await self.async_client.get("/middleware_exceptions/view/")
+        self.assertEqual(response.content, b"OK")
         self.assertEqual(response.status_code, 200)
         self.assertEqual(
             cm.records[0].getMessage(),
-            'Asynchronous middleware middleware_exceptions.tests.MyMiddleware '
-            'adapted.',
+            "Asynchronous middleware middleware_exceptions.tests.MyMiddleware "
+            "adapted.",
         )
         self.assertEqual(
             cm.records[1].getMessage(),
@@ -202,29 +232,35 @@ class MiddlewareNotUsedTests(SimpleTestCase):
 
 @override_settings(
     DEBUG=True,
-    ROOT_URLCONF='middleware_exceptions.urls',
+    ROOT_URLCONF="middleware_exceptions.urls",
 )
 class MiddlewareSyncAsyncTests(SimpleTestCase):
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.PaymentMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.PaymentMiddleware",
+        ]
+    )
     def test_sync_middleware(self):
-        response = self.client.get('/middleware_exceptions/view/')
+        response = self.client.get("/middleware_exceptions/view/")
         self.assertEqual(response.status_code, 402)
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.DecoratedPaymentMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.DecoratedPaymentMiddleware",
+        ]
+    )
     def test_sync_decorated_middleware(self):
-        response = self.client.get('/middleware_exceptions/view/')
+        response = self.client.get("/middleware_exceptions/view/")
         self.assertEqual(response.status_code, 402)
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.async_payment_middleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.async_payment_middleware",
+        ]
+    )
     def test_async_middleware(self):
-        with self.assertLogs('django.request', 'DEBUG') as cm:
-            response = self.client.get('/middleware_exceptions/view/')
+        with self.assertLogs("django.request", "DEBUG") as cm:
+            response = self.client.get("/middleware_exceptions/view/")
         self.assertEqual(response.status_code, 402)
         self.assertEqual(
             cm.records[0].getMessage(),
@@ -233,24 +269,28 @@ class MiddlewareSyncAsyncTests(SimpleTestCase):
             "adapted.",
         )
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.NotSyncOrAsyncMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware",
+        ]
+    )
     def test_not_sync_or_async_middleware(self):
         msg = (
-            'Middleware '
-            'middleware_exceptions.middleware.NotSyncOrAsyncMiddleware must '
-            'have at least one of sync_capable/async_capable set to True.'
+            "Middleware "
+            "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware must "
+            "have at least one of sync_capable/async_capable set to True."
         )
         with self.assertRaisesMessage(RuntimeError, msg):
-            self.client.get('/middleware_exceptions/view/')
+            self.client.get("/middleware_exceptions/view/")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.PaymentMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.PaymentMiddleware",
+        ]
+    )
     async def test_sync_middleware_async(self):
-        with self.assertLogs('django.request', 'DEBUG') as cm:
-            response = await self.async_client.get('/middleware_exceptions/view/')
+        with self.assertLogs("django.request", "DEBUG") as cm:
+            response = await self.async_client.get("/middleware_exceptions/view/")
         self.assertEqual(response.status_code, 402)
         self.assertEqual(
             cm.records[0].getMessage(),
@@ -258,22 +298,24 @@ class MiddlewareSyncAsyncTests(SimpleTestCase):
             "middleware_exceptions.middleware.PaymentMiddleware adapted.",
         )
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.async_payment_middleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.async_payment_middleware",
+        ]
+    )
     async def test_async_middleware_async(self):
-        with self.assertLogs('django.request', 'WARNING') as cm:
-            response = await self.async_client.get('/middleware_exceptions/view/')
+        with self.assertLogs("django.request", "WARNING") as cm:
+            response = await self.async_client.get("/middleware_exceptions/view/")
         self.assertEqual(response.status_code, 402)
         self.assertEqual(
             cm.records[0].getMessage(),
-            'Payment Required: /middleware_exceptions/view/',
+            "Payment Required: /middleware_exceptions/view/",
         )
 
     @override_settings(
         DEBUG=False,
         MIDDLEWARE=[
-            'middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware',
+            "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
         ],
     )
     def test_async_process_template_response_returns_none_with_sync_client(self):
@@ -282,78 +324,94 @@ class MiddlewareSyncAsyncTests(SimpleTestCase):
             "didn't return an HttpResponse object."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            self.client.get('/middleware_exceptions/template_response/')
+            self.client.get("/middleware_exceptions/template_response/")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.SyncAndAsyncMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+        ]
+    )
     async def test_async_and_sync_middleware_async_call(self):
-        response = await self.async_client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'OK')
+        response = await self.async_client.get("/middleware_exceptions/view/")
+        self.assertEqual(response.content, b"OK")
         self.assertEqual(response.status_code, 200)
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.SyncAndAsyncMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+        ]
+    )
     def test_async_and_sync_middleware_sync_call(self):
-        response = self.client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'OK')
+        response = self.client.get("/middleware_exceptions/view/")
+        self.assertEqual(response.content, b"OK")
         self.assertEqual(response.status_code, 200)
 
 
-@override_settings(ROOT_URLCONF='middleware_exceptions.urls')
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
 class AsyncMiddlewareTests(SimpleTestCase):
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncTemplateResponseMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncTemplateResponseMiddleware",
+        ]
+    )
     async def test_process_template_response(self):
         response = await self.async_client.get(
-            '/middleware_exceptions/template_response/'
+            "/middleware_exceptions/template_response/"
         )
         self.assertEqual(
             response.content,
-            b'template_response OK\nAsyncTemplateResponseMiddleware',
+            b"template_response OK\nAsyncTemplateResponseMiddleware",
         )
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
+        ]
+    )
     async def test_process_template_response_returns_none(self):
         msg = (
             "AsyncNoTemplateResponseMiddleware.process_template_response "
             "didn't return an HttpResponse object. It returned None instead."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            await self.async_client.get('/middleware_exceptions/template_response/')
+            await self.async_client.get("/middleware_exceptions/template_response/")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncProcessExceptionMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+        ]
+    )
     async def test_exception_in_render_passed_to_process_exception(self):
         response = await self.async_client.get(
-            '/middleware_exceptions/exception_in_render/'
+            "/middleware_exceptions/exception_in_render/"
         )
-        self.assertEqual(response.content, b'Exception caught')
+        self.assertEqual(response.content, b"Exception caught")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncProcessExceptionMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+        ]
+    )
     async def test_exception_in_async_render_passed_to_process_exception(self):
         response = await self.async_client.get(
-            '/middleware_exceptions/async_exception_in_render/'
+            "/middleware_exceptions/async_exception_in_render/"
         )
-        self.assertEqual(response.content, b'Exception caught')
+        self.assertEqual(response.content, b"Exception caught")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncProcessExceptionMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+        ]
+    )
     async def test_view_exception_handled_by_process_exception(self):
-        response = await self.async_client.get('/middleware_exceptions/error/')
-        self.assertEqual(response.content, b'Exception caught')
+        response = await self.async_client.get("/middleware_exceptions/error/")
+        self.assertEqual(response.content, b"Exception caught")
 
-    @override_settings(MIDDLEWARE=[
-        'middleware_exceptions.middleware.AsyncProcessViewMiddleware',
-    ])
+    @override_settings(
+        MIDDLEWARE=[
+            "middleware_exceptions.middleware.AsyncProcessViewMiddleware",
+        ]
+    )
     async def test_process_view_return_response(self):
-        response = await self.async_client.get('/middleware_exceptions/view/')
-        self.assertEqual(response.content, b'Processed view normal_view')
+        response = await self.async_client.get("/middleware_exceptions/view/")
+        self.assertEqual(response.content, b"Processed view normal_view")
diff --git a/tests/middleware_exceptions/urls.py b/tests/middleware_exceptions/urls.py
index d676ef470c..80cbb2c21b 100644
--- a/tests/middleware_exceptions/urls.py
+++ b/tests/middleware_exceptions/urls.py
@@ -3,14 +3,14 @@ from django.urls import path
 from . import views
 
 urlpatterns = [
-    path('middleware_exceptions/view/', views.normal_view),
-    path('middleware_exceptions/error/', views.server_error),
-    path('middleware_exceptions/permission_denied/', views.permission_denied),
-    path('middleware_exceptions/exception_in_render/', views.exception_in_render),
-    path('middleware_exceptions/template_response/', views.template_response),
+    path("middleware_exceptions/view/", views.normal_view),
+    path("middleware_exceptions/error/", views.server_error),
+    path("middleware_exceptions/permission_denied/", views.permission_denied),
+    path("middleware_exceptions/exception_in_render/", views.exception_in_render),
+    path("middleware_exceptions/template_response/", views.template_response),
     # Async views.
     path(
-        'middleware_exceptions/async_exception_in_render/',
+        "middleware_exceptions/async_exception_in_render/",
         views.async_exception_in_render,
     ),
 ]
diff --git a/tests/middleware_exceptions/views.py b/tests/middleware_exceptions/views.py
index 7a1d244863..0f1595b2d6 100644
--- a/tests/middleware_exceptions/views.py
+++ b/tests/middleware_exceptions/views.py
@@ -5,16 +5,18 @@ from django.template.response import TemplateResponse
 
 
 def normal_view(request):
-    return HttpResponse('OK')
+    return HttpResponse("OK")
 
 
 def template_response(request):
-    template = engines['django'].from_string('template_response OK{% for m in mw %}\n{{ m }}{% endfor %}')
-    return TemplateResponse(request, template, context={'mw': []})
+    template = engines["django"].from_string(
+        "template_response OK{% for m in mw %}\n{{ m }}{% endfor %}"
+    )
+    return TemplateResponse(request, template, context={"mw": []})
 
 
 def server_error(request):
-    raise Exception('Error in view')
+    raise Exception("Error in view")
 
 
 def permission_denied(request):
@@ -24,14 +26,14 @@ def permission_denied(request):
 def exception_in_render(request):
     class CustomHttpResponse(HttpResponse):
         def render(self):
-            raise Exception('Exception in HttpResponse.render()')
+            raise Exception("Exception in HttpResponse.render()")
 
-    return CustomHttpResponse('Error')
+    return CustomHttpResponse("Error")
 
 
 async def async_exception_in_render(request):
     class CustomHttpResponse(HttpResponse):
         async def render(self):
-            raise Exception('Exception in HttpResponse.render()')
+            raise Exception("Exception in HttpResponse.render()")
 
-    return CustomHttpResponse('Error')
+    return CustomHttpResponse("Error")