Shared dependencies across routers in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when accessing the endpoint with shared dependency?

Consider a FastAPI app with two routers sharing a dependency that returns a user ID. What will the response be when calling /items/?

FastAPI

from fastapi import FastAPI, Depends, APIRouter

app = FastAPI()

async def get_user_id():
    return "user123"

router1 = APIRouter(dependencies=[Depends(get_user_id)])

@router1.get("/items/")
async def read_items():
    return {"message": "Items accessed"}

router2 = APIRouter(dependencies=[Depends(get_user_id)])

@router2.get("/users/")
async def read_users():
    return {"message": "Users accessed"}

app.include_router(router1)
app.include_router(router2)

A {"detail": "Not Found"}

B {"message": "Users accessed"}

C RuntimeError due to dependency conflict

D {"message": "Items accessed"}

💡 Hint

Think about which router handles the /items/ path and what the shared dependency returns.

The /items/ endpoint is defined in router1, which includes the shared dependency get_user_id. The endpoint returns a fixed message, so the output is {"message": "Items accessed"}.

📝 Syntax

intermediate

Which option correctly applies a shared dependency to multiple routers?

Given two routers, which code snippet correctly applies the same dependency to both routers?

FastAPI

from fastapi import APIRouter, Depends

async def common_dep():
    return "common"

router1 = APIRouter()
router2 = APIRouter()

# Which option correctly adds common_dep as a shared dependency?

A

router1 = APIRouter(dependencies=[Depends(common_dep)])
router2 = APIRouter(dependencies=[Depends(common_dep)])

B

router1.dependencies = [Depends(common_dep)]
router2.dependencies = [Depends(common_dep)]

C

router1 = APIRouter()
router2 = APIRouter()
router1.include_router(router2, dependencies=[Depends(common_dep)])

D

router1 = APIRouter(dependencies=Depends(common_dep))
router2 = APIRouter(dependencies=Depends(common_dep))

💡 Hint

Check how dependencies are passed as a list to the APIRouter constructor.

Dependencies must be passed as a list of Depends instances to the dependencies parameter of APIRouter. Option A correctly does this for both routers.

🔧 Debug

advanced

Why does this shared dependency raise a runtime error?

Examine the code below. When running the app, a runtime error occurs related to the shared dependency. What causes this error?

FastAPI

from fastapi import FastAPI, Depends, APIRouter

app = FastAPI()

async def get_db():
    raise RuntimeError("DB connection failed")

router = APIRouter(dependencies=[Depends(get_db)])

@router.get("/data")
async def read_data():
    return {"data": "sample"}

app.include_router(router)

A The dependency is not awaited properly, causing a coroutine warning.

B The router is missing a prefix, causing routing errors.

C The dependency get_db raises an exception, causing the endpoint to fail.

D FastAPI does not support async dependencies in routers.

💡 Hint

Look at what the dependency function does when called.

The dependency get_db raises a RuntimeError intentionally. This causes any endpoint depending on it to fail at runtime.

❓ state_output

advanced

What is the value of the shared dependency parameter inside the endpoint?

Given this FastAPI router with a shared dependency that returns a string, what is the value of user inside the endpoint?

FastAPI

from fastapi import APIRouter, Depends

async def get_current_user():
    return "alice"

router = APIRouter(dependencies=[Depends(get_current_user)])

@router.get("/profile")
async def profile(user: str = Depends(get_current_user)):
    return {"user": user}

A None

B "alice"

C Raises a TypeError due to duplicate dependency

D "user"

💡 Hint

Consider how FastAPI resolves dependencies when declared both in router and endpoint.

FastAPI calls the dependency once and injects the returned value. The user parameter receives the string "alice".

🧠 Conceptual

expert

Why use shared dependencies at router level instead of endpoint level?

Which is the main advantage of applying dependencies at the router level instead of individually on each endpoint?

A It ensures the dependency is executed once per request for all endpoints in the router, reducing code repetition.

B It disables dependency injection for endpoints not needing it.

C It automatically caches the dependency result across all requests.

D It allows dependencies to modify the router's URL prefix dynamically.

💡 Hint

Think about code reuse and how dependencies apply to multiple endpoints.

Applying dependencies at the router level avoids repeating the same dependency on every endpoint. It runs the dependency once per request for all endpoints in that router.