Global exception middleware in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a ValueError is raised inside a FastAPI route with global exception middleware?

Consider a FastAPI app with a global exception middleware that catches ValueError and returns a JSON response with status 400 and a message. What will the client receive if a route raises ValueError('Invalid input')?

FastAPI

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.middleware("http")
async def catch_value_error(request: Request, call_next):
    try:
        response = await call_next(request)
        return response
    except ValueError as e:
        return JSONResponse(status_code=400, content={"error": str(e)})

@app.get("/test")
async def test_route():
    raise ValueError("Invalid input")

A {"error": "Invalid input"} with status code 400

B 500 Internal Server Error with default HTML response

C {"detail": "Invalid input"} with status code 422

D Empty response with status code 204

💡 Hint

Think about what the middleware does when it catches a ValueError.

The middleware catches the ValueError and returns a JSON response with status 400 and the error message. So the client receives the JSON with the error message and status 400.

📝 Syntax

intermediate

Which middleware code snippet correctly catches all exceptions and returns a JSON error response?

Choose the correct FastAPI middleware code that catches any exception during request processing and returns a JSON response with status 500 and a generic error message.

A

async def middleware(request: Request, call_next):
    try:
        return await call_next(request)
    except Exception as e:
        return JSONResponse(status_code=500, content={"error": "Server error"})

B

async def middleware(request: Request, call_next):
    try:
        response = call_next(request)
        return response
    except Exception:
        return JSONResponse(status_code=500, content={"error": "Server error"})

C

async def middleware(request: Request, call_next):
    try:
        response = await call_next(request)
    except Exception as e:
        return JSONResponse(status_code=500, content={"error": str(e)})
    return response

D

async def middleware(request: Request, call_next):
    response = await call_next(request)
    except Exception:
        return JSONResponse(status_code=500, content={"error": "Server error"})
    return response

💡 Hint

Remember to await the call_next and handle exceptions properly.

Option A correctly awaits call_next and catches exceptions. Option A misses await. Option A returns response outside try block which can cause errors. Option A has syntax error with misplaced except.

🔧 Debug

advanced

Why does this global exception middleware not catch exceptions raised in background tasks?

Given this middleware that catches exceptions during request processing, why are exceptions raised inside background tasks not caught by it?

FastAPI

from fastapi import FastAPI, BackgroundTasks, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.middleware("http")
async def catch_exceptions(request: Request, call_next):
    try:
        response = await call_next(request)
        return response
    except Exception as e:
        return JSONResponse(status_code=500, content={"error": str(e)})

@app.get("/bg")
async def bg_route(background_tasks: BackgroundTasks):
    def task():
        raise RuntimeError("Background error")
    background_tasks.add_task(task)
    return {"message": "Task started"}

A Middleware must be registered with background task manager to catch those exceptions

B Background tasks exceptions are caught but ignored silently by FastAPI

C Background tasks run synchronously blocking middleware exception handling

D Middleware only catches exceptions during request processing, background tasks run after response is sent

💡 Hint

Think about when background tasks run compared to the request lifecycle.

Background tasks run after the response is sent, outside the middleware's request processing. So exceptions in background tasks are not caught by middleware.

🧠 Conceptual

advanced

What is the main benefit of using global exception middleware in FastAPI?

Why would a developer add a global exception middleware instead of handling exceptions inside each route?

A To automatically retry failed requests without user code

B To centralize error handling and provide consistent error responses across all routes

C To log all requests regardless of errors

D To improve performance by skipping exception handling in routes

💡 Hint

Think about code reuse and consistency in user experience.

Global exception middleware centralizes error handling so developers don't repeat code in every route and users get consistent error messages.

❓ state_output

expert

What is the response status code and body when a KeyError is raised but middleware only catches ValueError?

Given a FastAPI app with middleware that catches only ValueError exceptions and returns status 400, what happens if a route raises KeyError('missing')?

FastAPI

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.middleware("http")
async def catch_value_error(request: Request, call_next):
    try:
        response = await call_next(request)
        return response
    except ValueError as e:
        return JSONResponse(status_code=400, content={"error": str(e)})

@app.get("/keyerror")
async def key_error_route():
    raise KeyError("missing")

A {"error": "missing"} with status code 400

B 422 Unprocessable Entity with JSON error detail

C 500 Internal Server Error with default HTML error page

D 200 OK with empty body

💡 Hint

Consider which exceptions the middleware catches and what happens to others.

The middleware only catches ValueError. A KeyError is not caught, so FastAPI returns its default 500 error response.