Connection lifecycle management in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ lifecycle

intermediate

What happens when a FastAPI dependency uses yield?

Consider a FastAPI dependency function that uses yield to provide a database connection. What is the behavior of this dependency during a request?

FastAPI

from fastapi import Depends, FastAPI
from contextlib import asynccontextmanager

app = FastAPI()

@asynccontextmanager
def get_db():
    db = "db connection"
    try:
        yield db
    finally:
        print("Closing db connection")

@app.get("/items/")
async def read_items(db=Depends(get_db)):
    return {"db": db}

A The code opens the connection before the request and closes it after the response is sent.

B The connection is opened and closed multiple times during the request processing.

C The connection is never closed because yield does not support cleanup.

D The connection is opened after the response is sent.

💡 Hint

Think about how yield works in Python generators and how FastAPI uses it for dependencies.

FastAPI treats dependencies with yield as context managers. It runs code before yield when the request starts, and runs the code after yield when the request ends, allowing cleanup like closing connections.

❓ state_output

intermediate

What is the output when a FastAPI dependency raises an exception after yield?

Given this FastAPI dependency that yields a resource and then raises an exception in the cleanup code, what happens when the endpoint is called?

FastAPI

from fastapi import Depends, FastAPI

app = FastAPI()

def resource():
    print("Setup resource")
    yield "resource"
    print("Cleanup resource")
    raise RuntimeError("Error during cleanup")

@app.get("/test")
async def test(dep=Depends(resource)):
    return {"message": "success"}

A The endpoint returns {"message": "success"} and logs the cleanup error after response.

B The endpoint never runs the cleanup code because of the exception.

C The endpoint returns an error response with status 500 immediately.

D The endpoint raises RuntimeError and does not return a response.

💡 Hint

Consider when the cleanup code after yield runs in FastAPI dependencies.

The code before yield runs before the request, the yield provides the value, and the code after yield runs after the response is sent. Exceptions in cleanup run after response, so the client still gets success.

🔧 Debug

advanced

Why does this FastAPI dependency not close the connection?

Examine this FastAPI dependency that tries to open and close a connection. Why does the connection never close?

FastAPI

from fastapi import Depends, FastAPI

app = FastAPI()

def get_conn():
    conn = "open connection"
    return conn
    print("Closing connection")

@app.get("/data")
async def data(conn=Depends(get_conn)):
    return {"conn": conn}

A The dependency must use yield to open and close connections properly.

B FastAPI requires async functions for dependencies to close connections.

C The print statement after return never runs, so connection is never closed.

D The connection closes automatically after the request without explicit code.

💡 Hint

Think about what happens to code after a return statement in Python functions.

Code after a return statement is never executed. So the print statement that should close the connection never runs, leaving the connection open.

🧠 Conceptual

advanced

How does FastAPI manage lifespan events for connections?

FastAPI allows defining lifespan events to manage resources like database connections. Which statement best describes how lifespan events work?

A Lifespan events run before and after every request to open and close connections.

B Lifespan events run code once when the app starts and once when it shuts down, managing global resources.

C Lifespan events are deprecated and replaced by dependencies with yield.

D Lifespan events only run if the app uses synchronous endpoints.

💡 Hint

Think about app startup and shutdown phases versus request handling.

Lifespan events run once at app startup and once at shutdown, ideal for managing resources shared across requests like database pools.

❓ component_behavior

expert

What is the behavior of nested FastAPI dependencies with yield?

Given two nested dependencies where the outer depends on the inner, both using yield to manage connections, what is the order of opening and closing connections during a request?

FastAPI

from fastapi import Depends, FastAPI

app = FastAPI()

def inner_conn():
    print("Open inner connection")
    yield "inner"
    print("Close inner connection")

def outer_conn(inner=Depends(inner_conn)):
    print("Open outer connection")
    yield f"outer uses {inner}"
    print("Close outer connection")

@app.get("/nested")
async def nested(dep=Depends(outer_conn)):
    return {"connection": dep}

A Open outer, open inner, close inner, close outer

B Open inner, open outer, close inner, close outer

C Open outer, open inner, close outer, close inner

D Open inner, open outer, close outer, close inner

💡 Hint

Consider how Python generators and context managers nest when using yield in dependencies.

The inner dependency opens first, then the outer. On cleanup, the outer closes first, then the inner, following stack unwinding order.