Custom middleware creation in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Flask middleware do to the response?

Consider this Flask middleware that modifies the response body. What will be the final response content when a client requests the root URL?

Flask

from flask import Flask, request, Response

app = Flask(__name__)

@app.before_request
def before():
    print('Before request')

@app.after_request
def after(response):
    response.set_data(response.get_data(as_text=True) + ' World!')
    return response

@app.route('/')
def index():
    return 'Hello'

if __name__ == '__main__':
    app.run()

A "Hello World!"

B "Hello"

C " World!"

D Empty response

💡 Hint

Look at how the after_request function changes the response data.

The after_request middleware appends ' World!' to the original response 'Hello', so the final output is 'Hello World!'.

❓ lifecycle

intermediate

When is Flask middleware executed in the request lifecycle?

Given Flask middleware functions before_request and after_request, when are they executed relative to the route handler?

A before_request runs after the route handler; after_request runs before the route handler

B before_request runs before the route handler; after_request runs after the route handler

C Both run before the route handler

D Both run after the route handler

💡 Hint

Think about the names and purpose of these middleware hooks.

before_request runs before the route handler to prepare or check the request. after_request runs after the route handler to modify the response.

📝 Syntax

advanced

Which middleware code snippet correctly adds a custom header to all responses?

Choose the correct Flask middleware code that adds the header X-Custom: True to every response.

A

@app.after_request
def add_header():
    response.headers['X-Custom'] = 'True'
    return response

B

@app.before_request
def add_header():
    response.headers['X-Custom'] = 'True'
    return response

C

@app.before_request
def add_header(response):
    response.headers['X-Custom'] = 'True'
    return response

D

@app.after_request
def add_header(response):
    response.headers['X-Custom'] = 'True'
    return response

💡 Hint

Remember which middleware hook receives the response object.

The after_request function receives the response object and can modify headers. The before_request does not receive the response.

🔧 Debug

advanced

What does this Flask middleware do when a request is made?

Examine the middleware code below. What happens when a request is made?

Flask

from flask import Flask
app = Flask(__name__)

@app.before_request
def check():
    return 'Blocked'

@app.route('/')
def index():
    return 'Hello'

if __name__ == '__main__':
    app.run()

A The route handler is never called because before_request raises an exception

B The before_request must return None or a Response object, returning a string causes a TypeError

C The before_request returns a string which stops the request and returns 'Blocked' instead of calling the route

D The middleware is missing a return statement, causing a runtime error

💡 Hint

Check what returning a string from before_request does in Flask.

Returning a string from before_request stops further processing and sends that string as the response. This is valid and does not cause an error.

❓ state_output

expert

What is the final response content after multiple middleware modify it?

Given these two Flask middleware functions, what is the final response content when requesting '/'?

Flask

from flask import Flask, Response
app = Flask(__name__)

@app.after_request
def add_hello(response):
    response.set_data(response.get_data(as_text=True) + ' Hello')
    return response

@app.after_request
def add_world(response):
    response.set_data(response.get_data(as_text=True) + ' World')
    return response

@app.route('/')
def index():
    return 'Start'

if __name__ == '__main__':
    app.run()

A "Start World Hello"

B "Start Hello"

C "Start Hello World"

D "Start World"

💡 Hint

Consider the order in which multiple after_request functions run (reverse registration order).

Flask runs multiple after_request functions in reverse order of registration. add_world (later registered) runs first, appending ' World', then add_hello appends ' Hello'.

Practice

1. What is the main purpose of creating custom middleware in a Flask application?

easy

A. To run code before and after each request is processed by Flask

B. To define new routes and views in the Flask app

C. To replace Flask's built-in request handling completely

D. To create database models for the application

Solution

1. Step 1: Understand middleware role

   Middleware runs code around request processing, before and after Flask handles requests.

2. Step 2: Compare options

   Only To run code before and after each request is processed by Flask describes this behavior. Other options describe unrelated tasks.

3. Final Answer:

   To run code before and after each request is processed by Flask -> Option A

4. Quick Check:

   Middleware purpose = run code around requests [OK]

Hint: Middleware wraps requests to add extra processing [OK]

Common Mistakes:

• Confusing middleware with route creation
• Thinking middleware replaces Flask core
• Mixing middleware with database models

2. Which of the following is the correct way to define a custom middleware class in Flask?

easy

A. class MyMiddleware:
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
return self.app(environ, start_response)

B. def MyMiddleware(app):
return app

C. class MyMiddleware:
def handle_request(self):
pass

D. class MyMiddleware:
def __init__(self):
pass

Solution

1. Step 1: Check middleware class structure

   Middleware must accept the app in __init__ and implement __call__ with environ and start_response.

2. Step 2: Validate options

   Only class MyMiddleware: def __init__(self, app): self.app = app def __call__(self, environ, start_response): return self.app(environ, start_response) matches this pattern correctly. Others miss __call__ or parameters.

3. Final Answer:

   Correct middleware class with __init__ and __call__ methods -> Option A

4. Quick Check:

   Middleware class needs __call__ method [OK]

Hint: Middleware class must implement __call__(environ, start_response) [OK]

Common Mistakes:

• Omitting __call__ method
• Not passing app to __init__
• Using function instead of class

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

class LoggerMiddleware:
    def __init__(self, app):
        self.app = app
    def __call__(self, environ, start_response):
        print('Before request')
        response = self.app(environ, start_response)
        print('After request')
        return response

app.wsgi_app = LoggerMiddleware(app.wsgi_app)

medium

A. Only After request printed

B. Only Before request printed

C. No output printed

D. Before request printed, then After request printed

Solution

1. Step 1: Analyze __call__ method

   Prints 'Before request', calls app, then prints 'After request'.

2. Step 2: Understand call order

   Both prints happen on each request, before and after app call.

3. Final Answer:

   Before request printed, then After request printed -> Option D

4. Quick Check:

   Prints before and after app call [OK]

Hint: Middleware __call__ runs code before and after app call [OK]

Common Mistakes:

• Thinking only one print runs
• Confusing order of prints
• Assuming prints happen outside __call__

4. Identify the error in this middleware code snippet:

class BadMiddleware:
    def __init__(self, app):
        self.app = app
    def __call__(self, request):
        print('Middleware active')
        return self.app(request)

medium

A. Missing __init__ method to accept app

B. __call__ method has wrong parameters; should be (environ, start_response)

C. Middleware class should not print anything

D. The return statement should be outside __call__

Solution

1. Step 1: Check __call__ method signature

   WSGI middleware __call__ must accept (environ, start_response), not (request).

2. Step 2: Validate other parts

   __init__ is correct, printing is allowed, return inside __call__ is correct.

3. Final Answer:

   __call__ method has wrong parameters; should be (environ, start_response) -> Option B

4. Quick Check:

   Middleware __call__ signature = (environ, start_response) [OK]

Hint: Middleware __call__ needs environ and start_response params [OK]

Common Mistakes:

• Using Flask request object instead of WSGI params
• Omitting start_response parameter
• Misplacing return statement

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

hard

A. class HeaderMiddleware:
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
response = self.app(environ, start_response)
response.headers['X-Hello'] = 'World'
return response

B. class HeaderMiddleware:
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
start_response('200 OK', [('X-Hello', 'World')])
return self.app(environ, start_response)

C. class HeaderMiddleware:
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
def custom_start_response(status, headers, exc_info=None):
headers.append(('X-Hello', 'World'))
return start_response(status, headers, exc_info)
return self.app(environ, custom_start_response)

D. class HeaderMiddleware:
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
environ['X-Hello'] = 'World'
return self.app(environ, start_response)

Solution

1. Step 1: Understand WSGI header modification

   Headers are set by calling start_response with status and headers. To add headers, wrap start_response.

2. Step 2: Check options for correct header addition

   class HeaderMiddleware: def __init__(self, app): self.app = app def __call__(self, environ, start_response): def custom_start_response(status, headers, exc_info=None): headers.append(('X-Hello', 'World')) return start_response(status, headers, exc_info) return self.app(environ, custom_start_response) wraps start_response to append header before calling original start_response. Others misuse start_response or response object.

3. Final Answer:

   Wrap start_response to add header before calling original -> Option C

4. Quick Check:

   Add headers by wrapping start_response [OK]

Hint: Wrap start_response to add headers in middleware [OK]

Common Mistakes:

• Calling start_response twice incorrectly
• Trying to modify response object directly in WSGI
• Adding headers to environ instead of response