Refs #33476 -- Reformatted code with Black.

9 files changed, 225 insertions, 190 deletions

diff --git a/tests/messages_tests/base.py b/tests/messages_tests/base.py
index 2ee1f995aa..d89e186278 100644
--- a/tests/messages_tests/base.py
+++ b/tests/messages_tests/base.py
@@ -14,41 +14,44 @@ def add_level_messages(storage):
     Add 6 messages from different levels (including a custom one) to a storage
     instance.
     """
-    storage.add(constants.INFO, 'A generic info message')
-    storage.add(29, 'Some custom level')
-    storage.add(constants.DEBUG, 'A debugging message', extra_tags='extra-tag')
-    storage.add(constants.WARNING, 'A warning')
-    storage.add(constants.ERROR, 'An error')
-    storage.add(constants.SUCCESS, 'This was a triumph.')
+    storage.add(constants.INFO, "A generic info message")
+    storage.add(29, "Some custom level")
+    storage.add(constants.DEBUG, "A debugging message", extra_tags="extra-tag")
+    storage.add(constants.WARNING, "A warning")
+    storage.add(constants.ERROR, "An error")
+    storage.add(constants.SUCCESS, "This was a triumph.")
 
 
 class BaseTests:
     storage_class = default_storage
     levels = {
-        'debug': constants.DEBUG,
-        'info': constants.INFO,
-        'success': constants.SUCCESS,
-        'warning': constants.WARNING,
-        'error': constants.ERROR,
+        "debug": constants.DEBUG,
+        "info": constants.INFO,
+        "success": constants.SUCCESS,
+        "warning": constants.WARNING,
+        "error": constants.ERROR,
     }
 
     def setUp(self):
         self.settings_override = override_settings(
-            TEMPLATES=[{
-                'BACKEND': 'django.template.backends.django.DjangoTemplates',
-                'DIRS': [],
-                'APP_DIRS': True,
-                'OPTIONS': {
-                    'context_processors': (
-                        'django.contrib.auth.context_processors.auth',
-                        'django.contrib.messages.context_processors.messages',
-                    ),
-                },
-            }],
-            ROOT_URLCONF='messages_tests.urls',
+            TEMPLATES=[
+                {
+                    "BACKEND": "django.template.backends.django.DjangoTemplates",
+                    "DIRS": [],
+                    "APP_DIRS": True,
+                    "OPTIONS": {
+                        "context_processors": (
+                            "django.contrib.auth.context_processors.auth",
+                            "django.contrib.messages.context_processors.messages",
+                        ),
+                    },
+                }
+            ],
+            ROOT_URLCONF="messages_tests.urls",
             MESSAGE_TAGS={},
-            MESSAGE_STORAGE='%s.%s' % (self.storage_class.__module__, self.storage_class.__name__),
-            SESSION_SERIALIZER='django.contrib.sessions.serializers.JSONSerializer',
+            MESSAGE_STORAGE="%s.%s"
+            % (self.storage_class.__module__, self.storage_class.__name__),
+            SESSION_SERIALIZER="django.contrib.sessions.serializers.JSONSerializer",
         )
         self.settings_override.enable()
 
@@ -79,22 +82,22 @@ class BaseTests:
         storage = self.storage_class(request)
         self.assertEqual(
             repr(storage),
-            f'<{self.storage_class.__qualname__}: request=<HttpRequest>>',
+            f"<{self.storage_class.__qualname__}: request=<HttpRequest>>",
         )
 
     def test_add(self):
         storage = self.get_storage()
         self.assertFalse(storage.added_new)
-        storage.add(constants.INFO, 'Test message 1')
+        storage.add(constants.INFO, "Test message 1")
         self.assertTrue(storage.added_new)
-        storage.add(constants.INFO, 'Test message 2', extra_tags='tag')
+        storage.add(constants.INFO, "Test message 2", extra_tags="tag")
         self.assertEqual(len(storage), 2)
 
     def test_add_lazy_translation(self):
         storage = self.get_storage()
         response = self.get_response()
 
-        storage.add(constants.INFO, gettext_lazy('lazy message'))
+        storage.add(constants.INFO, gettext_lazy("lazy message"))
         storage.update(response)
 
         storing = self.stored_messages_count(storage, response)
@@ -111,8 +114,8 @@ class BaseTests:
         storage = self.get_storage()
         response = self.get_response()
 
-        storage.add(constants.INFO, 'Test message 1')
-        storage.add(constants.INFO, 'Test message 1', extra_tags='tag')
+        storage.add(constants.INFO, "Test message 1")
+        storage.add(constants.INFO, "Test message 1", extra_tags="tag")
         storage.update(response)
 
         storing = self.stored_messages_count(storage, response)
@@ -122,8 +125,8 @@ class BaseTests:
         storage = self.get_existing_storage()
         response = self.get_response()
 
-        storage.add(constants.INFO, 'Test message 3')
-        list(storage)   # Simulates a read
+        storage.add(constants.INFO, "Test message 3")
+        list(storage)  # Simulates a read
         storage.update(response)
 
         storing = self.stored_messages_count(storage, response)
@@ -133,8 +136,8 @@ class BaseTests:
         storage = self.get_existing_storage()
         response = self.get_response()
 
-        list(storage)   # Simulates a read
-        storage.add(constants.INFO, 'Test message 3')
+        list(storage)  # Simulates a read
+        storage.add(constants.INFO, "Test message 3")
         storage.update(response)
 
         storing = self.stored_messages_count(storage, response)
@@ -147,44 +150,44 @@ class BaseTests:
         retrieved across the full request/redirect/response cycle.
         """
         data = {
-            'messages': ['Test message %d' % x for x in range(5)],
+            "messages": ["Test message %d" % x for x in range(5)],
         }
-        show_url = reverse('show_message')
-        for level in ('debug', 'info', 'success', 'warning', 'error'):
-            add_url = reverse('add_message', args=(level,))
+        show_url = reverse("show_message")
+        for level in ("debug", "info", "success", "warning", "error"):
+            add_url = reverse("add_message", args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertIn('messages', response.context)
-            messages = [Message(self.levels[level], msg) for msg in data['messages']]
-            self.assertEqual(list(response.context['messages']), messages)
-            for msg in data['messages']:
+            self.assertIn("messages", response.context)
+            messages = [Message(self.levels[level], msg) for msg in data["messages"]]
+            self.assertEqual(list(response.context["messages"]), messages)
+            for msg in data["messages"]:
                 self.assertContains(response, msg)
 
     @override_settings(MESSAGE_LEVEL=constants.DEBUG)
     def test_with_template_response(self):
         data = {
-            'messages': ['Test message %d' % x for x in range(5)],
+            "messages": ["Test message %d" % x for x in range(5)],
         }
-        show_url = reverse('show_template_response')
+        show_url = reverse("show_template_response")
         for level in self.levels:
-            add_url = reverse('add_template_response', args=(level,))
+            add_url = reverse("add_template_response", args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertIn('messages', response.context)
-            for msg in data['messages']:
+            self.assertIn("messages", response.context)
+            for msg in data["messages"]:
                 self.assertContains(response, msg)
 
             # there shouldn't be any messages on second GET request
             response = self.client.get(show_url)
-            for msg in data['messages']:
+            for msg in data["messages"]:
                 self.assertNotContains(response, msg)
 
     def test_context_processor_message_levels(self):
-        show_url = reverse('show_template_response')
+        show_url = reverse("show_template_response")
         response = self.client.get(show_url)
 
-        self.assertIn('DEFAULT_MESSAGE_LEVELS', response.context)
-        self.assertEqual(response.context['DEFAULT_MESSAGE_LEVELS'], DEFAULT_LEVELS)
+        self.assertIn("DEFAULT_MESSAGE_LEVELS", response.context)
+        self.assertEqual(response.context["DEFAULT_MESSAGE_LEVELS"], DEFAULT_LEVELS)
 
     @override_settings(MESSAGE_LEVEL=constants.DEBUG)
     def test_multiple_posts(self):
@@ -192,31 +195,35 @@ class BaseTests:
         Messages persist properly when multiple POSTs are made before a GET.
         """
         data = {
-            'messages': ['Test message %d' % x for x in range(5)],
+            "messages": ["Test message %d" % x for x in range(5)],
         }
-        show_url = reverse('show_message')
+        show_url = reverse("show_message")
         messages = []
-        for level in ('debug', 'info', 'success', 'warning', 'error'):
-            messages.extend(Message(self.levels[level], msg) for msg in data['messages'])
-            add_url = reverse('add_message', args=(level,))
+        for level in ("debug", "info", "success", "warning", "error"):
+            messages.extend(
+                Message(self.levels[level], msg) for msg in data["messages"]
+            )
+            add_url = reverse("add_message", args=(level,))
             self.client.post(add_url, data)
         response = self.client.get(show_url)
-        self.assertIn('messages', response.context)
-        self.assertEqual(list(response.context['messages']), messages)
-        for msg in data['messages']:
+        self.assertIn("messages", response.context)
+        self.assertEqual(list(response.context["messages"]), messages)
+        for msg in data["messages"]:
             self.assertContains(response, msg)
 
     @modify_settings(
-        INSTALLED_APPS={'remove': 'django.contrib.messages'},
-        MIDDLEWARE={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
+        INSTALLED_APPS={"remove": "django.contrib.messages"},
+        MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
     )
     @override_settings(
         MESSAGE_LEVEL=constants.DEBUG,
-        TEMPLATES=[{
-            'BACKEND': 'django.template.backends.django.DjangoTemplates',
-            'DIRS': [],
-            'APP_DIRS': True,
-        }],
+        TEMPLATES=[
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+                "DIRS": [],
+                "APP_DIRS": True,
+            }
+        ],
     )
     def test_middleware_disabled(self):
         """
@@ -224,24 +231,26 @@ class BaseTests:
         attempts to store a message.
         """
         data = {
-            'messages': ['Test message %d' % x for x in range(5)],
+            "messages": ["Test message %d" % x for x in range(5)],
         }
-        reverse('show_message')
-        for level in ('debug', 'info', 'success', 'warning', 'error'):
-            add_url = reverse('add_message', args=(level,))
+        reverse("show_message")
+        for level in ("debug", "info", "success", "warning", "error"):
+            add_url = reverse("add_message", args=(level,))
             with self.assertRaises(MessageFailure):
                 self.client.post(add_url, data, follow=True)
 
     @modify_settings(
-        INSTALLED_APPS={'remove': 'django.contrib.messages'},
-        MIDDLEWARE={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
+        INSTALLED_APPS={"remove": "django.contrib.messages"},
+        MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
     )
     @override_settings(
-        TEMPLATES=[{
-            'BACKEND': 'django.template.backends.django.DjangoTemplates',
-            'DIRS': [],
-            'APP_DIRS': True,
-        }],
+        TEMPLATES=[
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+                "DIRS": [],
+                "APP_DIRS": True,
+            }
+        ],
     )
     def test_middleware_disabled_fail_silently(self):
         """
@@ -249,31 +258,33 @@ class BaseTests:
         if 'fail_silently' is True.
         """
         data = {
-            'messages': ['Test message %d' % x for x in range(5)],
-            'fail_silently': True,
+            "messages": ["Test message %d" % x for x in range(5)],
+            "fail_silently": True,
         }
-        show_url = reverse('show_message')
-        for level in ('debug', 'info', 'success', 'warning', 'error'):
-            add_url = reverse('add_message', args=(level,))
+        show_url = reverse("show_message")
+        for level in ("debug", "info", "success", "warning", "error"):
+            add_url = reverse("add_message", args=(level,))
             response = self.client.post(add_url, data, follow=True)
             self.assertRedirects(response, show_url)
-            self.assertNotIn('messages', response.context)
+            self.assertNotIn("messages", response.context)
 
     def stored_messages_count(self, storage, response):
         """
         Return the number of messages being stored after a
         ``storage.update()`` call.
         """
-        raise NotImplementedError('This method must be set by a subclass.')
+        raise NotImplementedError("This method must be set by a subclass.")
 
     def test_get(self):
-        raise NotImplementedError('This method must be set by a subclass.')
+        raise NotImplementedError("This method must be set by a subclass.")
 
     def get_existing_storage(self):
-        return self.get_storage([
-            Message(constants.INFO, 'Test message 1'),
-            Message(constants.INFO, 'Test message 2', extra_tags='tag'),
-        ])
+        return self.get_storage(
+            [
+                Message(constants.INFO, "Test message 1"),
+                Message(constants.INFO, "Test message 2", extra_tags="tag"),
+            ]
+        )
 
     def test_existing_read(self):
         """
@@ -290,7 +301,7 @@ class BaseTests:
     def test_existing_add(self):
         storage = self.get_existing_storage()
         self.assertFalse(storage.added_new)
-        storage.add(constants.INFO, 'Test message 3')
+        storage.add(constants.INFO, "Test message 3")
         self.assertTrue(storage.added_new)
 
     def test_default_level(self):
@@ -343,27 +354,31 @@ class BaseTests:
         storage = self.get_storage()
         storage.level = 0
         add_level_messages(storage)
-        storage.add(constants.INFO, 'A generic info message', extra_tags=None)
+        storage.add(constants.INFO, "A generic info message", extra_tags=None)
         tags = [msg.tags for msg in storage]
-        self.assertEqual(tags, ['info', '', 'extra-tag debug', 'warning', 'error', 'success', 'info'])
+        self.assertEqual(
+            tags, ["info", "", "extra-tag debug", "warning", "error", "success", "info"]
+        )
 
     def test_level_tag(self):
         storage = self.get_storage()
         storage.level = 0
         add_level_messages(storage)
         tags = [msg.level_tag for msg in storage]
-        self.assertEqual(tags, ['info', '', 'debug', 'warning', 'error', 'success'])
-
-    @override_settings(MESSAGE_TAGS={
-        constants.INFO: 'info',
-        constants.DEBUG: '',
-        constants.WARNING: '',
-        constants.ERROR: 'bad',
-        29: 'custom',
-    })
+        self.assertEqual(tags, ["info", "", "debug", "warning", "error", "success"])
+
+    @override_settings(
+        MESSAGE_TAGS={
+            constants.INFO: "info",
+            constants.DEBUG: "",
+            constants.WARNING: "",
+            constants.ERROR: "bad",
+            29: "custom",
+        }
+    )
     def test_custom_tags(self):
         storage = self.get_storage()
         storage.level = 0
         add_level_messages(storage)
         tags = [msg.tags for msg in storage]
-        self.assertEqual(tags, ['info', 'custom', 'extra-tag', '', 'bad', 'success'])
+        self.assertEqual(tags, ["info", "custom", "extra-tag", "", "bad", "success"])
diff --git a/tests/messages_tests/test_api.py b/tests/messages_tests/test_api.py
index 603aea437f..dcd98f085c 100644
--- a/tests/messages_tests/test_api.py
+++ b/tests/messages_tests/test_api.py
@@ -10,7 +10,7 @@ class DummyStorage:
     def __init__(self):
         self.store = []
 
-    def add(self, level, message, extra_tags=''):
+    def add(self, level, message, extra_tags=""):
         self.store.append(message)
 
 
@@ -22,7 +22,7 @@ class ApiTests(SimpleTestCase):
         self.storage = DummyStorage()
 
     def test_ok(self):
-        msg = 'some message'
+        msg = "some message"
         self.request._messages = self.storage
         messages.add_message(self.request, messages.DEBUG, msg)
         self.assertIn(msg, self.storage.store)
@@ -31,17 +31,19 @@ class ApiTests(SimpleTestCase):
         msg = "add_message() argument must be an HttpRequest object, not 'NoneType'."
         self.request._messages = self.storage
         with self.assertRaisesMessage(TypeError, msg):
-            messages.add_message(None, messages.DEBUG, 'some message')
+            messages.add_message(None, messages.DEBUG, "some message")
         self.assertEqual(self.storage.store, [])
 
     def test_middleware_missing(self):
-        msg = 'You cannot add messages without installing django.contrib.messages.middleware.MessageMiddleware'
+        msg = "You cannot add messages without installing django.contrib.messages.middleware.MessageMiddleware"
         with self.assertRaisesMessage(messages.MessageFailure, msg):
-            messages.add_message(self.request, messages.DEBUG, 'some message')
+            messages.add_message(self.request, messages.DEBUG, "some message")
         self.assertEqual(self.storage.store, [])
 
     def test_middleware_missing_silently(self):
-        messages.add_message(self.request, messages.DEBUG, 'some message', fail_silently=True)
+        messages.add_message(
+            self.request, messages.DEBUG, "some message", fail_silently=True
+        )
         self.assertEqual(self.storage.store, [])
 
 
@@ -61,6 +63,7 @@ class CustomRequestApiTests(ApiTests):
     add_message() should use ducktyping to allow request wrappers such as the
     one in Django REST framework.
     """
+
     def setUp(self):
         super().setUp()
         self.request = CustomRequest(self.request)
diff --git a/tests/messages_tests/test_cookie.py b/tests/messages_tests/test_cookie.py
index 248afae4f4..e2e62378d3 100644
--- a/tests/messages_tests/test_cookie.py
+++ b/tests/messages_tests/test_cookie.py
@@ -5,7 +5,9 @@ from django.conf import settings
 from django.contrib.messages import constants
 from django.contrib.messages.storage.base import Message
 from django.contrib.messages.storage.cookie import (
-    CookieStorage, MessageDecoder, MessageEncoder,
+    CookieStorage,
+    MessageDecoder,
+    MessageEncoder,
 )
 from django.test import SimpleTestCase, override_settings
 from django.utils.crypto import get_random_string
@@ -24,7 +26,7 @@ def set_cookie_data(storage, messages, invalid=False, encode_empty=False):
         # Truncate the first character so that the hash is invalid.
         encoded_data = encoded_data[1:]
     storage.request.COOKIES = {CookieStorage.cookie_name: encoded_data}
-    if hasattr(storage, '_loaded_data'):
+    if hasattr(storage, "_loaded_data"):
         del storage._loaded_data
 
 
@@ -35,7 +37,7 @@ def stored_cookie_messages_count(storage, response):
     # Get a list of cookies, excluding ones with a max-age of 0 (because
     # they have been marked for deletion).
     cookie = response.cookies.get(storage.cookie_name)
-    if not cookie or cookie['max-age'] == 0:
+    if not cookie or cookie["max-age"] == 0:
         return 0
     data = storage._decode(cookie.value)
     if not data:
@@ -45,7 +47,11 @@ def stored_cookie_messages_count(storage, response):
     return len(data)
 
 
-@override_settings(SESSION_COOKIE_DOMAIN='.example.com', SESSION_COOKIE_SECURE=True, SESSION_COOKIE_HTTPONLY=True)
+@override_settings(
+    SESSION_COOKIE_DOMAIN=".example.com",
+    SESSION_COOKIE_SECURE=True,
+    SESSION_COOKIE_HTTPONLY=True,
+)
 class CookieTests(BaseTests, SimpleTestCase):
     storage_class = CookieStorage
 
@@ -61,12 +67,12 @@ class CookieTests(BaseTests, SimpleTestCase):
     def test_get(self):
         storage = self.storage_class(self.get_request())
         # Set initial data.
-        example_messages = ['test', 'me']
+        example_messages = ["test", "me"]
         set_cookie_data(storage, example_messages)
         # The message contains what's expected.
         self.assertEqual(list(storage), example_messages)
 
-    @override_settings(SESSION_COOKIE_SAMESITE='Strict')
+    @override_settings(SESSION_COOKIE_SAMESITE="Strict")
     def test_cookie_setings(self):
         """
         CookieStorage honors SESSION_COOKIE_DOMAIN, SESSION_COOKIE_SECURE, and
@@ -75,29 +81,31 @@ class CookieTests(BaseTests, SimpleTestCase):
         # Test before the messages have been consumed
         storage = self.get_storage()
         response = self.get_response()
-        storage.add(constants.INFO, 'test')
+        storage.add(constants.INFO, "test")
         storage.update(response)
-        messages = storage._decode(response.cookies['messages'].value)
+        messages = storage._decode(response.cookies["messages"].value)
         self.assertEqual(len(messages), 1)
-        self.assertEqual(messages[0].message, 'test')
-        self.assertEqual(response.cookies['messages']['domain'], '.example.com')
-        self.assertEqual(response.cookies['messages']['expires'], '')
-        self.assertIs(response.cookies['messages']['secure'], True)
-        self.assertIs(response.cookies['messages']['httponly'], True)
-        self.assertEqual(response.cookies['messages']['samesite'], 'Strict')
+        self.assertEqual(messages[0].message, "test")
+        self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
+        self.assertEqual(response.cookies["messages"]["expires"], "")
+        self.assertIs(response.cookies["messages"]["secure"], True)
+        self.assertIs(response.cookies["messages"]["httponly"], True)
+        self.assertEqual(response.cookies["messages"]["samesite"], "Strict")
 
         # Test deletion of the cookie (storing with an empty value) after the messages have been consumed
         storage = self.get_storage()
         response = self.get_response()
-        storage.add(constants.INFO, 'test')
+        storage.add(constants.INFO, "test")
         for m in storage:
             pass  # Iterate through the storage to simulate consumption of messages.
         storage.update(response)
-        self.assertEqual(response.cookies['messages'].value, '')
-        self.assertEqual(response.cookies['messages']['domain'], '.example.com')
-        self.assertEqual(response.cookies['messages']['expires'], 'Thu, 01 Jan 1970 00:00:00 GMT')
+        self.assertEqual(response.cookies["messages"].value, "")
+        self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
+        self.assertEqual(
+            response.cookies["messages"]["expires"], "Thu, 01 Jan 1970 00:00:00 GMT"
+        )
         self.assertEqual(
-            response.cookies['messages']['samesite'],
+            response.cookies["messages"]["samesite"],
             settings.SESSION_COOKIE_SAMESITE,
         )
 
@@ -105,7 +113,7 @@ class CookieTests(BaseTests, SimpleTestCase):
         request = self.get_request()
         storage = self.storage_class(request)
         # Set initial (invalid) data.
-        example_messages = ['test', 'me']
+        example_messages = ["test", "me"]
         set_cookie_data(storage, example_messages, invalid=True)
         # The message actually contains what we expect.
         self.assertEqual(list(storage), [])
@@ -142,8 +150,8 @@ class CookieTests(BaseTests, SimpleTestCase):
         self.assertEqual(unstored_messages[0].message, first_msg)
 
     def test_message_rfc6265(self):
-        non_compliant_chars = ['\\', ',', ';', '"']
-        messages = ['\\te,st', ';m"e', '\u2019', '123"NOTRECEIVED"']
+        non_compliant_chars = ["\\", ",", ";", '"']
+        messages = ["\\te,st", ';m"e', "\u2019", '123"NOTRECEIVED"']
         storage = self.get_storage()
         encoded = storage._encode(messages)
         for illegal in non_compliant_chars:
@@ -157,12 +165,13 @@ class CookieTests(BaseTests, SimpleTestCase):
         """
         messages = [
             {
-                'message': Message(constants.INFO, 'Test message'),
-                'message_list': [
-                    Message(constants.INFO, 'message %s') for x in range(5)
-                ] + [{'another-message': Message(constants.ERROR, 'error')}],
+                "message": Message(constants.INFO, "Test message"),
+                "message_list": [
+                    Message(constants.INFO, "message %s") for x in range(5)
+                ]
+                + [{"another-message": Message(constants.ERROR, "error")}],
             },
-            Message(constants.INFO, 'message %s'),
+            Message(constants.INFO, "message %s"),
         ]
         encoder = MessageEncoder()
         value = encoder.encode(messages)
@@ -175,11 +184,11 @@ class CookieTests(BaseTests, SimpleTestCase):
         retrieved from the message storage.
         """
         self.assertIsInstance(
-            self.encode_decode(mark_safe('<b>Hello Django!</b>')).message,
+            self.encode_decode(mark_safe("<b>Hello Django!</b>")).message,
             SafeData,
         )
         self.assertNotIsInstance(
-            self.encode_decode('<b>Hello Django!</b>').message,
+            self.encode_decode("<b>Hello Django!</b>").message,
             SafeData,
         )
 
@@ -188,9 +197,9 @@ class CookieTests(BaseTests, SimpleTestCase):
         A message's extra_tags attribute is correctly preserved when retrieved
         from the message storage.
         """
-        for extra_tags in ['', None, 'some tags']:
+        for extra_tags in ["", None, "some tags"]:
             with self.subTest(extra_tags=extra_tags):
                 self.assertEqual(
-                    self.encode_decode('message', extra_tags=extra_tags).extra_tags,
+                    self.encode_decode("message", extra_tags=extra_tags).extra_tags,
                     extra_tags,
                 )
diff --git a/tests/messages_tests/test_fallback.py b/tests/messages_tests/test_fallback.py
index dcfc53d8cb..7a335114c5 100644
--- a/tests/messages_tests/test_fallback.py
+++ b/tests/messages_tests/test_fallback.py
@@ -1,9 +1,7 @@
 import random
 
 from django.contrib.messages import constants
-from django.contrib.messages.storage.fallback import (
-    CookieStorage, FallbackStorage,
-)
+from django.contrib.messages.storage.fallback import CookieStorage, FallbackStorage
 from django.test import SimpleTestCase
 from django.utils.crypto import get_random_string
 
@@ -37,10 +35,9 @@ class FallbackTests(BaseTests, SimpleTestCase):
         """
         Return the storage totals from both cookie and session backends.
         """
-        return (
-            self.stored_cookie_messages_count(storage, response) +
-            self.stored_session_messages_count(storage, response)
-        )
+        return self.stored_cookie_messages_count(
+            storage, response
+        ) + self.stored_session_messages_count(storage, response)
 
     def test_get(self):
         request = self.get_request()
@@ -70,7 +67,9 @@ class FallbackTests(BaseTests, SimpleTestCase):
 
         # Set initial cookie and session data.
         example_messages = [str(i) for i in range(5)]
-        set_cookie_data(cookie_storage, example_messages[:4] + [CookieStorage.not_finished])
+        set_cookie_data(
+            cookie_storage, example_messages[:4] + [CookieStorage.not_finished]
+        )
         set_session_data(session_storage, example_messages[4:])
         self.assertEqual(list(storage), example_messages)
 
@@ -91,8 +90,8 @@ class FallbackTests(BaseTests, SimpleTestCase):
         cookie_storage = self.get_cookie_storage(storage)
         session_storage = self.get_session_storage(storage)
         # Set initial cookie and session data.
-        set_cookie_data(cookie_storage, ['cookie', CookieStorage.not_finished])
-        set_session_data(session_storage, ['session'])
+        set_cookie_data(cookie_storage, ["cookie", CookieStorage.not_finished])
+        set_session_data(session_storage, ["session"])
         # When updating, previously used but no longer needed backends are
         # flushed.
         response = self.get_response()
diff --git a/tests/messages_tests/test_middleware.py b/tests/messages_tests/test_middleware.py
index 9fd66e9186..6b5733fdd2 100644
--- a/tests/messages_tests/test_middleware.py
+++ b/tests/messages_tests/test_middleware.py
@@ -5,11 +5,12 @@ from django.http import HttpRequest, HttpResponse
 
 
 class MiddlewareTests(unittest.TestCase):
-
     def test_response_without_messages(self):
         """
         MessageMiddleware is tolerant of messages not existing on request.
         """
         request = HttpRequest()
         response = HttpResponse()
-        MessageMiddleware(lambda req: HttpResponse()).process_response(request, response)
+        MessageMiddleware(lambda req: HttpResponse()).process_response(
+            request, response
+        )
diff --git a/tests/messages_tests/test_mixins.py b/tests/messages_tests/test_mixins.py
index f4d0b26d28..0e3e0360d9 100644
--- a/tests/messages_tests/test_mixins.py
+++ b/tests/messages_tests/test_mixins.py
@@ -6,21 +6,20 @@ from .models import SomeObject
 from .urls import ContactFormViewWithMsg, DeleteFormViewWithMsg
 
 
-@override_settings(ROOT_URLCONF='messages_tests.urls')
+@override_settings(ROOT_URLCONF="messages_tests.urls")
 class SuccessMessageMixinTests(TestCase):
-
     def test_set_messages_success(self):
-        author = {'name': 'John Doe', 'slug': 'success-msg'}
-        add_url = reverse('add_success_msg')
+        author = {"name": "John Doe", "slug": "success-msg"}
+        add_url = reverse("add_success_msg")
         req = self.client.post(add_url, author)
         # Uncompressed message is stored in the cookie.
         value = b64_decode(
-            req.cookies['messages'].value.split(":")[0].encode(),
+            req.cookies["messages"].value.split(":")[0].encode(),
         ).decode()
         self.assertIn(ContactFormViewWithMsg.success_message % author, value)
 
     def test_set_messages_success_on_delete(self):
-        object_to_delete = SomeObject.objects.create(name='MyObject')
-        delete_url = reverse('success_msg_on_delete', args=[object_to_delete.pk])
+        object_to_delete = SomeObject.objects.create(name="MyObject")
+        delete_url = reverse("success_msg_on_delete", args=[object_to_delete.pk])
         response = self.client.post(delete_url, follow=True)
         self.assertContains(response, DeleteFormViewWithMsg.success_message)
diff --git a/tests/messages_tests/test_session.py b/tests/messages_tests/test_session.py
index c313921baa..07be6063f7 100644
--- a/tests/messages_tests/test_session.py
+++ b/tests/messages_tests/test_session.py
@@ -15,12 +15,14 @@ def set_session_data(storage, messages):
     backend's loaded data cache.
     """
     storage.request.session[storage.session_key] = storage.serialize_messages(messages)
-    if hasattr(storage, '_loaded_data'):
+    if hasattr(storage, "_loaded_data"):
         del storage._loaded_data
 
 
 def stored_session_messages_count(storage):
-    data = storage.deserialize_messages(storage.request.session.get(storage.session_key, []))
+    data = storage.deserialize_messages(
+        storage.request.session.get(storage.session_key, [])
+    )
     return len(data)
 
 
@@ -38,16 +40,16 @@ class SessionTests(BaseTests, TestCase):
 
     def test_no_session(self):
         msg = (
-            'The session-based temporary message storage requires session '
-            'middleware to be installed, and come before the message '
-            'middleware in the MIDDLEWARE list.'
+            "The session-based temporary message storage requires session "
+            "middleware to be installed, and come before the message "
+            "middleware in the MIDDLEWARE list."
         )
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
             self.storage_class(HttpRequest())
 
     def test_get(self):
         storage = self.storage_class(self.get_request())
-        example_messages = ['test', 'me']
+        example_messages = ["test", "me"]
         set_session_data(storage, example_messages)
         self.assertEqual(list(storage), example_messages)
 
diff --git a/tests/messages_tests/tests.py b/tests/messages_tests/tests.py
index aebb5bb0ec..d16854a89a 100644
--- a/tests/messages_tests/tests.py
+++ b/tests/messages_tests/tests.py
@@ -8,9 +8,9 @@ from django.test import SimpleTestCase, override_settings
 
 class MessageTests(SimpleTestCase):
     def test_eq(self):
-        msg_1 = Message(constants.INFO, 'Test message 1')
-        msg_2 = Message(constants.INFO, 'Test message 2')
-        msg_3 = Message(constants.WARNING, 'Test message 1')
+        msg_1 = Message(constants.INFO, "Test message 1")
+        msg_2 = Message(constants.INFO, "Test message 2")
+        msg_3 = Message(constants.WARNING, "Test message 1")
         self.assertEqual(msg_1, msg_1)
         self.assertEqual(msg_1, mock.ANY)
         self.assertNotEqual(msg_1, msg_2)
@@ -20,12 +20,12 @@ class MessageTests(SimpleTestCase):
 
 class TestLevelTags(SimpleTestCase):
     message_tags = {
-        constants.INFO: 'info',
-        constants.DEBUG: '',
-        constants.WARNING: '',
-        constants.ERROR: 'bad',
-        constants.SUCCESS: '',
-        12: 'custom',
+        constants.INFO: "info",
+        constants.DEBUG: "",
+        constants.WARNING: "",
+        constants.ERROR: "bad",
+        constants.SUCCESS: "",
+        12: "custom",
     }
 
     @override_settings(MESSAGE_TAGS=message_tags)
diff --git a/tests/messages_tests/urls.py b/tests/messages_tests/urls.py
index 983cb33d72..3f70911d4f 100644
--- a/tests/messages_tests/urls.py
+++ b/tests/messages_tests/urls.py
@@ -26,31 +26,31 @@ TEMPLATE = """{% if messages %}
 def add(request, message_type):
     # Don't default to False here to test that it defaults to False if
     # unspecified.
-    fail_silently = request.POST.get('fail_silently', None)
-    for msg in request.POST.getlist('messages'):
+    fail_silently = request.POST.get("fail_silently", None)
+    for msg in request.POST.getlist("messages"):
         if fail_silently is not None:
             getattr(messages, message_type)(request, msg, fail_silently=fail_silently)
         else:
             getattr(messages, message_type)(request, msg)
-    return HttpResponseRedirect(reverse('show_message'))
+    return HttpResponseRedirect(reverse("show_message"))
 
 
 @never_cache
 def add_template_response(request, message_type):
-    for msg in request.POST.getlist('messages'):
+    for msg in request.POST.getlist("messages"):
         getattr(messages, message_type)(request, msg)
-    return HttpResponseRedirect(reverse('show_template_response'))
+    return HttpResponseRedirect(reverse("show_template_response"))
 
 
 @never_cache
 def show(request):
-    template = engines['django'].from_string(TEMPLATE)
+    template = engines["django"].from_string(TEMPLATE)
     return HttpResponse(template.render(request=request))
 
 
 @never_cache
 def show_template_response(request):
-    template = engines['django'].from_string(TEMPLATE)
+    template = engines["django"].from_string(TEMPLATE)
     return TemplateResponse(request, template)
 
 
@@ -67,18 +67,25 @@ class ContactFormViewWithMsg(SuccessMessageMixin, FormView):
 
 class DeleteFormViewWithMsg(SuccessMessageMixin, DeleteView):
     model = SomeObject
-    success_url = '/show/'
-    success_message = 'Object was deleted successfully'
+    success_url = "/show/"
+    success_message = "Object was deleted successfully"
 
 
 urlpatterns = [
-    re_path('^add/(debug|info|success|warning|error)/$', add, name='add_message'),
-    path('add/msg/', ContactFormViewWithMsg.as_view(), name='add_success_msg'),
-    path('delete/msg/<int:pk>', DeleteFormViewWithMsg.as_view(), name='success_msg_on_delete'),
-    path('show/', show, name='show_message'),
+    re_path("^add/(debug|info|success|warning|error)/$", add, name="add_message"),
+    path("add/msg/", ContactFormViewWithMsg.as_view(), name="add_success_msg"),
+    path(
+        "delete/msg/<int:pk>",
+        DeleteFormViewWithMsg.as_view(),
+        name="success_msg_on_delete",
+    ),
+    path("show/", show, name="show_message"),
     re_path(
-        '^template_response/add/(debug|info|success|warning|error)/$',
-        add_template_response, name='add_template_response',
+        "^template_response/add/(debug|info|success|warning|error)/$",
+        add_template_response,
+        name="add_template_response",
+    ),
+    path(
+        "template_response/show/", show_template_response, name="show_template_response"
     ),
-    path('template_response/show/', show_template_response, name='show_template_response'),
 ]