Before_request as middleware alternative in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Flask before_request function returns a response?

In Flask, if a before_request function returns a response, what is the effect on the request processing?

Flask

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

@app.before_request
def check_auth():
    return jsonify({'error': 'Unauthorized'}), 401

@app.route('/')
def home():
    return 'Welcome!'

# What will a client see when accessing '/'?

A The client receives a 401 JSON error response and the home route is not executed.

B The client receives an empty response with status 200.

C The client receives a 500 Internal Server Error due to returning a response in before_request.

D The client receives 'Welcome!' because the before_request does not affect the route.

💡 Hint

Think about how Flask handles returned responses in before_request functions.

If a before_request function returns a response, Flask stops processing further handlers and sends that response immediately.

📝 Syntax

intermediate

Identify the correct way to register a before_request function in Flask

Which of the following code snippets correctly registers a before_request function in Flask?

A

def check():
    pass
app.before_request(check)

B

@app.before_request()
def check():
    pass

C

@app.before_request
check = lambda: None

D

@app.before_request
def check():
    pass

💡 Hint

Remember the decorator syntax for Flask hooks.

The before_request decorator is used without parentheses to register a function.

🔧 Debug

advanced

Why does this Flask before_request middleware not block unauthorized access?

Consider this Flask app code:

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

@app.before_request
def check_token():
    token = request.headers.get('Authorization')
    if token != 'secret':
        return None

@app.route('/data')
def data():
    return 'Sensitive data'

Why might a client still access '/data' without the correct token?

A Because the before_request function does not return a response object, Flask ignores it.

B Because the route '/data' is registered before the before_request function.

C Because the before_request function returns a string and status code tuple, which Flask accepts and blocks access correctly.

D Because the client is sending the correct token, so access is allowed.

💡 Hint

Check the return type of the before_request function when blocking access.

Returning a plain string and status code tuple is valid in Flask, so option A is correct behavior. But if the function returns None or does not return anything, Flask continues processing. If the function returns a non-response type that Flask can't handle, it raises an error. The question states unauthorized access is not blocked, so the function likely returns None or does not return the response properly.

❓ state_output

advanced

What is the output when using before_request to modify g object in Flask?

Given this Flask app code:

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

@app.before_request
def set_user():
    g.user = 'Alice'

@app.route('/')
def home():
    return f'Hello, {g.user}!'

What will a client see when accessing '/'?

A Hello, !

B Hello, Alice!

C AttributeError because g.user is not set

D 500 Internal Server Error due to missing return

💡 Hint

Think about how Flask's g object works across requests.

The before_request function sets g.user before the route runs. The route accesses g.user and returns 'Hello, Alice!'.

🧠 Conceptual

expert

How does Flask's before_request compare to middleware in other frameworks?

Which statement best describes the difference between Flask's before_request functions and middleware in frameworks like Express.js or Django?

A Flask's before_request functions are identical to middleware in Express.js and Django, supporting next() calls to pass control.

B Flask does not support middleware; before_request is the only way to intercept requests.

C Flask's before_request functions are simpler hooks that run before each request but do not form a chain of middleware layers like Express.js middleware.

D Flask's before_request functions run after the response is sent, unlike middleware in other frameworks.

💡 Hint

Consider how control flow works in Flask before_request vs middleware chains.

Flask's before_request functions run before each request but do not support chaining or calling next middleware explicitly. Middleware in Express.js or Django often form chains where each middleware calls next() to continue.