Refs #33476 -- Reformatted code with Black.

6 files changed, 643 insertions, 540 deletions

diff --git a/tests/test_client/test_conditional_content_removal.py b/tests/test_client/test_conditional_content_removal.py
index bd26b8fb52..d8938062fe 100644
--- a/tests/test_client/test_conditional_content_removal.py
+++ b/tests/test_client/test_conditional_content_removal.py
@@ -6,7 +6,6 @@ from django.test.client import conditional_content_removal
 
 
 class ConditionalContentTests(SimpleTestCase):
-
     def test_conditional_content_removal(self):
         """
         Content is removed from regular and streaming responses with a
@@ -15,43 +14,43 @@ class ConditionalContentTests(SimpleTestCase):
         req = HttpRequest()
 
         # Do nothing for 200 responses.
-        res = HttpResponse('abc')
+        res = HttpResponse("abc")
         conditional_content_removal(req, res)
-        self.assertEqual(res.content, b'abc')
+        self.assertEqual(res.content, b"abc")
 
-        res = StreamingHttpResponse(['abc'])
+        res = StreamingHttpResponse(["abc"])
         conditional_content_removal(req, res)
-        self.assertEqual(b''.join(res), b'abc')
+        self.assertEqual(b"".join(res), b"abc")
 
         # Strip content for some status codes.
         for status_code in (100, 150, 199, 204, 304):
-            res = HttpResponse('abc', status=status_code)
+            res = HttpResponse("abc", status=status_code)
             conditional_content_removal(req, res)
-            self.assertEqual(res.content, b'')
+            self.assertEqual(res.content, b"")
 
-            res = StreamingHttpResponse(['abc'], status=status_code)
+            res = StreamingHttpResponse(["abc"], status=status_code)
             conditional_content_removal(req, res)
-            self.assertEqual(b''.join(res), b'')
+            self.assertEqual(b"".join(res), b"")
 
         # Issue #20472
-        abc = gzip.compress(b'abc')
+        abc = gzip.compress(b"abc")
         res = HttpResponse(abc, status=304)
-        res['Content-Encoding'] = 'gzip'
+        res["Content-Encoding"] = "gzip"
         conditional_content_removal(req, res)
-        self.assertEqual(res.content, b'')
+        self.assertEqual(res.content, b"")
 
         res = StreamingHttpResponse([abc], status=304)
-        res['Content-Encoding'] = 'gzip'
+        res["Content-Encoding"] = "gzip"
         conditional_content_removal(req, res)
-        self.assertEqual(b''.join(res), b'')
+        self.assertEqual(b"".join(res), b"")
 
         # Strip content for HEAD requests.
-        req.method = 'HEAD'
+        req.method = "HEAD"
 
-        res = HttpResponse('abc')
+        res = HttpResponse("abc")
         conditional_content_removal(req, res)
-        self.assertEqual(res.content, b'')
+        self.assertEqual(res.content, b"")
 
-        res = StreamingHttpResponse(['abc'])
+        res = StreamingHttpResponse(["abc"])
         conditional_content_removal(req, res)
-        self.assertEqual(b''.join(res), b'')
+        self.assertEqual(b"".join(res), b"")
diff --git a/tests/test_client/test_fakepayload.py b/tests/test_client/test_fakepayload.py
index d33a95824d..191bf0e111 100644
--- a/tests/test_client/test_fakepayload.py
+++ b/tests/test_client/test_fakepayload.py
@@ -8,4 +8,4 @@ class FakePayloadTests(SimpleTestCase):
         payload.read()
         msg = "Unable to write a payload after it's been read"
         with self.assertRaisesMessage(ValueError, msg):
-            payload.write(b'abc')
+            payload.write(b"abc")
diff --git a/tests/test_client/tests.py b/tests/test_client/tests.py
index 2496a1d79a..ea096efda4 100644
--- a/tests/test_client/tests.py
+++ b/tests/test_client/tests.py
@@ -27,8 +27,13 @@ from django.contrib.auth.models import User
 from django.core import mail
 from django.http import HttpResponse, HttpResponseNotAllowed
 from django.test import (
-    AsyncRequestFactory, Client, RequestFactory, SimpleTestCase, TestCase,
-    modify_settings, override_settings,
+    AsyncRequestFactory,
+    Client,
+    RequestFactory,
+    SimpleTestCase,
+    TestCase,
+    modify_settings,
+    override_settings,
 )
 from django.urls import reverse_lazy
 from django.utils.decorators import async_only_middleware
@@ -39,7 +44,7 @@ from .views import TwoArgException, get_view, post_view, trace_view
 
 def middleware_urlconf(get_response):
     def middleware(request):
-        request.urlconf = 'tests.test_client.urls_middleware_urlconf'
+        request.urlconf = "tests.test_client.urls_middleware_urlconf"
         return get_response(request)
 
     return middleware
@@ -48,36 +53,37 @@ def middleware_urlconf(get_response):
 @async_only_middleware
 def async_middleware_urlconf(get_response):
     async def middleware(request):
-        request.urlconf = 'tests.test_client.urls_middleware_urlconf'
+        request.urlconf = "tests.test_client.urls_middleware_urlconf"
         return await get_response(request)
 
     return middleware
 
 
-@override_settings(ROOT_URLCONF='test_client.urls')
+@override_settings(ROOT_URLCONF="test_client.urls")
 class ClientTest(TestCase):
-
     @classmethod
     def setUpTestData(cls):
-        cls.u1 = User.objects.create_user(username='testclient', password='password')
-        cls.u2 = User.objects.create_user(username='inactive', password='password', is_active=False)
+        cls.u1 = User.objects.create_user(username="testclient", password="password")
+        cls.u2 = User.objects.create_user(
+            username="inactive", password="password", is_active=False
+        )
 
     def test_get_view(self):
         "GET a view"
         # The data is ignored, but let's check it doesn't crash the system
         # anyway.
-        data = {'var': '\xf2'}
-        response = self.client.get('/get_view/', data)
+        data = {"var": "\xf2"}
+        response = self.client.get("/get_view/", data)
 
         # Check some response details
-        self.assertContains(response, 'This is a test')
-        self.assertEqual(response.context['var'], '\xf2')
-        self.assertEqual(response.templates[0].name, 'GET Template')
+        self.assertContains(response, "This is a test")
+        self.assertEqual(response.context["var"], "\xf2")
+        self.assertEqual(response.templates[0].name, "GET Template")
 
     def test_query_string_encoding(self):
         # WSGI requires latin-1 encoded strings.
-        response = self.client.get('/get_view/?var=1\ufffd')
-        self.assertEqual(response.context['var'], '1\ufffd')
+        response = self.client.get("/get_view/?var=1\ufffd")
+        self.assertEqual(response.context["var"], "1\ufffd")
 
     def test_get_data_none(self):
         msg = (
@@ -85,39 +91,37 @@ class ClientTest(TestCase):
             "mean to pass an empty string or omit the value?"
         )
         with self.assertRaisesMessage(TypeError, msg):
-            self.client.get('/get_view/', {'value': None})
+            self.client.get("/get_view/", {"value": None})
 
     def test_get_post_view(self):
         "GET a view that normally expects POSTs"
-        response = self.client.get('/post_view/', {})
+        response = self.client.get("/post_view/", {})
 
         # Check some response details
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.templates[0].name, 'Empty GET Template')
-        self.assertTemplateUsed(response, 'Empty GET Template')
-        self.assertTemplateNotUsed(response, 'Empty POST Template')
+        self.assertEqual(response.templates[0].name, "Empty GET Template")
+        self.assertTemplateUsed(response, "Empty GET Template")
+        self.assertTemplateNotUsed(response, "Empty POST Template")
 
     def test_empty_post(self):
         "POST an empty dictionary to a view"
-        response = self.client.post('/post_view/', {})
+        response = self.client.post("/post_view/", {})
 
         # Check some response details
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.templates[0].name, 'Empty POST Template')
-        self.assertTemplateNotUsed(response, 'Empty GET Template')
-        self.assertTemplateUsed(response, 'Empty POST Template')
+        self.assertEqual(response.templates[0].name, "Empty POST Template")
+        self.assertTemplateNotUsed(response, "Empty GET Template")
+        self.assertTemplateUsed(response, "Empty POST Template")
 
     def test_post(self):
         "POST some data to a view"
-        post_data = {
-            'value': 37
-        }
-        response = self.client.post('/post_view/', post_data)
+        post_data = {"value": 37}
+        response = self.client.post("/post_view/", post_data)
 
         # Check some response details
-        self.assertContains(response, 'Data received')
-        self.assertEqual(response.context['data'], '37')
-        self.assertEqual(response.templates[0].name, 'POST Template')
+        self.assertContains(response, "Data received")
+        self.assertEqual(response.context["data"], "37")
+        self.assertEqual(response.templates[0].name, "POST Template")
 
     def test_post_data_none(self):
         msg = (
@@ -125,13 +129,13 @@ class ClientTest(TestCase):
             "to pass an empty string or omit the value?"
         )
         with self.assertRaisesMessage(TypeError, msg):
-            self.client.post('/post_view/', {'value': None})
+            self.client.post("/post_view/", {"value": None})
 
     def test_json_serialization(self):
         """The test client serializes JSON data."""
-        methods = ('post', 'put', 'patch', 'delete')
+        methods = ("post", "put", "patch", "delete")
         tests = (
-            ({'value': 37}, {'value': 37}),
+            ({"value": 37}, {"value": 37}),
             ([37, True], [37, True]),
             ((37, False), [37, False]),
         )
@@ -141,9 +145,11 @@ class ClientTest(TestCase):
                     with self.subTest(data):
                         client_method = getattr(self.client, method)
                         method_name = method.upper()
-                        response = client_method('/json_view/', data, content_type='application/json')
-                        self.assertContains(response, 'Viewing %s page.' % method_name)
-                        self.assertEqual(response.context['data'], expected)
+                        response = client_method(
+                            "/json_view/", data, content_type="application/json"
+                        )
+                        self.assertContains(response, "Viewing %s page." % method_name)
+                        self.assertEqual(response.context["data"], expected)
 
     def test_json_encoder_argument(self):
         """The test Client accepts a json_encoder."""
@@ -154,29 +160,31 @@ class ClientTest(TestCase):
 
         client = self.client_class(json_encoder=mock_encoder)
         # Vendored tree JSON content types are accepted.
-        client.post('/json_view/', {'value': 37}, content_type='application/vnd.api+json')
+        client.post(
+            "/json_view/", {"value": 37}, content_type="application/vnd.api+json"
+        )
         self.assertTrue(mock_encoder.called)
         self.assertTrue(mock_encoding.encode.called)
 
     def test_put(self):
-        response = self.client.put('/put_view/', {'foo': 'bar'})
+        response = self.client.put("/put_view/", {"foo": "bar"})
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.templates[0].name, 'PUT Template')
-        self.assertEqual(response.context['data'], "{'foo': 'bar'}")
-        self.assertEqual(response.context['Content-Length'], '14')
+        self.assertEqual(response.templates[0].name, "PUT Template")
+        self.assertEqual(response.context["data"], "{'foo': 'bar'}")
+        self.assertEqual(response.context["Content-Length"], "14")
 
     def test_trace(self):
         """TRACE a view"""
-        response = self.client.trace('/trace_view/')
+        response = self.client.trace("/trace_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['method'], 'TRACE')
-        self.assertEqual(response.templates[0].name, 'TRACE Template')
+        self.assertEqual(response.context["method"], "TRACE")
+        self.assertEqual(response.templates[0].name, "TRACE Template")
 
     def test_response_headers(self):
         "Check the value of HTTP headers returned in a response"
         response = self.client.get("/header_view/")
 
-        self.assertEqual(response.headers['X-DJANGO-TEST'], 'Slartibartfast')
+        self.assertEqual(response.headers["X-DJANGO-TEST"], "Slartibartfast")
 
     def test_response_attached_request(self):
         """
@@ -185,8 +193,8 @@ class ClientTest(TestCase):
         """
         response = self.client.get("/header_view/")
 
-        self.assertTrue(hasattr(response, 'request'))
-        self.assertTrue(hasattr(response, 'wsgi_request'))
+        self.assertTrue(hasattr(response, "request"))
+        self.assertTrue(hasattr(response, "wsgi_request"))
         for key, value in response.request.items():
             self.assertIn(key, response.wsgi_request.environ)
             self.assertEqual(response.wsgi_request.environ[key], value)
@@ -195,328 +203,337 @@ class ClientTest(TestCase):
         """
         The response contains a ResolverMatch instance.
         """
-        response = self.client.get('/header_view/')
-        self.assertTrue(hasattr(response, 'resolver_match'))
+        response = self.client.get("/header_view/")
+        self.assertTrue(hasattr(response, "resolver_match"))
 
     def test_response_resolver_match_redirect_follow(self):
         """
         The response ResolverMatch instance contains the correct
         information when following redirects.
         """
-        response = self.client.get('/redirect_view/', follow=True)
-        self.assertEqual(response.resolver_match.url_name, 'get_view')
+        response = self.client.get("/redirect_view/", follow=True)
+        self.assertEqual(response.resolver_match.url_name, "get_view")
 
     def test_response_resolver_match_regular_view(self):
         """
         The response ResolverMatch instance contains the correct
         information when accessing a regular view.
         """
-        response = self.client.get('/get_view/')
-        self.assertEqual(response.resolver_match.url_name, 'get_view')
+        response = self.client.get("/get_view/")
+        self.assertEqual(response.resolver_match.url_name, "get_view")
 
     def test_response_resolver_match_class_based_view(self):
         """
         The response ResolverMatch instance can be used to access the CBV view
         class.
         """
-        response = self.client.get('/accounts/')
+        response = self.client.get("/accounts/")
         self.assertIs(response.resolver_match.func.view_class, RedirectView)
 
-    @modify_settings(MIDDLEWARE={'prepend': 'test_client.tests.middleware_urlconf'})
+    @modify_settings(MIDDLEWARE={"prepend": "test_client.tests.middleware_urlconf"})
     def test_response_resolver_match_middleware_urlconf(self):
-        response = self.client.get('/middleware_urlconf_view/')
-        self.assertEqual(response.resolver_match.url_name, 'middleware_urlconf_view')
+        response = self.client.get("/middleware_urlconf_view/")
+        self.assertEqual(response.resolver_match.url_name, "middleware_urlconf_view")
 
     def test_raw_post(self):
         "POST raw data (with a content type) to a view"
         test_doc = """<?xml version="1.0" encoding="utf-8"?>
         <library><book><title>Blink</title><author>Malcolm Gladwell</author></book></library>
         """
-        response = self.client.post('/raw_post_view/', test_doc, content_type='text/xml')
+        response = self.client.post(
+            "/raw_post_view/", test_doc, content_type="text/xml"
+        )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.templates[0].name, "Book template")
         self.assertEqual(response.content, b"Blink - Malcolm Gladwell")
 
     def test_insecure(self):
         "GET a URL through http"
-        response = self.client.get('/secure_view/', secure=False)
+        response = self.client.get("/secure_view/", secure=False)
         self.assertFalse(response.test_was_secure_request)
-        self.assertEqual(response.test_server_port, '80')
+        self.assertEqual(response.test_server_port, "80")
 
     def test_secure(self):
         "GET a URL through https"
-        response = self.client.get('/secure_view/', secure=True)
+        response = self.client.get("/secure_view/", secure=True)
         self.assertTrue(response.test_was_secure_request)
-        self.assertEqual(response.test_server_port, '443')
+        self.assertEqual(response.test_server_port, "443")
 
     def test_redirect(self):
         "GET a URL that redirects elsewhere"
-        response = self.client.get('/redirect_view/')
-        self.assertRedirects(response, '/get_view/')
+        response = self.client.get("/redirect_view/")
+        self.assertRedirects(response, "/get_view/")
 
     def test_redirect_with_query(self):
         "GET a URL that redirects with given GET parameters"
-        response = self.client.get('/redirect_view/', {'var': 'value'})
-        self.assertRedirects(response, '/get_view/?var=value')
+        response = self.client.get("/redirect_view/", {"var": "value"})
+        self.assertRedirects(response, "/get_view/?var=value")
 
     def test_redirect_with_query_ordering(self):
         """assertRedirects() ignores the order of query string parameters."""
-        response = self.client.get('/redirect_view/', {'var': 'value', 'foo': 'bar'})
-        self.assertRedirects(response, '/get_view/?var=value&foo=bar')
-        self.assertRedirects(response, '/get_view/?foo=bar&var=value')
+        response = self.client.get("/redirect_view/", {"var": "value", "foo": "bar"})
+        self.assertRedirects(response, "/get_view/?var=value&foo=bar")
+        self.assertRedirects(response, "/get_view/?foo=bar&var=value")
 
     def test_permanent_redirect(self):
         "GET a URL that redirects permanently elsewhere"
-        response = self.client.get('/permanent_redirect_view/')
-        self.assertRedirects(response, '/get_view/', status_code=301)
+        response = self.client.get("/permanent_redirect_view/")
+        self.assertRedirects(response, "/get_view/", status_code=301)
 
     def test_temporary_redirect(self):
         "GET a URL that does a non-permanent redirect"
-        response = self.client.get('/temporary_redirect_view/')
-        self.assertRedirects(response, '/get_view/', status_code=302)
+        response = self.client.get("/temporary_redirect_view/")
+        self.assertRedirects(response, "/get_view/", status_code=302)
 
     def test_redirect_to_strange_location(self):
         "GET a URL that redirects to a non-200 page"
-        response = self.client.get('/double_redirect_view/')
+        response = self.client.get("/double_redirect_view/")
         # The response was a 302, and that the attempt to get the redirection
         # location returned 301 when retrieved
-        self.assertRedirects(response, '/permanent_redirect_view/', target_status_code=301)
+        self.assertRedirects(
+            response, "/permanent_redirect_view/", target_status_code=301
+        )
 
     def test_follow_redirect(self):
         "A URL that redirects can be followed to termination."
-        response = self.client.get('/double_redirect_view/', follow=True)
-        self.assertRedirects(response, '/get_view/', status_code=302, target_status_code=200)
+        response = self.client.get("/double_redirect_view/", follow=True)
+        self.assertRedirects(
+            response, "/get_view/", status_code=302, target_status_code=200
+        )
         self.assertEqual(len(response.redirect_chain), 2)
 
     def test_follow_relative_redirect(self):
         "A URL with a relative redirect can be followed."
-        response = self.client.get('/accounts/', follow=True)
+        response = self.client.get("/accounts/", follow=True)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.request['PATH_INFO'], '/accounts/login/')
+        self.assertEqual(response.request["PATH_INFO"], "/accounts/login/")
 
     def test_follow_relative_redirect_no_trailing_slash(self):
         "A URL with a relative redirect with no trailing slash can be followed."
-        response = self.client.get('/accounts/no_trailing_slash', follow=True)
+        response = self.client.get("/accounts/no_trailing_slash", follow=True)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.request['PATH_INFO'], '/accounts/login/')
+        self.assertEqual(response.request["PATH_INFO"], "/accounts/login/")
 
     def test_redirect_to_querystring_only(self):
         """A URL that consists of a querystring only can be followed"""
-        response = self.client.post('/post_then_get_view/', follow=True)
+        response = self.client.post("/post_then_get_view/", follow=True)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.request['PATH_INFO'], '/post_then_get_view/')
-        self.assertEqual(response.content, b'The value of success is true.')
+        self.assertEqual(response.request["PATH_INFO"], "/post_then_get_view/")
+        self.assertEqual(response.content, b"The value of success is true.")
 
     def test_follow_307_and_308_redirect(self):
         """
         A 307 or 308 redirect preserves the request method after the redirect.
         """
-        methods = ('get', 'post', 'head', 'options', 'put', 'patch', 'delete', 'trace')
+        methods = ("get", "post", "head", "options", "put", "patch", "delete", "trace")
         codes = (307, 308)
         for method, code in itertools.product(methods, codes):
             with self.subTest(method=method, code=code):
                 req_method = getattr(self.client, method)
-                response = req_method('/redirect_view_%s/' % code, data={'value': 'test'}, follow=True)
+                response = req_method(
+                    "/redirect_view_%s/" % code, data={"value": "test"}, follow=True
+                )
                 self.assertEqual(response.status_code, 200)
-                self.assertEqual(response.request['PATH_INFO'], '/post_view/')
-                self.assertEqual(response.request['REQUEST_METHOD'], method.upper())
+                self.assertEqual(response.request["PATH_INFO"], "/post_view/")
+                self.assertEqual(response.request["REQUEST_METHOD"], method.upper())
 
     def test_follow_307_and_308_preserves_query_string(self):
-        methods = ('post', 'options', 'put', 'patch', 'delete', 'trace')
+        methods = ("post", "options", "put", "patch", "delete", "trace")
         codes = (307, 308)
         for method, code in itertools.product(methods, codes):
             with self.subTest(method=method, code=code):
                 req_method = getattr(self.client, method)
                 response = req_method(
-                    '/redirect_view_%s_query_string/' % code,
-                    data={'value': 'test'},
+                    "/redirect_view_%s_query_string/" % code,
+                    data={"value": "test"},
                     follow=True,
                 )
-                self.assertRedirects(response, '/post_view/?hello=world', status_code=code)
-                self.assertEqual(response.request['QUERY_STRING'], 'hello=world')
+                self.assertRedirects(
+                    response, "/post_view/?hello=world", status_code=code
+                )
+                self.assertEqual(response.request["QUERY_STRING"], "hello=world")
 
     def test_follow_307_and_308_get_head_query_string(self):
-        methods = ('get', 'head')
+        methods = ("get", "head")
         codes = (307, 308)
         for method, code in itertools.product(methods, codes):
             with self.subTest(method=method, code=code):
                 req_method = getattr(self.client, method)
                 response = req_method(
-                    '/redirect_view_%s_query_string/' % code,
-                    data={'value': 'test'},
+                    "/redirect_view_%s_query_string/" % code,
+                    data={"value": "test"},
                     follow=True,
                 )
-                self.assertRedirects(response, '/post_view/?hello=world', status_code=code)
-                self.assertEqual(response.request['QUERY_STRING'], 'value=test')
+                self.assertRedirects(
+                    response, "/post_view/?hello=world", status_code=code
+                )
+                self.assertEqual(response.request["QUERY_STRING"], "value=test")
 
     def test_follow_307_and_308_preserves_post_data(self):
         for code in (307, 308):
             with self.subTest(code=code):
-                response = self.client.post('/redirect_view_%s/' % code, data={'value': 'test'}, follow=True)
-                self.assertContains(response, 'test is the value')
+                response = self.client.post(
+                    "/redirect_view_%s/" % code, data={"value": "test"}, follow=True
+                )
+                self.assertContains(response, "test is the value")
 
     def test_follow_307_and_308_preserves_put_body(self):
         for code in (307, 308):
             with self.subTest(code=code):
-                response = self.client.put('/redirect_view_%s/?to=/put_view/' % code, data='a=b', follow=True)
-                self.assertContains(response, 'a=b is the body')
+                response = self.client.put(
+                    "/redirect_view_%s/?to=/put_view/" % code, data="a=b", follow=True
+                )
+                self.assertContains(response, "a=b is the body")
 
     def test_follow_307_and_308_preserves_get_params(self):
-        data = {'var': 30, 'to': '/get_view/'}
+        data = {"var": 30, "to": "/get_view/"}
         for code in (307, 308):
             with self.subTest(code=code):
-                response = self.client.get('/redirect_view_%s/' % code, data=data, follow=True)
-                self.assertContains(response, '30 is the value')
+                response = self.client.get(
+                    "/redirect_view_%s/" % code, data=data, follow=True
+                )
+                self.assertContains(response, "30 is the value")
 
     def test_redirect_http(self):
         """GET a URL that redirects to an HTTP URI."""
-        response = self.client.get('/http_redirect_view/', follow=True)
+        response = self.client.get("/http_redirect_view/", follow=True)
         self.assertFalse(response.test_was_secure_request)
 
     def test_redirect_https(self):
         """GET a URL that redirects to an HTTPS URI."""
-        response = self.client.get('/https_redirect_view/', follow=True)
+        response = self.client.get("/https_redirect_view/", follow=True)
         self.assertTrue(response.test_was_secure_request)
 
     def test_notfound_response(self):
         "GET a URL that responds as '404:Not Found'"
-        response = self.client.get('/bad_view/')
-        self.assertContains(response, 'MAGIC', status_code=404)
+        response = self.client.get("/bad_view/")
+        self.assertContains(response, "MAGIC", status_code=404)
 
     def test_valid_form(self):
         "POST valid data to a form"
         post_data = {
-            'text': 'Hello World',
-            'email': 'foo@example.com',
-            'value': 37,
-            'single': 'b',
-            'multi': ('b', 'c', 'e')
+            "text": "Hello World",
+            "email": "foo@example.com",
+            "value": 37,
+            "single": "b",
+            "multi": ("b", "c", "e"),
         }
-        response = self.client.post('/form_view/', post_data)
+        response = self.client.post("/form_view/", post_data)
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "Valid POST Template")
 
     def test_valid_form_with_hints(self):
         "GET a form, providing hints in the GET data"
-        hints = {
-            'text': 'Hello World',
-            'multi': ('b', 'c', 'e')
-        }
-        response = self.client.get('/form_view/', data=hints)
+        hints = {"text": "Hello World", "multi": ("b", "c", "e")}
+        response = self.client.get("/form_view/", data=hints)
         # The multi-value data has been rolled out ok
-        self.assertContains(response, 'Select a valid choice.', 0)
+        self.assertContains(response, "Select a valid choice.", 0)
         self.assertTemplateUsed(response, "Form GET Template")
 
     def test_incomplete_data_form(self):
         "POST incomplete data to a form"
-        post_data = {
-            'text': 'Hello World',
-            'value': 37
-        }
-        response = self.client.post('/form_view/', post_data)
-        self.assertContains(response, 'This field is required.', 3)
+        post_data = {"text": "Hello World", "value": 37}
+        response = self.client.post("/form_view/", post_data)
+        self.assertContains(response, "This field is required.", 3)
         self.assertTemplateUsed(response, "Invalid POST Template")
 
-        self.assertFormError(response, 'form', 'email', 'This field is required.')
-        self.assertFormError(response, 'form', 'single', 'This field is required.')
-        self.assertFormError(response, 'form', 'multi', 'This field is required.')
+        self.assertFormError(response, "form", "email", "This field is required.")
+        self.assertFormError(response, "form", "single", "This field is required.")
+        self.assertFormError(response, "form", "multi", "This field is required.")
 
     def test_form_error(self):
         "POST erroneous data to a form"
         post_data = {
-            'text': 'Hello World',
-            'email': 'not an email address',
-            'value': 37,
-            'single': 'b',
-            'multi': ('b', 'c', 'e')
+            "text": "Hello World",
+            "email": "not an email address",
+            "value": 37,
+            "single": "b",
+            "multi": ("b", "c", "e"),
         }
-        response = self.client.post('/form_view/', post_data)
+        response = self.client.post("/form_view/", post_data)
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "Invalid POST Template")
 
-        self.assertFormError(response, 'form', 'email', 'Enter a valid email address.')
+        self.assertFormError(response, "form", "email", "Enter a valid email address.")
 
     def test_valid_form_with_template(self):
         "POST valid data to a form using multiple templates"
         post_data = {
-            'text': 'Hello World',
-            'email': 'foo@example.com',
-            'value': 37,
-            'single': 'b',
-            'multi': ('b', 'c', 'e')
+            "text": "Hello World",
+            "email": "foo@example.com",
+            "value": 37,
+            "single": "b",
+            "multi": ("b", "c", "e"),
         }
-        response = self.client.post('/form_view_with_template/', post_data)
-        self.assertContains(response, 'POST data OK')
+        response = self.client.post("/form_view_with_template/", post_data)
+        self.assertContains(response, "POST data OK")
         self.assertTemplateUsed(response, "form_view.html")
-        self.assertTemplateUsed(response, 'base.html')
+        self.assertTemplateUsed(response, "base.html")
         self.assertTemplateNotUsed(response, "Valid POST Template")
 
     def test_incomplete_data_form_with_template(self):
         "POST incomplete data to a form using multiple templates"
-        post_data = {
-            'text': 'Hello World',
-            'value': 37
-        }
-        response = self.client.post('/form_view_with_template/', post_data)
-        self.assertContains(response, 'POST data has errors')
-        self.assertTemplateUsed(response, 'form_view.html')
-        self.assertTemplateUsed(response, 'base.html')
+        post_data = {"text": "Hello World", "value": 37}
+        response = self.client.post("/form_view_with_template/", post_data)
+        self.assertContains(response, "POST data has errors")
+        self.assertTemplateUsed(response, "form_view.html")
+        self.assertTemplateUsed(response, "base.html")
         self.assertTemplateNotUsed(response, "Invalid POST Template")
 
-        self.assertFormError(response, 'form', 'email', 'This field is required.')
-        self.assertFormError(response, 'form', 'single', 'This field is required.')
-        self.assertFormError(response, 'form', 'multi', 'This field is required.')
+        self.assertFormError(response, "form", "email", "This field is required.")
+        self.assertFormError(response, "form", "single", "This field is required.")
+        self.assertFormError(response, "form", "multi", "This field is required.")
 
     def test_form_error_with_template(self):
         "POST erroneous data to a form using multiple templates"
         post_data = {
-            'text': 'Hello World',
-            'email': 'not an email address',
-            'value': 37,
-            'single': 'b',
-            'multi': ('b', 'c', 'e')
+            "text": "Hello World",
+            "email": "not an email address",
+            "value": 37,
+            "single": "b",
+            "multi": ("b", "c", "e"),
         }
-        response = self.client.post('/form_view_with_template/', post_data)
-        self.assertContains(response, 'POST data has errors')
+        response = self.client.post("/form_view_with_template/", post_data)
+        self.assertContains(response, "POST data has errors")
         self.assertTemplateUsed(response, "form_view.html")
-        self.assertTemplateUsed(response, 'base.html')
+        self.assertTemplateUsed(response, "base.html")
         self.assertTemplateNotUsed(response, "Invalid POST Template")
 
-        self.assertFormError(response, 'form', 'email', 'Enter a valid email address.')
+        self.assertFormError(response, "form", "email", "Enter a valid email address.")
 
     def test_unknown_page(self):
         "GET an invalid URL"
-        response = self.client.get('/unknown_view/')
+        response = self.client.get("/unknown_view/")
 
         # The response was a 404
         self.assertEqual(response.status_code, 404)
 
     def test_url_parameters(self):
         "Make sure that URL ;-parameters are not stripped."
-        response = self.client.get('/unknown_view/;some-parameter')
+        response = self.client.get("/unknown_view/;some-parameter")
 
         # The path in the response includes it (ignore that it's a 404)
-        self.assertEqual(response.request['PATH_INFO'], '/unknown_view/;some-parameter')
+        self.assertEqual(response.request["PATH_INFO"], "/unknown_view/;some-parameter")
 
     def test_view_with_login(self):
         "Request a page that is protected with @login_required"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     @override_settings(
-        INSTALLED_APPS=['django.contrib.auth'],
-        SESSION_ENGINE='django.contrib.sessions.backends.file',
+        INSTALLED_APPS=["django.contrib.auth"],
+        SESSION_ENGINE="django.contrib.sessions.backends.file",
     )
     def test_view_with_login_when_sessions_app_is_not_installed(self):
         self.test_view_with_login()
@@ -524,62 +541,69 @@ class ClientTest(TestCase):
     def test_view_with_force_login(self):
         "Request a page that is protected with @login_required"
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
         # Log in
         self.client.force_login(self.u1)
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     def test_view_with_method_login(self):
         "Request a page that is protected with a @login_required method"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_method_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_method_view/')
+        response = self.client.get("/login_protected_method_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/login_protected_method_view/"
+        )
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_method_view/')
+        response = self.client.get("/login_protected_method_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     def test_view_with_method_force_login(self):
         "Request a page that is protected with a @login_required method"
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_method_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_method_view/')
+        response = self.client.get("/login_protected_method_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/login_protected_method_view/"
+        )
 
         # Log in
         self.client.force_login(self.u1)
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_method_view/')
+        response = self.client.get("/login_protected_method_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     def test_view_with_login_and_custom_redirect(self):
         "Request a page that is protected with @login_required(redirect_field_name='redirect_to')"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view_custom_redirect/')
-        self.assertRedirects(response, '/accounts/login/?redirect_to=/login_protected_view_custom_redirect/')
+        response = self.client.get("/login_protected_view_custom_redirect/")
+        self.assertRedirects(
+            response,
+            "/accounts/login/?redirect_to=/login_protected_view_custom_redirect/",
+        )
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view_custom_redirect/')
+        response = self.client.get("/login_protected_view_custom_redirect/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     def test_view_with_force_login_and_custom_redirect(self):
         """
@@ -587,70 +611,79 @@ class ClientTest(TestCase):
         @login_required(redirect_field_name='redirect_to')
         """
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view_custom_redirect/')
-        self.assertRedirects(response, '/accounts/login/?redirect_to=/login_protected_view_custom_redirect/')
+        response = self.client.get("/login_protected_view_custom_redirect/")
+        self.assertRedirects(
+            response,
+            "/accounts/login/?redirect_to=/login_protected_view_custom_redirect/",
+        )
 
         # Log in
         self.client.force_login(self.u1)
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view_custom_redirect/')
+        response = self.client.get("/login_protected_view_custom_redirect/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     def test_view_with_bad_login(self):
         "Request a page that is protected with @login, but use bad credentials"
 
-        login = self.client.login(username='otheruser', password='nopassword')
+        login = self.client.login(username="otheruser", password="nopassword")
         self.assertFalse(login)
 
     def test_view_with_inactive_login(self):
         """
         An inactive user may login if the authenticate backend allows it.
         """
-        credentials = {'username': 'inactive', 'password': 'password'}
+        credentials = {"username": "inactive", "password": "password"}
         self.assertFalse(self.client.login(**credentials))
 
-        with self.settings(AUTHENTICATION_BACKENDS=['django.contrib.auth.backends.AllowAllUsersModelBackend']):
+        with self.settings(
+            AUTHENTICATION_BACKENDS=[
+                "django.contrib.auth.backends.AllowAllUsersModelBackend"
+            ]
+        ):
             self.assertTrue(self.client.login(**credentials))
 
     @override_settings(
         AUTHENTICATION_BACKENDS=[
-            'django.contrib.auth.backends.ModelBackend',
-            'django.contrib.auth.backends.AllowAllUsersModelBackend',
+            "django.contrib.auth.backends.ModelBackend",
+            "django.contrib.auth.backends.AllowAllUsersModelBackend",
         ]
     )
     def test_view_with_inactive_force_login(self):
         "Request a page that is protected with @login, but use an inactive login"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
         # Log in
-        self.client.force_login(self.u2, backend='django.contrib.auth.backends.AllowAllUsersModelBackend')
+        self.client.force_login(
+            self.u2, backend="django.contrib.auth.backends.AllowAllUsersModelBackend"
+        )
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'inactive')
+        self.assertEqual(response.context["user"].username, "inactive")
 
     def test_logout(self):
         "Request a logout after logging in"
         # Log in
-        self.client.login(username='testclient', password='password')
+        self.client.login(username="testclient", password="password")
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
         # Log out
         self.client.logout()
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
     def test_logout_with_force_login(self):
         "Request a logout after logging in"
@@ -658,21 +691,21 @@ class ClientTest(TestCase):
         self.client.force_login(self.u1)
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
         # Log out
         self.client.logout()
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
     @override_settings(
         AUTHENTICATION_BACKENDS=[
-            'django.contrib.auth.backends.ModelBackend',
-            'test_client.auth_backends.TestClientBackend',
+            "django.contrib.auth.backends.ModelBackend",
+            "test_client.auth_backends.TestClientBackend",
         ],
     )
     def test_force_login_with_backend(self):
@@ -681,22 +714,24 @@ class ClientTest(TestCase):
         force_login() and passing a backend.
         """
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/login_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
+        self.assertRedirects(response, "/accounts/login/?next=/login_protected_view/")
 
         # Log in
-        self.client.force_login(self.u1, backend='test_client.auth_backends.TestClientBackend')
-        self.assertEqual(self.u1.backend, 'test_client.auth_backends.TestClientBackend')
+        self.client.force_login(
+            self.u1, backend="test_client.auth_backends.TestClientBackend"
+        )
+        self.assertEqual(self.u1.backend, "test_client.auth_backends.TestClientBackend")
 
         # Request a page that requires a login
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
+        self.assertEqual(response.context["user"].username, "testclient")
 
     @override_settings(
         AUTHENTICATION_BACKENDS=[
-            'django.contrib.auth.backends.ModelBackend',
-            'test_client.auth_backends.TestClientBackend',
+            "django.contrib.auth.backends.ModelBackend",
+            "test_client.auth_backends.TestClientBackend",
         ],
     )
     def test_force_login_without_backend(self):
@@ -705,21 +740,23 @@ class ClientTest(TestCase):
         configured should automatically use the first backend.
         """
         self.client.force_login(self.u1)
-        response = self.client.get('/login_protected_view/')
+        response = self.client.get("/login_protected_view/")
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context['user'].username, 'testclient')
-        self.assertEqual(self.u1.backend, 'django.contrib.auth.backends.ModelBackend')
+        self.assertEqual(response.context["user"].username, "testclient")
+        self.assertEqual(self.u1.backend, "django.contrib.auth.backends.ModelBackend")
 
-    @override_settings(AUTHENTICATION_BACKENDS=[
-        'test_client.auth_backends.BackendWithoutGetUserMethod',
-        'django.contrib.auth.backends.ModelBackend',
-    ])
+    @override_settings(
+        AUTHENTICATION_BACKENDS=[
+            "test_client.auth_backends.BackendWithoutGetUserMethod",
+            "django.contrib.auth.backends.ModelBackend",
+        ]
+    )
     def test_force_login_with_backend_missing_get_user(self):
         """
         force_login() skips auth backends without a get_user() method.
         """
         self.client.force_login(self.u1)
-        self.assertEqual(self.u1.backend, 'django.contrib.auth.backends.ModelBackend')
+        self.assertEqual(self.u1.backend, "django.contrib.auth.backends.ModelBackend")
 
     @override_settings(SESSION_ENGINE="django.contrib.sessions.backends.signed_cookies")
     def test_logout_cookie_sessions(self):
@@ -729,16 +766,20 @@ class ClientTest(TestCase):
         "Request a page that is protected with @permission_required"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/permission_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/permission_protected_view/')
+        response = self.client.get("/permission_protected_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/permission_protected_view/"
+        )
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Log in with wrong permissions. Should result in 302.
-        response = self.client.get('/permission_protected_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/permission_protected_view/')
+        response = self.client.get("/permission_protected_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/permission_protected_view/"
+        )
 
         # TODO: Log in with right permissions and request the page again
 
@@ -746,51 +787,57 @@ class ClientTest(TestCase):
         "Request a page that is protected with @permission_required but raises an exception"
 
         # Get the page without logging in. Should result in 403.
-        response = self.client.get('/permission_protected_view_exception/')
+        response = self.client.get("/permission_protected_view_exception/")
         self.assertEqual(response.status_code, 403)
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Log in with wrong permissions. Should result in 403.
-        response = self.client.get('/permission_protected_view_exception/')
+        response = self.client.get("/permission_protected_view_exception/")
         self.assertEqual(response.status_code, 403)
 
     def test_view_with_method_permissions(self):
         "Request a page that is protected with a @permission_required method"
 
         # Get the page without logging in. Should result in 302.
-        response = self.client.get('/permission_protected_method_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/permission_protected_method_view/')
+        response = self.client.get("/permission_protected_method_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/permission_protected_method_view/"
+        )
 
         # Log in
-        login = self.client.login(username='testclient', password='password')
-        self.assertTrue(login, 'Could not log in')
+        login = self.client.login(username="testclient", password="password")
+        self.assertTrue(login, "Could not log in")
 
         # Log in with wrong permissions. Should result in 302.
-        response = self.client.get('/permission_protected_method_view/')
-        self.assertRedirects(response, '/accounts/login/?next=/permission_protected_method_view/')
+        response = self.client.get("/permission_protected_method_view/")
+        self.assertRedirects(
+            response, "/accounts/login/?next=/permission_protected_method_view/"
+        )
 
         # TODO: Log in with right permissions and request the page again
 
     def test_external_redirect(self):
-        response = self.client.get('/django_project_redirect/')
-        self.assertRedirects(response, 'https://www.djangoproject.com/', fetch_redirect_response=False)
+        response = self.client.get("/django_project_redirect/")
+        self.assertRedirects(
+            response, "https://www.djangoproject.com/", fetch_redirect_response=False
+        )
 
     def test_external_redirect_without_trailing_slash(self):
         """
         Client._handle_redirects() with an empty path.
         """
-        response = self.client.get('/no_trailing_slash_external_redirect/', follow=True)
-        self.assertRedirects(response, 'https://testserver')
+        response = self.client.get("/no_trailing_slash_external_redirect/", follow=True)
+        self.assertRedirects(response, "https://testserver")
 
     def test_external_redirect_with_fetch_error_msg(self):
         """
         assertRedirects without fetch_redirect_response=False raises
         a relevant ValueError rather than a non-descript AssertionError.
         """
-        response = self.client.get('/django_project_redirect/')
+        response = self.client.get("/django_project_redirect/")
         msg = (
             "The test client is unable to fetch remote URLs (got "
             "https://www.djangoproject.com/). If the host is served by Django, "
@@ -798,31 +845,31 @@ class ClientTest(TestCase):
             "Otherwise, use assertRedirects(..., fetch_redirect_response=False)."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            self.assertRedirects(response, 'https://www.djangoproject.com/')
+            self.assertRedirects(response, "https://www.djangoproject.com/")
 
     def test_session_modifying_view(self):
         "Request a page that modifies the session"
         # Session value isn't set initially
         with self.assertRaises(KeyError):
-            self.client.session['tobacconist']
+            self.client.session["tobacconist"]
 
-        self.client.post('/session_view/')
+        self.client.post("/session_view/")
         # The session was modified
-        self.assertEqual(self.client.session['tobacconist'], 'hovercraft')
+        self.assertEqual(self.client.session["tobacconist"], "hovercraft")
 
     @override_settings(
         INSTALLED_APPS=[],
-        SESSION_ENGINE='django.contrib.sessions.backends.file',
+        SESSION_ENGINE="django.contrib.sessions.backends.file",
     )
     def test_sessions_app_is_not_installed(self):
         self.test_session_modifying_view()
 
     @override_settings(
         INSTALLED_APPS=[],
-        SESSION_ENGINE='django.contrib.sessions.backends.nonexistent',
+        SESSION_ENGINE="django.contrib.sessions.backends.nonexistent",
     )
     def test_session_engine_is_invalid(self):
-        with self.assertRaisesMessage(ImportError, 'nonexistent'):
+        with self.assertRaisesMessage(ImportError, "nonexistent"):
             self.test_session_modifying_view()
 
     def test_view_with_exception(self):
@@ -846,92 +893,91 @@ class ClientTest(TestCase):
 
     def test_mail_sending(self):
         "Mail is redirected to a dummy outbox during test setup"
-        response = self.client.get('/mail_sending_view/')
+        response = self.client.get("/mail_sending_view/")
         self.assertEqual(response.status_code, 200)
 
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].subject, 'Test message')
-        self.assertEqual(mail.outbox[0].body, 'This is a test email')
-        self.assertEqual(mail.outbox[0].from_email, 'from@example.com')
-        self.assertEqual(mail.outbox[0].to[0], 'first@example.com')
-        self.assertEqual(mail.outbox[0].to[1], 'second@example.com')
+        self.assertEqual(mail.outbox[0].subject, "Test message")
+        self.assertEqual(mail.outbox[0].body, "This is a test email")
+        self.assertEqual(mail.outbox[0].from_email, "from@example.com")
+        self.assertEqual(mail.outbox[0].to[0], "first@example.com")
+        self.assertEqual(mail.outbox[0].to[1], "second@example.com")
 
     def test_reverse_lazy_decodes(self):
         "reverse_lazy() works in the test client"
-        data = {'var': 'data'}
-        response = self.client.get(reverse_lazy('get_view'), data)
+        data = {"var": "data"}
+        response = self.client.get(reverse_lazy("get_view"), data)
 
         # Check some response details
-        self.assertContains(response, 'This is a test')
+        self.assertContains(response, "This is a test")
 
     def test_relative_redirect(self):
-        response = self.client.get('/accounts/')
-        self.assertRedirects(response, '/accounts/login/')
+        response = self.client.get("/accounts/")
+        self.assertRedirects(response, "/accounts/login/")
 
     def test_relative_redirect_no_trailing_slash(self):
-        response = self.client.get('/accounts/no_trailing_slash')
-        self.assertRedirects(response, '/accounts/login/')
+        response = self.client.get("/accounts/no_trailing_slash")
+        self.assertRedirects(response, "/accounts/login/")
 
     def test_mass_mail_sending(self):
         "Mass mail is redirected to a dummy outbox during test setup"
-        response = self.client.get('/mass_mail_sending_view/')
+        response = self.client.get("/mass_mail_sending_view/")
         self.assertEqual(response.status_code, 200)
 
         self.assertEqual(len(mail.outbox), 2)
-        self.assertEqual(mail.outbox[0].subject, 'First Test message')
-        self.assertEqual(mail.outbox[0].body, 'This is the first test email')
-        self.assertEqual(mail.outbox[0].from_email, 'from@example.com')
-        self.assertEqual(mail.outbox[0].to[0], 'first@example.com')
-        self.assertEqual(mail.outbox[0].to[1], 'second@example.com')
-
-        self.assertEqual(mail.outbox[1].subject, 'Second Test message')
-        self.assertEqual(mail.outbox[1].body, 'This is the second test email')
-        self.assertEqual(mail.outbox[1].from_email, 'from@example.com')
-        self.assertEqual(mail.outbox[1].to[0], 'second@example.com')
-        self.assertEqual(mail.outbox[1].to[1], 'third@example.com')
+        self.assertEqual(mail.outbox[0].subject, "First Test message")
+        self.assertEqual(mail.outbox[0].body, "This is the first test email")
+        self.assertEqual(mail.outbox[0].from_email, "from@example.com")
+        self.assertEqual(mail.outbox[0].to[0], "first@example.com")
+        self.assertEqual(mail.outbox[0].to[1], "second@example.com")
+
+        self.assertEqual(mail.outbox[1].subject, "Second Test message")
+        self.assertEqual(mail.outbox[1].body, "This is the second test email")
+        self.assertEqual(mail.outbox[1].from_email, "from@example.com")
+        self.assertEqual(mail.outbox[1].to[0], "second@example.com")
+        self.assertEqual(mail.outbox[1].to[1], "third@example.com")
 
     def test_exception_following_nested_client_request(self):
         """
         A nested test client request shouldn't clobber exception signals from
         the outer client request.
         """
-        with self.assertRaisesMessage(Exception, 'exception message'):
-            self.client.get('/nesting_exception_view/')
+        with self.assertRaisesMessage(Exception, "exception message"):
+            self.client.get("/nesting_exception_view/")
 
     def test_response_raises_multi_arg_exception(self):
         """A request may raise an exception with more than one required arg."""
         with self.assertRaises(TwoArgException) as cm:
-            self.client.get('/two_arg_exception/')
-        self.assertEqual(cm.exception.args, ('one', 'two'))
+            self.client.get("/two_arg_exception/")
+        self.assertEqual(cm.exception.args, ("one", "two"))
 
     def test_uploading_temp_file(self):
         with tempfile.TemporaryFile() as test_file:
-            response = self.client.post('/upload_view/', data={'temp_file': test_file})
-        self.assertEqual(response.content, b'temp_file')
+            response = self.client.post("/upload_view/", data={"temp_file": test_file})
+        self.assertEqual(response.content, b"temp_file")
 
     def test_uploading_named_temp_file(self):
         with tempfile.NamedTemporaryFile() as test_file:
             response = self.client.post(
-                '/upload_view/',
-                data={'named_temp_file': test_file},
+                "/upload_view/",
+                data={"named_temp_file": test_file},
             )
-        self.assertEqual(response.content, b'named_temp_file')
+        self.assertEqual(response.content, b"named_temp_file")
 
 
 @override_settings(
-    MIDDLEWARE=['django.middleware.csrf.CsrfViewMiddleware'],
-    ROOT_URLCONF='test_client.urls',
+    MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"],
+    ROOT_URLCONF="test_client.urls",
 )
 class CSRFEnabledClientTests(SimpleTestCase):
-
     def test_csrf_enabled_client(self):
         "A client can be instantiated with CSRF checks enabled"
         csrf_client = Client(enforce_csrf_checks=True)
         # The normal client allows the post
-        response = self.client.post('/post_view/', {})
+        response = self.client.post("/post_view/", {})
         self.assertEqual(response.status_code, 200)
         # The CSRF-enabled client rejects it
-        response = csrf_client.post('/post_view/', {})
+        response = csrf_client.post("/post_view/", {})
         self.assertEqual(response.status_code, 403)
 
 
@@ -951,20 +997,20 @@ def _generic_view(request):
     return HttpResponse(status=200)
 
 
-@override_settings(ROOT_URLCONF='test_client.urls')
+@override_settings(ROOT_URLCONF="test_client.urls")
 class RequestFactoryTest(SimpleTestCase):
     """Tests for the request factory."""
 
     # A mapping between names of HTTP/1.1 methods and their test views.
     http_methods_and_views = (
-        ('get', get_view),
-        ('post', post_view),
-        ('put', _generic_view),
-        ('patch', _generic_view),
-        ('delete', _generic_view),
-        ('head', _generic_view),
-        ('options', _generic_view),
-        ('trace', trace_view),
+        ("get", get_view),
+        ("post", post_view),
+        ("put", _generic_view),
+        ("patch", _generic_view),
+        ("delete", _generic_view),
+        ("head", _generic_view),
+        ("options", _generic_view),
+        ("trace", trace_view),
     )
     request_factory = RequestFactory()
 
@@ -972,7 +1018,7 @@ class RequestFactoryTest(SimpleTestCase):
         """The request factory implements all the HTTP/1.1 methods."""
         for method_name, view in self.http_methods_and_views:
             method = getattr(self.request_factory, method_name)
-            request = method('/somewhere/')
+            request = method("/somewhere/")
             response = view(request)
             self.assertEqual(response.status_code, 200)
 
@@ -980,13 +1026,13 @@ class RequestFactoryTest(SimpleTestCase):
         """
         The request factory returns a templated response for a GET request.
         """
-        request = self.request_factory.get('/somewhere/')
+        request = self.request_factory.get("/somewhere/")
         response = get_view(request)
-        self.assertContains(response, 'This is a test')
+        self.assertContains(response, "This is a test")
 
     def test_trace_request_from_factory(self):
         """The request factory returns an echo response for a TRACE request."""
-        url_path = '/somewhere/'
+        url_path = "/somewhere/"
         request = self.request_factory.trace(url_path)
         response = trace_view(request)
         protocol = request.META["SERVER_PROTOCOL"]
@@ -994,67 +1040,68 @@ class RequestFactoryTest(SimpleTestCase):
         self.assertContains(response, echoed_request_line)
 
 
-@override_settings(ROOT_URLCONF='test_client.urls')
+@override_settings(ROOT_URLCONF="test_client.urls")
 class AsyncClientTest(TestCase):
     async def test_response_resolver_match(self):
-        response = await self.async_client.get('/async_get_view/')
-        self.assertTrue(hasattr(response, 'resolver_match'))
-        self.assertEqual(response.resolver_match.url_name, 'async_get_view')
+        response = await self.async_client.get("/async_get_view/")
+        self.assertTrue(hasattr(response, "resolver_match"))
+        self.assertEqual(response.resolver_match.url_name, "async_get_view")
 
     @modify_settings(
-        MIDDLEWARE={'prepend': 'test_client.tests.async_middleware_urlconf'},
+        MIDDLEWARE={"prepend": "test_client.tests.async_middleware_urlconf"},
     )
     async def test_response_resolver_match_middleware_urlconf(self):
-        response = await self.async_client.get('/middleware_urlconf_view/')
-        self.assertEqual(response.resolver_match.url_name, 'middleware_urlconf_view')
+        response = await self.async_client.get("/middleware_urlconf_view/")
+        self.assertEqual(response.resolver_match.url_name, "middleware_urlconf_view")
 
     async def test_follow_parameter_not_implemented(self):
-        msg = 'AsyncClient request methods do not accept the follow parameter.'
+        msg = "AsyncClient request methods do not accept the follow parameter."
         tests = (
-            'get',
-            'post',
-            'put',
-            'patch',
-            'delete',
-            'head',
-            'options',
-            'trace',
+            "get",
+            "post",
+            "put",
+            "patch",
+            "delete",
+            "head",
+            "options",
+            "trace",
         )
         for method_name in tests:
             with self.subTest(method=method_name):
                 method = getattr(self.async_client, method_name)
                 with self.assertRaisesMessage(NotImplementedError, msg):
-                    await method('/redirect_view/', follow=True)
+                    await method("/redirect_view/", follow=True)
 
     async def test_get_data(self):
-        response = await self.async_client.get('/get_view/', {'var': 'val'})
-        self.assertContains(response, 'This is a test. val is the value.')
+        response = await self.async_client.get("/get_view/", {"var": "val"})
+        self.assertContains(response, "This is a test. val is the value.")
 
 
-@override_settings(ROOT_URLCONF='test_client.urls')
+@override_settings(ROOT_URLCONF="test_client.urls")
 class AsyncRequestFactoryTest(SimpleTestCase):
     request_factory = AsyncRequestFactory()
 
     async def test_request_factory(self):
         tests = (
-            'get',
-            'post',
-            'put',
-            'patch',
-            'delete',
-            'head',
-            'options',
-            'trace',
+            "get",
+            "post",
+            "put",
+            "patch",
+            "delete",
+            "head",
+            "options",
+            "trace",
         )
         for method_name in tests:
             with self.subTest(method=method_name):
+
                 async def async_generic_view(request):
                     if request.method.lower() != method_name:
                         return HttpResponseNotAllowed(method_name)
                     return HttpResponse(status=200)
 
                 method = getattr(self.request_factory, method_name)
-                request = method('/somewhere/')
+                request = method("/somewhere/")
                 response = await async_generic_view(request)
                 self.assertEqual(response.status_code, 200)
 
@@ -1063,28 +1110,28 @@ class AsyncRequestFactoryTest(SimpleTestCase):
             return HttpResponse(status=200, content=request.body)
 
         request = self.request_factory.post(
-            '/somewhere/',
-            data={'example': 'data'},
-            content_type='application/json',
+            "/somewhere/",
+            data={"example": "data"},
+            content_type="application/json",
         )
-        self.assertEqual(request.headers['content-length'], '19')
-        self.assertEqual(request.headers['content-type'], 'application/json')
+        self.assertEqual(request.headers["content-length"], "19")
+        self.assertEqual(request.headers["content-type"], "application/json")
         response = await async_generic_view(request)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content, b'{"example": "data"}')
 
     def test_request_factory_sets_headers(self):
         request = self.request_factory.get(
-            '/somewhere/',
-            AUTHORIZATION='Bearer faketoken',
-            X_ANOTHER_HEADER='some other value',
+            "/somewhere/",
+            AUTHORIZATION="Bearer faketoken",
+            X_ANOTHER_HEADER="some other value",
         )
-        self.assertEqual(request.headers['authorization'], 'Bearer faketoken')
-        self.assertIn('HTTP_AUTHORIZATION', request.META)
-        self.assertEqual(request.headers['x-another-header'], 'some other value')
-        self.assertIn('HTTP_X_ANOTHER_HEADER', request.META)
+        self.assertEqual(request.headers["authorization"], "Bearer faketoken")
+        self.assertIn("HTTP_AUTHORIZATION", request.META)
+        self.assertEqual(request.headers["x-another-header"], "some other value")
+        self.assertIn("HTTP_X_ANOTHER_HEADER", request.META)
 
     def test_request_factory_query_string(self):
-        request = self.request_factory.get('/somewhere/', {'example': 'data'})
-        self.assertNotIn('Query-String', request.headers)
-        self.assertEqual(request.GET['example'], 'data')
+        request = self.request_factory.get("/somewhere/", {"example": "data"})
+        self.assertNotIn("Query-String", request.headers)
+        self.assertEqual(request.GET["example"], "data")
diff --git a/tests/test_client/urls.py b/tests/test_client/urls.py
index 51f1fdbb72..9ccd219fb5 100644
--- a/tests/test_client/urls.py
+++ b/tests/test_client/urls.py
@@ -5,55 +5,75 @@ from django.views.generic import RedirectView
 from . import views
 
 urlpatterns = [
-    path('upload_view/', views.upload_view, name='upload_view'),
-    path('get_view/', views.get_view, name='get_view'),
-    path('post_view/', views.post_view),
-    path('post_then_get_view/', views.post_then_get_view),
-    path('put_view/', views.put_view),
-    path('trace_view/', views.trace_view),
-    path('header_view/', views.view_with_header),
-    path('raw_post_view/', views.raw_post_view),
-    path('redirect_view/', views.redirect_view),
-    path('redirect_view_307/', views.method_saving_307_redirect_view),
-    path(
-        'redirect_view_307_query_string/',
+    path("upload_view/", views.upload_view, name="upload_view"),
+    path("get_view/", views.get_view, name="get_view"),
+    path("post_view/", views.post_view),
+    path("post_then_get_view/", views.post_then_get_view),
+    path("put_view/", views.put_view),
+    path("trace_view/", views.trace_view),
+    path("header_view/", views.view_with_header),
+    path("raw_post_view/", views.raw_post_view),
+    path("redirect_view/", views.redirect_view),
+    path("redirect_view_307/", views.method_saving_307_redirect_view),
+    path(
+        "redirect_view_307_query_string/",
         views.method_saving_307_redirect_query_string_view,
     ),
-    path('redirect_view_308/', views.method_saving_308_redirect_view),
+    path("redirect_view_308/", views.method_saving_308_redirect_view),
     path(
-        'redirect_view_308_query_string/',
+        "redirect_view_308_query_string/",
         views.method_saving_308_redirect_query_string_view,
     ),
-    path('secure_view/', views.view_with_secure),
-    path('permanent_redirect_view/', RedirectView.as_view(url='/get_view/', permanent=True)),
-    path('temporary_redirect_view/', RedirectView.as_view(url='/get_view/', permanent=False)),
-    path('http_redirect_view/', RedirectView.as_view(url='/secure_view/')),
-    path('https_redirect_view/', RedirectView.as_view(url='https://testserver/secure_view/')),
-    path('double_redirect_view/', views.double_redirect_view),
-    path('bad_view/', views.bad_view),
-    path('form_view/', views.form_view),
-    path('form_view_with_template/', views.form_view_with_template),
-    path('formset_view/', views.formset_view),
-    path('json_view/', views.json_view),
-    path('login_protected_view/', views.login_protected_view),
-    path('login_protected_method_view/', views.login_protected_method_view),
-    path('login_protected_view_custom_redirect/', views.login_protected_view_changed_redirect),
-    path('permission_protected_view/', views.permission_protected_view),
-    path('permission_protected_view_exception/', views.permission_protected_view_exception),
-    path('permission_protected_method_view/', views.permission_protected_method_view),
-    path('session_view/', views.session_view),
-    path('broken_view/', views.broken_view),
-    path('mail_sending_view/', views.mail_sending_view),
-    path('mass_mail_sending_view/', views.mass_mail_sending_view),
-    path('nesting_exception_view/', views.nesting_exception_view),
-    path('django_project_redirect/', views.django_project_redirect),
-    path('no_trailing_slash_external_redirect/', views.no_trailing_slash_external_redirect),
-    path('', views.index_view, name='index'),  # Target for no_trailing_slash_external_redirect/ with follow=True
-    path('two_arg_exception/', views.two_arg_exception),
-    path('accounts/', RedirectView.as_view(url='login/')),
-    path('accounts/no_trailing_slash', RedirectView.as_view(url='login/')),
-    path('accounts/login/', auth_views.LoginView.as_view(template_name='login.html')),
-    path('accounts/logout/', auth_views.LogoutView.as_view()),
+    path("secure_view/", views.view_with_secure),
+    path(
+        "permanent_redirect_view/",
+        RedirectView.as_view(url="/get_view/", permanent=True),
+    ),
+    path(
+        "temporary_redirect_view/",
+        RedirectView.as_view(url="/get_view/", permanent=False),
+    ),
+    path("http_redirect_view/", RedirectView.as_view(url="/secure_view/")),
+    path(
+        "https_redirect_view/",
+        RedirectView.as_view(url="https://testserver/secure_view/"),
+    ),
+    path("double_redirect_view/", views.double_redirect_view),
+    path("bad_view/", views.bad_view),
+    path("form_view/", views.form_view),
+    path("form_view_with_template/", views.form_view_with_template),
+    path("formset_view/", views.formset_view),
+    path("json_view/", views.json_view),
+    path("login_protected_view/", views.login_protected_view),
+    path("login_protected_method_view/", views.login_protected_method_view),
+    path(
+        "login_protected_view_custom_redirect/",
+        views.login_protected_view_changed_redirect,
+    ),
+    path("permission_protected_view/", views.permission_protected_view),
+    path(
+        "permission_protected_view_exception/",
+        views.permission_protected_view_exception,
+    ),
+    path("permission_protected_method_view/", views.permission_protected_method_view),
+    path("session_view/", views.session_view),
+    path("broken_view/", views.broken_view),
+    path("mail_sending_view/", views.mail_sending_view),
+    path("mass_mail_sending_view/", views.mass_mail_sending_view),
+    path("nesting_exception_view/", views.nesting_exception_view),
+    path("django_project_redirect/", views.django_project_redirect),
+    path(
+        "no_trailing_slash_external_redirect/",
+        views.no_trailing_slash_external_redirect,
+    ),
+    path(
+        "", views.index_view, name="index"
+    ),  # Target for no_trailing_slash_external_redirect/ with follow=True
+    path("two_arg_exception/", views.two_arg_exception),
+    path("accounts/", RedirectView.as_view(url="login/")),
+    path("accounts/no_trailing_slash", RedirectView.as_view(url="login/")),
+    path("accounts/login/", auth_views.LoginView.as_view(template_name="login.html")),
+    path("accounts/logout/", auth_views.LogoutView.as_view()),
     # Async views.
-    path('async_get_view/', views.async_get_view, name='async_get_view'),
+    path("async_get_view/", views.async_get_view, name="async_get_view"),
 ]
diff --git a/tests/test_client/urls_middleware_urlconf.py b/tests/test_client/urls_middleware_urlconf.py
index 59893699f9..106d9e6584 100644
--- a/tests/test_client/urls_middleware_urlconf.py
+++ b/tests/test_client/urls_middleware_urlconf.py
@@ -7,5 +7,5 @@ def empty_response(request):
 
 
 urlpatterns = [
-    path('middleware_urlconf_view/', empty_response, name='middleware_urlconf_view'),
+    path("middleware_urlconf_view/", empty_response, name="middleware_urlconf_view"),
 ]
diff --git a/tests/test_client/views.py b/tests/test_client/views.py
index fa2bac2943..4dc58fab8d 100644
--- a/tests/test_client/views.py
+++ b/tests/test_client/views.py
@@ -9,8 +9,11 @@ from django.forms import fields
 from django.forms.forms import Form
 from django.forms.formsets import BaseFormSet, formset_factory
 from django.http import (
-    HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed,
-    HttpResponseNotFound, HttpResponseRedirect,
+    HttpResponse,
+    HttpResponseBadRequest,
+    HttpResponseNotAllowed,
+    HttpResponseNotFound,
+    HttpResponseRedirect,
 )
 from django.shortcuts import render
 from django.template import Context, Template
@@ -20,14 +23,14 @@ from django.utils.decorators import method_decorator
 
 def get_view(request):
     "A simple view that expects a GET request, and returns a rendered template"
-    t = Template('This is a test. {{ var }} is the value.', name='GET Template')
-    c = Context({'var': request.GET.get('var', 42)})
+    t = Template("This is a test. {{ var }} is the value.", name="GET Template")
+    c = Context({"var": request.GET.get("var", 42)})
 
     return HttpResponse(t.render(c))
 
 
 async def async_get_view(request):
-    return HttpResponse(b'GET content.')
+    return HttpResponse(b"GET content.")
 
 
 def trace_view(request):
@@ -44,26 +47,30 @@ def trace_view(request):
     else:
         protocol = request.META["SERVER_PROTOCOL"]
         t = Template(
-            '{{ method }} {{ uri }} {{ version }}',
+            "{{ method }} {{ uri }} {{ version }}",
             name="TRACE Template",
         )
-        c = Context({
-            'method': request.method,
-            'uri': request.path,
-            'version': protocol,
-        })
+        c = Context(
+            {
+                "method": request.method,
+                "uri": request.path,
+                "version": protocol,
+            }
+        )
         return HttpResponse(t.render(c))
 
 
 def put_view(request):
-    if request.method == 'PUT':
-        t = Template('Data received: {{ data }} is the body.', name='PUT Template')
-        c = Context({
-            'Content-Length': request.META['CONTENT_LENGTH'],
-            'data': request.body.decode(),
-        })
+    if request.method == "PUT":
+        t = Template("Data received: {{ data }} is the body.", name="PUT Template")
+        c = Context(
+            {
+                "Content-Length": request.META["CONTENT_LENGTH"],
+                "data": request.body.decode(),
+            }
+        )
     else:
-        t = Template('Viewing GET page.', name='Empty GET Template')
+        t = Template("Viewing GET page.", name="Empty GET Template")
         c = Context()
     return HttpResponse(t.render(c))
 
@@ -72,15 +79,17 @@ def post_view(request):
     """A view that expects a POST, and returns a different template depending
     on whether any POST data is available
     """
-    if request.method == 'POST':
+    if request.method == "POST":
         if request.POST:
-            t = Template('Data received: {{ data }} is the value.', name='POST Template')
-            c = Context({'data': request.POST['value']})
+            t = Template(
+                "Data received: {{ data }} is the value.", name="POST Template"
+            )
+            c = Context({"data": request.POST["value"]})
         else:
-            t = Template('Viewing POST page.', name='Empty POST Template')
+            t = Template("Viewing POST page.", name="Empty POST Template")
             c = Context()
     else:
-        t = Template('Viewing GET page.', name='Empty GET Template')
+        t = Template("Viewing GET page.", name="Empty GET Template")
         c = Context()
     return HttpResponse(t.render(c))
 
@@ -91,11 +100,11 @@ def post_then_get_view(request):
     to itself providing only a ?success=true querystring,
     the value of this querystring is then rendered upon GET.
     """
-    if request.method == 'POST':
-        return HttpResponseRedirect('?success=true')
+    if request.method == "POST":
+        return HttpResponseRedirect("?success=true")
 
-    t = Template('The value of success is {{ value }}.', name='GET Template')
-    c = Context({'value': request.GET.get('success', 'false')})
+    t = Template("The value of success is {{ value }}.", name="GET Template")
+    c = Context({"value": request.GET.get("success", "false")})
 
     return HttpResponse(t.render(c))
 
@@ -105,26 +114,26 @@ def json_view(request):
     A view that expects a request with the header 'application/json' and JSON
     data, which is deserialized and included in the context.
     """
-    if request.META.get('CONTENT_TYPE') != 'application/json':
+    if request.META.get("CONTENT_TYPE") != "application/json":
         return HttpResponse()
 
-    t = Template('Viewing {} page. With data {{ data }}.'.format(request.method))
-    data = json.loads(request.body.decode('utf-8'))
-    c = Context({'data': data})
+    t = Template("Viewing {} page. With data {{ data }}.".format(request.method))
+    data = json.loads(request.body.decode("utf-8"))
+    c = Context({"data": data})
     return HttpResponse(t.render(c))
 
 
 def view_with_header(request):
     "A view that has a custom header"
     response = HttpResponse()
-    response.headers['X-DJANGO-TEST'] = 'Slartibartfast'
+    response.headers["X-DJANGO-TEST"] = "Slartibartfast"
     return response
 
 
 def raw_post_view(request):
     """A view which expects raw XML to be posted and returns content extracted
     from the XML"""
-    if request.method == 'POST':
+    if request.method == "POST":
         root = parseString(request.body)
         first_book = root.firstChild.firstChild
         title, author = [n.firstChild.nodeValue for n in first_book.childNodes]
@@ -140,23 +149,23 @@ def raw_post_view(request):
 def redirect_view(request):
     "A view that redirects all requests to the GET view"
     if request.GET:
-        query = '?' + urlencode(request.GET, True)
+        query = "?" + urlencode(request.GET, True)
     else:
-        query = ''
-    return HttpResponseRedirect('/get_view/' + query)
+        query = ""
+    return HttpResponseRedirect("/get_view/" + query)
 
 
 def method_saving_307_redirect_query_string_view(request):
-    return HttpResponseRedirect('/post_view/?hello=world', status=307)
+    return HttpResponseRedirect("/post_view/?hello=world", status=307)
 
 
 def method_saving_308_redirect_query_string_view(request):
-    return HttpResponseRedirect('/post_view/?hello=world', status=308)
+    return HttpResponseRedirect("/post_view/?hello=world", status=308)
 
 
 def _post_view_redirect(request, status_code):
     """Redirect to /post_view/ using the status code."""
-    redirect_to = request.GET.get('to', '/post_view/')
+    redirect_to = request.GET.get("to", "/post_view/")
     return HttpResponseRedirect(redirect_to, status=status_code)
 
 
@@ -172,26 +181,26 @@ def view_with_secure(request):
     "A view that indicates if the request was secure"
     response = HttpResponse()
     response.test_was_secure_request = request.is_secure()
-    response.test_server_port = request.META.get('SERVER_PORT', 80)
+    response.test_server_port = request.META.get("SERVER_PORT", 80)
     return response
 
 
 def double_redirect_view(request):
     "A view that redirects all requests to a redirection view"
-    return HttpResponseRedirect('/permanent_redirect_view/')
+    return HttpResponseRedirect("/permanent_redirect_view/")
 
 
 def bad_view(request):
     "A view that returns a 404 with some error content"
-    return HttpResponseNotFound('Not found!. This page contains some MAGIC content')
+    return HttpResponseNotFound("Not found!. This page contains some MAGIC content")
 
 
 TestChoices = (
-    ('a', 'First Choice'),
-    ('b', 'Second Choice'),
-    ('c', 'Third Choice'),
-    ('d', 'Fourth Choice'),
-    ('e', 'Fifth Choice')
+    ("a", "First Choice"),
+    ("b", "Second Choice"),
+    ("c", "Third Choice"),
+    ("d", "Fourth Choice"),
+    ("e", "Fifth Choice"),
 )
 
 
@@ -211,37 +220,43 @@ class TestForm(Form):
 
 def form_view(request):
     "A view that tests a simple form"
-    if request.method == 'POST':
+    if request.method == "POST":
         form = TestForm(request.POST)
         if form.is_valid():
-            t = Template('Valid POST data.', name='Valid POST Template')
+            t = Template("Valid POST data.", name="Valid POST Template")
             c = Context()
         else:
-            t = Template('Invalid POST data. {{ form.errors }}', name='Invalid POST Template')
-            c = Context({'form': form})
+            t = Template(
+                "Invalid POST data. {{ form.errors }}", name="Invalid POST Template"
+            )
+            c = Context({"form": form})
     else:
         form = TestForm(request.GET)
-        t = Template('Viewing base form. {{ form }}.', name='Form GET Template')
-        c = Context({'form': form})
+        t = Template("Viewing base form. {{ form }}.", name="Form GET Template")
+        c = Context({"form": form})
 
     return HttpResponse(t.render(c))
 
 
 def form_view_with_template(request):
     "A view that tests a simple form"
-    if request.method == 'POST':
+    if request.method == "POST":
         form = TestForm(request.POST)
         if form.is_valid():
-            message = 'POST data OK'
+            message = "POST data OK"
         else:
-            message = 'POST data has errors'
+            message = "POST data has errors"
     else:
         form = TestForm()
-        message = 'GET form page'
-    return render(request, 'form_view.html', {
-        'form': form,
-        'message': message,
-    })
+        message = "GET form page"
+    return render(
+        request,
+        "form_view.html",
+        {
+            "form": form,
+            "message": message,
+        },
+    )
 
 
 class BaseTestFormSet(BaseFormSet):
@@ -253,7 +268,7 @@ class BaseTestFormSet(BaseFormSet):
 
         emails = []
         for form in self.forms:
-            email = form.cleaned_data['email']
+            email = form.cleaned_data["email"]
             if email in emails:
                 raise ValidationError(
                     "Forms in a set must have distinct email addresses."
@@ -266,72 +281,89 @@ TestFormSet = formset_factory(TestForm, BaseTestFormSet)
 
 def formset_view(request):
     "A view that tests a simple formset"
-    if request.method == 'POST':
+    if request.method == "POST":
         formset = TestFormSet(request.POST)
         if formset.is_valid():
-            t = Template('Valid POST data.', name='Valid POST Template')
+            t = Template("Valid POST data.", name="Valid POST Template")
             c = Context()
         else:
-            t = Template('Invalid POST data. {{ my_formset.errors }}',
-                         name='Invalid POST Template')
-            c = Context({'my_formset': formset})
+            t = Template(
+                "Invalid POST data. {{ my_formset.errors }}",
+                name="Invalid POST Template",
+            )
+            c = Context({"my_formset": formset})
     else:
         formset = TestForm(request.GET)
-        t = Template('Viewing base formset. {{ my_formset }}.',
-                     name='Formset GET Template')
-        c = Context({'my_formset': formset})
+        t = Template(
+            "Viewing base formset. {{ my_formset }}.", name="Formset GET Template"
+        )
+        c = Context({"my_formset": formset})
     return HttpResponse(t.render(c))
 
 
 @login_required
 def login_protected_view(request):
     "A simple view that is login protected."
-    t = Template('This is a login protected test. Username is {{ user.username }}.', name='Login Template')
-    c = Context({'user': request.user})
+    t = Template(
+        "This is a login protected test. Username is {{ user.username }}.",
+        name="Login Template",
+    )
+    c = Context({"user": request.user})
 
     return HttpResponse(t.render(c))
 
 
-@login_required(redirect_field_name='redirect_to')
+@login_required(redirect_field_name="redirect_to")
 def login_protected_view_changed_redirect(request):
     "A simple view that is login protected with a custom redirect field set"
-    t = Template('This is a login protected test. Username is {{ user.username }}.', name='Login Template')
-    c = Context({'user': request.user})
+    t = Template(
+        "This is a login protected test. Username is {{ user.username }}.",
+        name="Login Template",
+    )
+    c = Context({"user": request.user})
     return HttpResponse(t.render(c))
 
 
 def _permission_protected_view(request):
     "A simple view that is permission protected."
-    t = Template('This is a permission protected test. '
-                 'Username is {{ user.username }}. '
-                 'Permissions are {{ user.get_all_permissions }}.',
-                 name='Permissions Template')
-    c = Context({'user': request.user})
+    t = Template(
+        "This is a permission protected test. "
+        "Username is {{ user.username }}. "
+        "Permissions are {{ user.get_all_permissions }}.",
+        name="Permissions Template",
+    )
+    c = Context({"user": request.user})
     return HttpResponse(t.render(c))
 
 
-permission_protected_view = permission_required('permission_not_granted')(_permission_protected_view)
-permission_protected_view_exception = (
-    permission_required('permission_not_granted', raise_exception=True)(_permission_protected_view)
+permission_protected_view = permission_required("permission_not_granted")(
+    _permission_protected_view
 )
+permission_protected_view_exception = permission_required(
+    "permission_not_granted", raise_exception=True
+)(_permission_protected_view)
 
 
 class _ViewManager:
     @method_decorator(login_required)
     def login_protected_view(self, request):
-        t = Template('This is a login protected test using a method. '
-                     'Username is {{ user.username }}.',
-                     name='Login Method Template')
-        c = Context({'user': request.user})
+        t = Template(
+            "This is a login protected test using a method. "
+            "Username is {{ user.username }}.",
+            name="Login Method Template",
+        )
+        c = Context({"user": request.user})
         return HttpResponse(t.render(c))
 
-    @method_decorator(permission_required('permission_not_granted'))
+    @method_decorator(permission_required("permission_not_granted"))
     def permission_protected_view(self, request):
-        t = Template('This is a permission protected test using a method. '
-                     'Username is {{ user.username }}. '
-                     'Permissions are {{ user.get_all_permissions }}.',
-                     name='Permissions Template')
-        c = Context({'user': request.user})
+        t = Template(
+            "This is a permission protected test using a method. "
+            "Username is {{ user.username }}. "
+            "Permissions are {{ user.get_all_permissions }}.",
+            name="Permissions Template",
+        )
+        c = Context({"user": request.user})
         return HttpResponse(t.render(c))
 
 
@@ -342,10 +374,12 @@ permission_protected_method_view = _view_manager.permission_protected_view
 
 def session_view(request):
     "A view that modifies the session"
-    request.session['tobacconist'] = 'hovercraft'
+    request.session["tobacconist"] = "hovercraft"
 
-    t = Template('This is a view that modifies the session.',
-                 name='Session Modifying View Template')
+    t = Template(
+        "This is a view that modifies the session.",
+        name="Session Modifying View Template",
+    )
     c = Context()
     return HttpResponse(t.render(c))
 
@@ -360,21 +394,24 @@ def mail_sending_view(request):
         "Test message",
         "This is a test email",
         "from@example.com",
-        ['first@example.com', 'second@example.com']).send()
+        ["first@example.com", "second@example.com"],
+    ).send()
     return HttpResponse("Mail sent")
 
 
 def mass_mail_sending_view(request):
     m1 = mail.EmailMessage(
-        'First Test message',
-        'This is the first test email',
-        'from@example.com',
-        ['first@example.com', 'second@example.com'])
+        "First Test message",
+        "This is the first test email",
+        "from@example.com",
+        ["first@example.com", "second@example.com"],
+    )
     m2 = mail.EmailMessage(
-        'Second Test message',
-        'This is the second test email',
-        'from@example.com',
-        ['second@example.com', 'third@example.com'])
+        "Second Test message",
+        "This is the second test email",
+        "from@example.com",
+        ["second@example.com", "third@example.com"],
+    )
 
     c = mail.get_connection()
     c.send_messages([m1, m2])
@@ -388,12 +425,12 @@ def nesting_exception_view(request):
     exception.
     """
     client = Client()
-    client.get('/get_view/')
-    raise Exception('exception message')
+    client.get("/get_view/")
+    raise Exception("exception message")
 
 
 def django_project_redirect(request):
-    return HttpResponseRedirect('https://www.djangoproject.com/')
+    return HttpResponseRedirect("https://www.djangoproject.com/")
 
 
 def no_trailing_slash_external_redirect(request):
@@ -404,17 +441,17 @@ def no_trailing_slash_external_redirect(request):
     Use https://testserver, rather than an external domain, in order to allow
     use of follow=True, triggering Client._handle_redirects().
     """
-    return HttpResponseRedirect('https://testserver')
+    return HttpResponseRedirect("https://testserver")
 
 
 def index_view(request):
     """Target for no_trailing_slash_external_redirect with follow=True."""
-    return HttpResponse('Hello world')
+    return HttpResponse("Hello world")
 
 
 def upload_view(request):
     """Prints keys of request.FILES to the response."""
-    return HttpResponse(', '.join(request.FILES))
+    return HttpResponse(", ".join(request.FILES))
 
 
 class TwoArgException(Exception):
@@ -423,4 +460,4 @@ class TwoArgException(Exception):
 
 
 def two_arg_exception(request):
-    raise TwoArgException('one', 'two')
+    raise TwoArgException("one", "two")