Lifespan context manager in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens during the lifespan context manager in FastAPI?

Consider a FastAPI app using a lifespan context manager to open and close a database connection. What is the correct sequence of events when the app starts and stops?

FastAPI

from fastapi import FastAPI
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    print('Connecting to DB')
    yield
    print('Disconnecting from DB')

app = FastAPI(lifespan=lifespan)

A 1,2,3

B 2,1,3

C 1,3,2

D 3,1,2

💡 Hint

Think about what happens before and after the yield statement in a context manager.

The code before yield runs when the app starts, and the code after yield runs when the app stops.

❓ state_output

intermediate

What is printed when the FastAPI app with lifespan starts and stops?

Given this FastAPI app with a lifespan context manager, what will be printed to the console when the app starts and then stops?

FastAPI

from fastapi import FastAPI
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    print('Starting app')
    yield
    print('Stopping app')

app = FastAPI(lifespan=lifespan)

A Starting app\nStopping app

B Stopping app\nStarting app

C Starting app

D Stopping app

💡 Hint

Remember the lifespan context manager runs code before and after the yield.

The print before yield runs at startup, the print after yield runs at shutdown.

🔧 Debug

advanced

Why does this FastAPI lifespan context manager cause an error?

Examine this lifespan context manager code. Why does it raise a RuntimeError when the app starts?

FastAPI

from fastapi import FastAPI
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    print('Setup')
    # Missing yield statement
    print('Teardown')

app = FastAPI(lifespan=lifespan)

A It raises RuntimeError because the app variable is not used inside lifespan.

B It raises RuntimeError because print statements are not allowed in lifespan.

C It raises RuntimeError because FastAPI requires a synchronous lifespan function.

D It raises RuntimeError because the async context manager function does not yield.

💡 Hint

Async context managers must have exactly one yield.

Without a yield, the async context manager is invalid and raises RuntimeError.

📝 Syntax

advanced

Which lifespan context manager code is syntactically correct in FastAPI?

Choose the option with correct syntax for an async lifespan context manager in FastAPI.

A

from contextlib import contextmanager

@contextmanager
def lifespan(app: FastAPI):
    print('Start')
    yield
    print('End')

B

from contextlib import asynccontextmanager

def lifespan(app: FastAPI):
    print('Start')
    yield
    print('End')

C

from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    print('Start')
    yield
    print('End')

D

from contextlib import asynccontextmanager

@asynccontextmanager
def lifespan():
    print('Start')
    yield
    print('End')

💡 Hint

FastAPI expects an async context manager with the app parameter.

Option C uses asynccontextmanager decorator, async function with app parameter, and yield.

🧠 Conceptual

expert

What is the main benefit of using a lifespan context manager in FastAPI?

Why would a developer use a lifespan context manager in a FastAPI application?

A To automatically reload the app when code changes are detected.

B To manage startup and shutdown tasks like opening and closing resources cleanly.

C To handle HTTP request routing and URL matching.

D To replace dependency injection for request handlers.

💡 Hint

Think about what happens when the app starts and stops.

Lifespan context managers allow running code at app startup and shutdown to manage resources.

Practice

1. What is the main purpose of the lifespan context manager in a FastAPI application?

easy

A. To manage user authentication and authorization

B. To handle HTTP requests and responses

C. To define API routes and endpoints

D. To run setup code when the app starts and cleanup code when it stops

Solution

1. Step 1: Understand the role of lifespan context manager

   The lifespan context manager is designed to run code at the start and end of the FastAPI app lifecycle.

2. Step 2: Identify its main use

   It is used to set up resources like database connections when the app starts and clean them up when the app stops.

3. Final Answer:

   To run setup code when the app starts and cleanup code when it stops -> Option D

4. Quick Check:

   Lifespan manages startup and shutdown code = A [OK]

Hint: Lifespan runs code at app start and stop [OK]

Common Mistakes:

• Confusing lifespan with route handling
• Thinking lifespan manages HTTP requests
• Assuming lifespan handles user sessions

2. Which of the following is the correct way to define a lifespan context manager in FastAPI?

easy

A. async def lifespan(app): yield

B. def lifespan(): return app

C. async def lifespan(): return app

D. def lifespan(app): yield

Solution

1. Step 1: Recall lifespan signature

   The lifespan function must be async and accept the app parameter to manage startup and shutdown.

2. Step 2: Confirm use of yield

   Using yield inside the async function allows running code before and after the yield for startup and shutdown.

3. Final Answer:

   async def lifespan(app): yield -> Option A

4. Quick Check:

   Async + app param + yield = A [OK]

Hint: Lifespan is async with app param and uses yield [OK]

Common Mistakes:

• Forgetting async keyword
• Missing app parameter
• Using return instead of yield

3. Given this FastAPI lifespan code snippet, what will be printed when the app starts and stops?

async def lifespan(app):
    print('Starting app')
    yield
    print('Stopping app')

medium

A. Only 'Starting app' is printed

B. 'Starting app' prints on start, 'Stopping app' prints on shutdown

C. Only 'Stopping app' is printed

D. Neither message is printed

Solution

1. Step 1: Understand yield in lifespan

   The code before yield runs at startup, and code after yield runs at shutdown.

2. Step 2: Match prints to lifecycle events

   So 'Starting app' prints when app starts, and 'Stopping app' prints when app stops.

3. Final Answer:

   'Starting app' prints on start, 'Stopping app' prints on shutdown -> Option B

4. Quick Check:

   Code before yield = start, after yield = stop [OK]

Hint: Code before yield runs on start, after yield on stop [OK]

Common Mistakes:

• Thinking both prints run immediately
• Assuming yield blocks all prints
• Confusing start and stop timing

4. What is wrong with this lifespan context manager code?

async def lifespan(app):
    print('Starting')
    return
    print('Stopping')

medium

A. The app parameter is not used, causing runtime error

B. Missing async keyword causes syntax error

C. Using return instead of yield prevents shutdown code from running

D. Print statements are not allowed in lifespan functions

Solution

1. Step 1: Identify use of return instead of yield

   The lifespan function must use yield to separate startup and shutdown code.

2. Step 2: Understand effect of return

   Using return exits the function immediately, so shutdown code after it never runs.

3. Final Answer:

   Using return instead of yield prevents shutdown code from running -> Option C

4. Quick Check:

   Return exits early; yield separates start/stop [OK]

Hint: Use yield, not return, to run shutdown code [OK]

Common Mistakes:

• Confusing return and yield in async functions
• Ignoring that shutdown code runs after yield
• Assuming print statements cause errors

5. You want to open a database connection when your FastAPI app starts and close it when the app stops using the lifespan context manager. Which code correctly implements this?

hard

A. async def lifespan(app):
db = await connect_db()
app.state.db = db
yield
await db.close()

B. async def lifespan(app):
db = await connect_db()
yield
app.state.db = db
await db.close()

C. def lifespan(app):
db = connect_db()
app.state.db = db
yield
db.close()

D. async def lifespan():
db = await connect_db()
app.state.db = db
yield
await db.close()

Solution

1. Step 1: Confirm async function with app parameter

   The lifespan function must be async and accept the app parameter to store the db connection.

2. Step 2: Check order of operations

   Connect to the database before yield, store it on app.state, then close it after yield.

3. Step 3: Verify correct use of await and yield

   Await connect_db and db.close, yield separates startup and shutdown code.

4. Final Answer:

   async def lifespan(app): db = await connect_db() app.state.db = db yield await db.close() -> Option A

5. Quick Check:

   Async + app param + yield + await connect/close = D [OK]

Hint: Connect before yield, close after, store in app.state [OK]

Common Mistakes:

• Placing yield before storing db connection
• Missing async or await keywords
• Not passing app parameter to lifespan