WSGI middleware concept in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this WSGI middleware do to the response?

Consider this WSGI middleware wrapping a Flask app. What will be the final response body sent to the client?

Flask

class SimpleMiddleware:
    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-Custom-Header', 'Middleware'))
            return start_response(status, headers, exc_info)

        response = self.app(environ, custom_start_response)
        modified_response = []
        for data in response:
            modified_response.append(data.upper())
        return modified_response

from flask import Flask
app = Flask(__name__)

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

app.wsgi_app = SimpleMiddleware(app.wsgi_app)

A The client receives 'HELLO WORLD' with an extra header 'X-Custom-Header: Middleware'.

B The client receives 'hello world' with no extra headers.

C The client receives 'HELLO WORLD' but no extra headers.

D The client receives 'hello world' with an extra header 'X-Custom-Header: Middleware'.

💡 Hint

Think about how the middleware modifies both headers and response body.

The middleware adds a custom header by modifying the start_response call and converts the response body to uppercase by iterating over it and changing each chunk to uppercase.

❓ lifecycle

intermediate

When is the WSGI middleware __call__ method executed?

In a Flask app wrapped by WSGI middleware, at what point is the middleware's __call__ method triggered?

A Only once when the Flask app starts.

B Each time the Flask app receives an HTTP request.

C Only when the Flask app sends a response.

D Only when the Flask app raises an error.

💡 Hint

Think about what WSGI middleware wraps and how requests flow.

The __call__ method of WSGI middleware is called every time a new HTTP request comes in, because it wraps the app's WSGI callable which handles requests.

🔧 Debug

advanced

Why does this WSGI middleware cause a TypeError?

This middleware tries to modify the response but causes a TypeError. Why?

Flask

class FaultyMiddleware:
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        response = self.app(environ, start_response)
        return response.upper()

A Because start_response is called twice causing a TypeError.

B Because the middleware forgot to call start_response.

C Because response is an iterable, not a string, so .upper() is invalid.

D Because the app does not return any response causing NoneType error.

💡 Hint

Check the type of the response returned by the app.

The app returns an iterable (like a list or generator) of byte strings, not a single string. Calling .upper() on the iterable causes a TypeError.

📝 Syntax

advanced

Which option correctly adds a header in WSGI middleware?

Select the code snippet that correctly adds a custom header 'X-Test: Yes' in WSGI middleware.

A

def __call__(self, environ, start_response):
    def custom_start(status, headers):
        headers.append(('X-Test', 'Yes'))
        return start_response(status, headers)
    return self.app(environ, custom_start)

B

def __call__(self, environ, start_response):
    headers = [('X-Test', 'Yes')]
    start_response('200 OK', headers)
    return self.app(environ, start_response)

C

def __call__(self, environ, start_response):
    start_response('200 OK', [('X-Test', 'Yes')])
    return self.app(environ, start_response)

D

def __call__(self, environ, start_response):
    def custom_start(status, headers, exc_info=None):
        headers.append(('X-Test', 'Yes'))
        return start_response(status, headers, exc_info)
    return self.app(environ, custom_start)

💡 Hint

Remember the start_response signature and how to wrap it.

Option D correctly defines a wrapper function with the right signature including exc_info, appends the header, and calls the original start_response. Others have wrong signatures or call start_response too early.

🧠 Conceptual

expert

What is the main benefit of using WSGI middleware in Flask apps?

Why would a developer add WSGI middleware around a Flask app instead of modifying the Flask app code directly?

A To add reusable functionality like logging or headers without changing the app code.

B To speed up the Flask app by bypassing Flask's routing system.

C To convert Flask apps into asynchronous apps automatically.

D To replace Flask's request handling with a different framework.

💡 Hint

Think about separation of concerns and reusability.

WSGI middleware allows adding features like logging, security checks, or header modifications in a reusable way without touching the Flask app code itself.