如何在单元测试期间在 Django RequestFactory 中设置消息传递和 session 中间件

Question

I have a function I need to test which takes a request as its argument. It is not exposed as a view by URL so I cannot test it with the test client.

I need to pass a request object to it, and the request object needs to have the messaging middleware enabled because messaging middleware is used in the function.

I am using the RequestFactory to create my request. The documentation says:

It does not support middleware. Session and authentication attributes must be supplied by the test itself if required for the view to function properly.

How do I setup the messaging middleware with the RequestFactory? I think I will also need the session middleware to make the messaging middleware work

This is the error my test currently produces when using the vanilla RequestFactory.

MessageFailure: You cannot add messages without installing django.contrib.messages.middleware.MessageMiddleware

This is my function under test, in case it helps with understanding this problem:

from django.contrib import messages as django_messages

def store_to_request(self, request):
        """
        Place all the messages stored in this class into message storage in
        the request object supplied.
        :param request: The request object to which we should store all the messages
        :return: Does not return anything
        """
        for message in self._messages:
            django_messages.add_message(request, message.level, message.message, message.extra_tags,
                                    message.fail_silently)

Answer 1

This issue was raised , so as there said, you can fix your unit tests using that code:

from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)

Answer 2

If you don't need to test the behaviour of the request object itself you could mock the request using the mock library instead of RequestFactory eg:

import mock

request = mock.MagicMock()

# Call your function using the mocked request
store_to_request(request)

Answer 3

An effictively equivalent method to Danag's anwer would be to pass the request object through the process_request methods of the session and message middlewares (in that order) before passing it to the view/function:

from django.contrib.sessions.middleware import SessionMiddleware
from django.contrib.messages.middleware import MessageMiddleware

request = request_factory.get()
sm = SessionMiddleware()
sm.process_request(request)
mm = MessageMiddleware()
mm.process_request(request)

You can do the above in a method for convenience:

class MessageDependentTests(TestCase):
    
    def setUp(self):
        self.rf = RequestFactory()
        self.sm = SessionMiddleware()
        self.mm = MessageMiddleware()
        return super().setUp()
        
    def prepare_request(self, request):
        self.sm.process_request(request)
        self.mm.process_request(request)

    def test_something(self):
        request = self.rf.get('/')
        self.prepare_request(request)
        response = my_view(request)
        # test response below