Global dependencies in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI app with global dependencies?

Consider this FastAPI app where a global dependency adds a header. What will the response headers contain when you call /items/42?

FastAPI

from fastapi import FastAPI, Depends, Header

app = FastAPI()

def common_header(x_token: str = Header(...)):
    return x_token

@app.get("/items/{item_id}", dependencies=[Depends(common_header)])
async def read_item(item_id: int):
    return {"item_id": item_id}

A The response includes header 'x-token' with the value sent by the client.

B The response includes header 'x-token' with value 'None'.

C The response is 422 Unprocessable Entity because header 'x-token' is missing.

D The response body includes the token value under key 'x_token'.

💡 Hint

Think about what happens if the required header is missing in the request.

The dependency common_header requires the header x-token. If the client does not send it, FastAPI returns a 422 error before calling the path operation.

❓ state_output

intermediate

What is the value of the dependency result in this global dependency example?

Given this FastAPI app, what will be the value of token_value inside the endpoint?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "secret-token"

@app.get("/users/me", dependencies=[Depends(get_token)])
async def read_user(token_value: str = Depends(get_token)):
    return {"token": token_value}

A "secret-token"

B None

C Raises a runtime error due to duplicate dependency

D Empty string

💡 Hint

Consider how FastAPI resolves dependencies when the same function is used globally and locally.

FastAPI calls the dependency function for each injection. The global dependency does not affect the local parameter. So token_value is "secret-token".

📝 Syntax

advanced

Which option correctly defines a global dependency in FastAPI?

Choose the correct way to add a global dependency that runs for every request.

A app = FastAPI(dependencies=[Depends(common_dep)])

B

app = FastAPI()
@app.global_dependency
async def common_dep(): pass

C

app = FastAPI()
app.add_dependency(common_dep)

D

app = FastAPI()
app.include_dependency(common_dep)

💡 Hint

Check FastAPI docs for how to add global dependencies at app creation.

FastAPI accepts a dependencies parameter in the constructor to add global dependencies. Other options are invalid syntax or methods.

🔧 Debug

advanced

Why does this global dependency not run for the endpoint?

Given this code, why is the global dependency verify_token not executed when calling /open?

FastAPI

from fastapi import FastAPI, Depends

def verify_token():
    print("Token verified")

app = FastAPI(dependencies=[Depends(verify_token)])

@app.get("/open")
async def open_endpoint():
    return {"message": "Open to all"}

A Because the endpoint does not have any path parameters.

B Because the global dependency runs but print output is not visible in response.

C Because the global dependency is only called if the endpoint has a matching parameter.

D Because the global dependency is ignored for endpoints without explicit Depends in signature.

💡 Hint

Think about where print output goes in FastAPI apps.

The global dependency runs for every request. The print statement outputs to the server console, not the HTTP response. So the client sees the JSON response only.

🧠 Conceptual

expert

How does FastAPI handle multiple global dependencies with overlapping parameters?

Suppose you add two global dependencies that both require a header x-token. How does FastAPI handle this situation?

A FastAPI calls only the first global dependency and skips the second.

B FastAPI requires the header twice and expects two different values.

C FastAPI raises a runtime error due to duplicate header dependencies.

D FastAPI calls both dependencies once each, sharing the same header value from the request.

💡 Hint

Consider how FastAPI resolves dependencies and parameters from requests.

FastAPI calls each dependency separately but uses the same request data. The header x-token is read once and passed to both dependencies.