Shared dependencies in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI shared dependency example?

Consider this FastAPI code using a shared dependency:

from fastapi import FastAPI, Depends

app = FastAPI()

async def common_dep():
    return "shared value"

@app.get("/one")
async def one(dep=Depends(common_dep)):
    return {"result": dep}

@app.get("/two")
async def two(dep=Depends(common_dep)):
    return {"result": dep + " appended"}

What will be the JSON response from the endpoint /two?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

async def common_dep():
    return "shared value"

@app.get("/one")
async def one(dep=Depends(common_dep)):
    return {"result": dep}

@app.get("/two")
async def two(dep=Depends(common_dep)):
    return {"result": dep + " appended"}

A {"result": "shared value appended appended"}

B {"result": "shared value"}

C {"result": "shared value appended"}

D {"result": null}

💡 Hint

Think about what the dependency common_dep returns and how it is used in the /two endpoint.

The dependency common_dep returns the string "shared value". The /two endpoint appends " appended" to this string, so the final result is "shared value appended".

❓ state_output

intermediate

How many times is the shared dependency called in this FastAPI example?

Given this FastAPI code:

from fastapi import FastAPI, Depends

app = FastAPI()

call_count = 0

async def shared_dep():
    global call_count
    call_count += 1
    return call_count

@app.get("/first")
async def first(dep=Depends(shared_dep)):
    return {"count": dep}

@app.get("/second")
async def second(dep=Depends(shared_dep)):
    return {"count": dep}

If a client calls /first and then /second in sequence, what will be the value of call_count after both calls?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

call_count = 0

async def shared_dep():
    global call_count
    call_count += 1
    return call_count

@app.get("/first")
async def first(dep=Depends(shared_dep)):
    return {"count": dep}

@app.get("/second")
async def second(dep=Depends(shared_dep)):
    return {"count": dep}

A 0

B 2

C 3

D 1

💡 Hint

Each endpoint call triggers the dependency function once.

Each endpoint calls shared_dep once, so after two calls, call_count is 2.

🔧 Debug

advanced

What error does this FastAPI shared dependency code raise?

Examine this FastAPI code snippet:

from fastapi import FastAPI, Depends

app = FastAPI()

async def dep():
    return 42

@app.get("/error")
async def error(dep=Depends(dep())):
    return {"value": dep}

What error will occur when starting or calling the /error endpoint?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

async def dep():
    return 42

@app.get("/error")
async def error(dep=Depends(dep())):
    return {"value": dep}

A TypeError: 'int' object is not callable

B No error, returns {"value": 42}

C SyntaxError: invalid syntax

D RuntimeError: Dependency function called at import time

💡 Hint

Check how the dependency is passed to Depends.

The code calls dep() immediately when defining the dependency, so the async function is executed at import time, which FastAPI does not allow. This causes a runtime error.

🧠 Conceptual

advanced

Which option correctly shares a database session dependency in FastAPI?

You want to share a database session dependency across multiple endpoints in FastAPI. Which code snippet correctly implements this shared dependency?

A

def get_db():
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

B

def get_db():
    db = Session()
    return db
    db.close()

@app.get("/items")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

C

def get_db():
    db = Session()
    yield db
    db.close()

@app.get("/items")
async def read_items(db=Depends(get_db())):
    return db.query(Item).all()

D

def get_db():
    db = Session()
    yield db

@app.get("/items")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

💡 Hint

Think about how to properly open and close resources with dependencies.

Option A uses a generator with try/finally to ensure the database session is closed after use. This is the recommended pattern for shared dependencies managing resources.

📝 Syntax

expert

What is the correct syntax to declare a shared dependency with parameters in FastAPI?

Given a dependency function that accepts parameters, which option correctly declares it for use as a shared dependency in FastAPI?

def common_dep(param: int):
    return param * 2

FastAPI

def common_dep(param: int):
    return param * 2

A

@app.get("/calc")
async def calc(value: int, result=Depends(lambda: common_dep(value))):
    return {"result": result}

B

@app.get("/calc")
async def calc(value: int, result=Depends(common_dep)):
    return {"result": result}

C

@app.get("/calc")
async def calc(value: int, result=Depends(common_dep(value))):
    return {"result": result}

D

}tluser :"tluser"{ nruter    
:))ped_nommoc(sdnepeD=tluser ,tni :eulav(clac fed cnysa
)"clac/"(teg.ppa@

💡 Hint

Consider how to pass parameters to dependencies dynamically.

Option A uses a lambda to call common_dep with the parameter value at runtime, which is the correct way to pass parameters to dependencies.