Creating custom middleware in Django - Practice Exercises

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this custom middleware modifying response headers?

Consider this Django middleware that adds a custom header to every response. What will be the value of the X-Custom-Header in the HTTP response?

Django

class CustomHeaderMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response["X-Custom-Header"] = "MiddlewareActive"
        return response

A "MiddlewareActive"

B Header will not be present

C "CustomHeader"

D Raises AttributeError

💡 Hint

Think about how the middleware modifies the response object before returning it.

The middleware adds the header X-Custom-Header with value MiddlewareActive to every response before returning it.

❓ lifecycle

intermediate

At which point in the request lifecycle is the process_view middleware method called?

In Django middleware, when is the process_view method executed?

A After the response is returned

B Before the view function is called, after URL resolution

C Before URL resolution

D After the view function is called

💡 Hint

Think about when Django knows which view will handle the request.

process_view runs after Django resolves the URL to a view but before the view function is executed.

📝 Syntax

advanced

Which middleware class definition correctly implements __init__ and __call__ methods?

Select the option that correctly defines a Django middleware class with proper __init__ and __call__ methods.

A

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

B

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

C

class MyMiddleware:
    def __init__(self):
        pass
    def __call__(self, request, get_response):
        response = get_response(request)
        return response

D

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

💡 Hint

Remember the middleware class must accept get_response in __init__ and request in __call__.

Option D correctly defines __init__ with get_response and __call__ with request, calling get_response(request). Others have wrong method signatures.

🔧 Debug

advanced

Why does this middleware raise an AttributeError?

Given this middleware code, why does it raise an AttributeError when processing a request?

Django

class FaultyMiddleware:
    def __init__(self, get_response):
        pass

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

A Because __init__ should not accept get_response parameter

B Because __call__ method is missing the request parameter

C Because self.get_response is not assigned in __init__, so calling it raises AttributeError

D Because the middleware must return a string, not a response object

💡 Hint

Check if all attributes used in __call__ are properly set in __init__.

The middleware does not assign get_response to self.get_response in __init__, so self.get_response is undefined in __call__, causing AttributeError.

❓ state_output

expert

What is the final value of request.custom_flag after this middleware stack runs?

Two middlewares modify request.custom_flag. What is its value after both run?

Django

class MiddlewareOne:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        request.custom_flag = True
        response = self.get_response(request)
        return response

class MiddlewareTwo:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        if hasattr(request, 'custom_flag') and request.custom_flag:
            request.custom_flag = False
        response = self.get_response(request)
        return response

# Assume MiddlewareOne is listed before MiddlewareTwo in MIDDLEWARE setting

A False

B True

C AttributeError because custom_flag is missing

D None

💡 Hint

Remember middleware runs in order on request, reverse order on response.

MiddlewareOne sets custom_flag to True first. MiddlewareTwo then sees it True and sets it to False. So final value after both is False.

Practice

1. What is the main purpose of custom middleware in Django?

easy

A. To run code before and after a view processes a request

B. To define database models

C. To create HTML templates

D. To handle user authentication only

Solution

1. Step 1: Understand middleware role

   Middleware runs code before and after views handle requests.

2. Step 2: Compare options

   Only To run code before and after a view processes a request describes middleware's purpose correctly; others describe unrelated tasks.

3. Final Answer:

   To run code before and after a view processes a request -> Option A

4. Quick Check:

   Middleware = pre/post view code [OK]

Hint: Middleware runs code around views, not models or templates [OK]

Common Mistakes:

• Confusing middleware with models or templates
• Thinking middleware only handles authentication
• Believing middleware runs only after views

2. Which method must a Django custom middleware class implement to process requests and responses?

easy

A. __call__

B. __init__

C. process_request

D. handle_request

Solution

1. Step 1: Recall middleware class structure

   Custom middleware uses __init__ for setup and __call__ to handle requests and responses.

2. Step 2: Identify correct method for processing

   __call__ is the method that processes requests and responses; others are incorrect or deprecated.

3. Final Answer:

   __call__ -> Option A

4. Quick Check:

   Middleware processing method = __call__ [OK]

Hint: Use __call__ to process requests in custom middleware [OK]

Common Mistakes:

• Using process_request which is old style
• Confusing __init__ with request processing
• Inventing non-existent methods like handle_request

3. Given this middleware code, what will be printed when a request is processed?

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('Middleware initialized')

    def __call__(self, request):
        print('Before view')
        response = self.get_response(request)
        print('After view')
        return response

medium

A. After view\nBefore view\nMiddleware initialized

B. Middleware initialized\nBefore view\nAfter view

C. Before view\nAfter view\nMiddleware initialized

D. Middleware initialized only

Solution

1. Step 1: Understand when __init__ runs

   __init__ runs once when middleware is created, printing 'Middleware initialized'.

2. Step 2: Trace __call__ execution order

   __call__ prints 'Before view', calls the view, then prints 'After view'.

3. Final Answer:

   Middleware initialized\nBefore view\nAfter view -> Option B

4. Quick Check:

   Init then before and after view prints [OK]

Hint: Init prints once; __call__ prints before and after view [OK]

Common Mistakes:

• Thinking __init__ runs on every request
• Mixing order of print statements
• Ignoring that __call__ wraps the view call

4. What is wrong with this custom middleware code?

class MyMiddleware:
    def __init__(self):
        pass

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

medium

A. No error, code is correct

B. __call__ should not return a response

C. Missing get_response parameter in __init__

D. Middleware classes cannot have __call__ method

Solution

1. Step 1: Check __init__ signature

   Middleware __init__ must accept get_response parameter to store it for later use.

2. Step 2: Identify missing attribute

   get_response is used in __call__, but not saved in __init__, causing an error.

3. Final Answer:

   Missing get_response parameter in __init__ -> Option C

4. Quick Check:

   __init__ needs get_response [OK]

Hint: Always accept get_response in __init__ for middleware [OK]

Common Mistakes:

• Omitting get_response parameter
• Not storing get_response as instance variable
• Thinking __call__ cannot return response

5. You want to create a custom middleware that adds a header 'X-Hello: World' to every response. Which code snippet correctly implements this?

hard

A. class HelloMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def process_response(self, request, response):
response['X-Hello'] = 'World'
return response

B. class HelloMiddleware:
def __init__(self):
pass
def __call__(self, request):
response = self.get_response(request)
response.headers.add('X-Hello', 'World')
return response

C. class HelloMiddleware:
def __call__(self, request):
response = self.get_response(request)
response['X-Hello'] = 'World'
return response

D. class HelloMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
response['X-Hello'] = 'World'
return response

Solution

1. Step 1: Confirm __init__ accepts get_response

   class HelloMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) response['X-Hello'] = 'World' return response correctly accepts and stores get_response in __init__.

2. Step 2: Check __call__ modifies response

   class HelloMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) response['X-Hello'] = 'World' return response calls get_response, adds header, and returns response properly.

3. Step 3: Identify errors in other options

   class HelloMiddleware: def __init__(self): pass def __call__(self, request): response = self.get_response(request) response.headers.add('X-Hello', 'World') return response misses get_response in __init__; class HelloMiddleware: def __call__(self, request): response = self.get_response(request) response['X-Hello'] = 'World' return response misses __init__; class HelloMiddleware: def __init__(self, get_response): self.get_response = get_response def process_response(self, request, response): response['X-Hello'] = 'World' return response uses old process_response method not supported in new style middleware.

4. Final Answer:

   class HelloMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) response['X-Hello'] = 'World' return response -> Option D

5. Quick Check:

   New middleware = __init__ + __call__ + modify response [OK]

Hint: New middleware needs get_response in __init__ and modifies response in __call__ [OK]

Common Mistakes:

• Omitting get_response in __init__
• Using old process_response method
• Trying to add headers before calling get_response