Hey! This is actually expected behavior due to how Starlette handles dependencies and exceptions. The yield dependency finalization runs during the exception propagation, which occurs before the exception handler sends the response. The documentation phrase "after the response is sent" holds for the happy path but not for exceptions, because exceptions unwind the stack sooner. If you need cleanup to happen strictly after the response (regardless of success or error), you have two main options:

1. Use BackgroundTasks – add your cleanup function as a background task either in the route or in the exception handler. Background tasks are guaranteed to run after the response is sent.

   from fastapi import FastAPI, BackgroundTasks
   async def cleanup():
       print("cleanup")
   @app.get("/nothappy")
   def nothappy(background_tasks: BackgroundTasks):
       background_tasks.add_task(cleanup)
       raise Exception("failure")

2. Write a custom middleware that captures the response and then runs cleanup after await call_next(request) completes, regardless of exception. Ensure your middleware runs after other middlewares (by ordering) and does its cleanup in a finally block:

   @app.middleware("http")
   async def cleanup_middleware(request: Request, call_next):
       try:
           response = await call_next(request)
       finally:
           # your cleanup here
           print("cleanup")
       return response

The first option is simpler for per-route cleanup. The second works globally.

Also note that your test prints from middleware are affected by where you place the middleware relative to exception handling. The middleware send wrapper prints when the body is being sent; in error paths, the exception handler may have already generated the body, so ordering can appear different.

Hope this clarifies!