Async middleware in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async middleware logging example?

Consider this Django async middleware that logs request and response types. What will be printed in the console when a request is processed?

Django

import asyncio
from django.utils.deprecation import MiddlewareMixin

class AsyncLoggingMiddleware:
    async def __call__(self, request):
        print(f"Request type: {type(request)}")
        response = await self.get_response(request)
        print(f"Response type: {type(response)}")
        return response

A Request type: <class 'asyncio.Future'>\nResponse type: <class 'asyncio.Future'>

B Request type: <class 'django.http.HttpRequest'>\nResponse type: <class 'asyncio.coroutine'>

C Request type: <class 'django.http.HttpRequest'>\nResponse type: <class 'django.http.HttpResponse'>

D Request type: <class 'django.http.HttpResponse'>\nResponse type: <class 'django.http.HttpResponse'>

💡 Hint

Remember that Django passes HttpRequest objects to middleware and expects HttpResponse objects back.

The middleware receives a HttpRequest object and awaits the response, which is a HttpResponse object. The types printed reflect these classes.

📝 Syntax

intermediate

Which async middleware definition is syntactically correct in Django?

Select the option that correctly defines an async middleware class in Django 4+.

A

class MyMiddleware(MiddlewareMixin):
    async def __call__(self, request):
        response = self.get_response(request)
        return response

B

class MyMiddleware:
    async def __call__(self, request):
        response = await self.get_response(request)
        return response

C

class MyMiddleware:
    def __call__(self, request):
        response = await self.get_response(request)
        return response

D

class MyMiddleware:
    async def process_request(self, request):
        response = await self.get_response(request)
        return response

💡 Hint

Async middleware must define an async __call__ method and await the response.

Option B correctly defines an async __call__ method and awaits get_response. Option B is sync and does not await. Option B uses await in a sync method causing syntax error. Option B uses process_request which is not async middleware pattern.

🔧 Debug

advanced

Why does this async middleware cause a runtime error?

Given this middleware code, what is the cause of the runtime error when processing requests asynchronously? class FaultyMiddleware: def __call__(self, request): response = self.get_response(request) return response

A The __call__ method is not async but calls an async get_response without awaiting, causing a coroutine not awaited error.

B The middleware class is missing the MiddlewareMixin base class causing attribute errors.

C The get_response method is not defined in the middleware causing an AttributeError.

D The middleware uses sync __call__ but the request object is async-only causing a TypeError.

💡 Hint

Check if async functions are awaited properly in sync methods.

The get_response callable is async in async middleware chains. Calling it without await in a sync __call__ method returns a coroutine that is never awaited, causing runtime errors.

❓ state_output

advanced

What is the final value of request.state['count'] after this async middleware chain?

Two async middlewares increment a counter in request.state. What is the final count after processing a request? Middleware1: async def __call__(self, request): request.state['count'] = request.state.get('count', 0) + 1 response = await self.get_response(request) return response Middleware2: async def __call__(self, request): request.state['count'] = request.state.get('count', 0) + 1 response = await self.get_response(request) return response

A 2

B 1

C Raises KeyError because request.state is not initialized

D 0

💡 Hint

Each middleware increments the count once before passing the request on.

Both middlewares increment the count by 1. The first sets count=1, then calls next middleware which sets count=2. So final count is 2.

🧠 Conceptual

expert

Which statement best describes async middleware behavior in Django 4+?

Choose the most accurate statement about async middleware in Django 4 and later versions.

A Async middleware must inherit from MiddlewareMixin to work correctly with async views.

B Async middleware can only call async views; sync views cause runtime errors if called from async middleware.

C Async middleware cannot modify the request object because it is immutable during async processing.

D Async middleware must define an async __call__ method and can call both sync and async views seamlessly by awaiting get_response.

💡 Hint

Think about how Django handles sync and async views with async middleware.

Django's async middleware can await get_response which adapts to sync or async views internally, allowing seamless calling of both types.