Refs #33476 -- Reformatted code with Black.

1 files changed, 34 insertions, 32 deletions

diff --git a/tests/servers/test_basehttp.py b/tests/servers/test_basehttp.py
index b90e8565a6..a6e75a9c48 100644
--- a/tests/servers/test_basehttp.py
+++ b/tests/servers/test_basehttp.py
@@ -12,46 +12,48 @@ class Stub:
         self.__dict__.update(kwargs)
 
     def sendall(self, data):
-        self.makefile('wb').write(data)
+        self.makefile("wb").write(data)
 
 
 class WSGIRequestHandlerTestCase(SimpleTestCase):
     request_factory = RequestFactory()
 
     def test_log_message(self):
-        request = WSGIRequest(self.request_factory.get('/').environ)
+        request = WSGIRequest(self.request_factory.get("/").environ)
         request.makefile = lambda *args, **kwargs: BytesIO()
-        handler = WSGIRequestHandler(request, '192.168.0.2', None)
+        handler = WSGIRequestHandler(request, "192.168.0.2", None)
         level_status_codes = {
-            'info': [200, 301, 304],
-            'warning': [400, 403, 404],
-            'error': [500, 503],
+            "info": [200, 301, 304],
+            "warning": [400, 403, 404],
+            "error": [500, 503],
         }
         for level, status_codes in level_status_codes.items():
             for status_code in status_codes:
                 # The correct level gets the message.
-                with self.assertLogs('django.server', level.upper()) as cm:
-                    handler.log_message('GET %s %s', 'A', str(status_code))
-                self.assertIn('GET A %d' % status_code, cm.output[0])
+                with self.assertLogs("django.server", level.upper()) as cm:
+                    handler.log_message("GET %s %s", "A", str(status_code))
+                self.assertIn("GET A %d" % status_code, cm.output[0])
                 # Incorrect levels don't have any messages.
                 for wrong_level in level_status_codes:
                     if wrong_level != level:
-                        with self.assertLogs('django.server', 'INFO') as cm:
-                            handler.log_message('GET %s %s', 'A', str(status_code))
-                        self.assertNotEqual(cm.records[0].levelname, wrong_level.upper())
+                        with self.assertLogs("django.server", "INFO") as cm:
+                            handler.log_message("GET %s %s", "A", str(status_code))
+                        self.assertNotEqual(
+                            cm.records[0].levelname, wrong_level.upper()
+                        )
 
     def test_https(self):
-        request = WSGIRequest(self.request_factory.get('/').environ)
+        request = WSGIRequest(self.request_factory.get("/").environ)
         request.makefile = lambda *args, **kwargs: BytesIO()
 
-        handler = WSGIRequestHandler(request, '192.168.0.2', None)
+        handler = WSGIRequestHandler(request, "192.168.0.2", None)
 
-        with self.assertLogs('django.server', 'ERROR') as cm:
-            handler.log_message("GET %s %s", '\x16\x03', "4")
+        with self.assertLogs("django.server", "ERROR") as cm:
+            handler.log_message("GET %s %s", "\x16\x03", "4")
         self.assertIn(
             "You're accessing the development server over HTTPS, "
             "but it only supports HTTP.",
-            cm.records[0].getMessage()
+            cm.records[0].getMessage(),
         )
 
     def test_strips_underscore_headers(self):
@@ -61,14 +63,14 @@ class WSGIRequestHandlerTestCase(SimpleTestCase):
         ambiguity between dashes and underscores in mapping to WSGI environ,
         which can have security implications.
         """
+
         def test_app(environ, start_response):
             """A WSGI app that just reflects its HTTP environ."""
-            start_response('200 OK', [])
+            start_response("200 OK", [])
             http_environ_items = sorted(
-                '%s:%s' % (k, v) for k, v in environ.items()
-                if k.startswith('HTTP_')
+                "%s:%s" % (k, v) for k, v in environ.items() if k.startswith("HTTP_")
             )
-            yield (','.join(http_environ_items)).encode()
+            yield (",".join(http_environ_items)).encode()
 
         rfile = BytesIO()
         rfile.write(b"GET / HTTP/1.0\r\n")
@@ -86,23 +88,23 @@ class WSGIRequestHandlerTestCase(SimpleTestCase):
         wfile = UnclosableBytesIO()
 
         def makefile(mode, *a, **kw):
-            if mode == 'rb':
+            if mode == "rb":
                 return rfile
-            elif mode == 'wb':
+            elif mode == "wb":
                 return wfile
 
         request = Stub(makefile=makefile)
         server = Stub(base_environ={}, get_app=lambda: test_app)
 
         # Prevent logging from appearing in test output.
-        with self.assertLogs('django.server', 'INFO'):
+        with self.assertLogs("django.server", "INFO"):
             # instantiating a handler runs the request as side effect
-            WSGIRequestHandler(request, '192.168.0.2', server)
+            WSGIRequestHandler(request, "192.168.0.2", server)
 
         wfile.seek(0)
         body = list(wfile.readlines())[-1]
 
-        self.assertEqual(body, b'HTTP_SOME_HEADER:good')
+        self.assertEqual(body, b"HTTP_SOME_HEADER:good")
 
 
 class WSGIServerTestCase(SimpleTestCase):
@@ -110,9 +112,9 @@ class WSGIServerTestCase(SimpleTestCase):
 
     def test_broken_pipe_errors(self):
         """WSGIServer handles broken pipe errors."""
-        request = WSGIRequest(self.request_factory.get('/').environ)
-        client_address = ('192.168.2.0', 8080)
-        msg = f'- Broken pipe from {client_address}\n'
+        request = WSGIRequest(self.request_factory.get("/").environ)
+        client_address = ("192.168.2.0", 8080)
+        msg = f"- Broken pipe from {client_address}\n"
         tests = [
             BrokenPipeError,
             ConnectionAbortedError,
@@ -121,14 +123,14 @@ class WSGIServerTestCase(SimpleTestCase):
         for exception in tests:
             with self.subTest(exception=exception):
                 try:
-                    server = WSGIServer(('localhost', 0), WSGIRequestHandler)
+                    server = WSGIServer(("localhost", 0), WSGIRequestHandler)
                     try:
                         raise exception()
                     except Exception:
                         with captured_stderr() as err:
-                            with self.assertLogs('django.server', 'INFO') as cm:
+                            with self.assertLogs("django.server", "INFO") as cm:
                                 server.handle_error(request, client_address)
-                        self.assertEqual(err.getvalue(), '')
+                        self.assertEqual(err.getvalue(), "")
                         self.assertEqual(cm.records[0].getMessage(), msg)
                 finally:
                     server.server_close()