Why dependency injection matters in FastAPI - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FastAPI class.

FastAPI

from fastapi import [1]
app = [1]()

Drag options to blanks, or click blank then click option'

AFastAPI

BResponse

CRequest

DDepends

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Depends instead of FastAPI

Using Request or Response instead of FastAPI

FastAPI is the main class to create an app instance.

2fill in blank

medium

Complete the code to declare a dependency using Depends.

FastAPI

from fastapi import Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get("/items")
def read_items(token: str = [1](get_token)):
    return {"token": token}

Drag options to blanks, or click blank then click option'

ADepends

BRequest

CResponse

DFastAPI

Attempts:

3 left

💡 Hint

Common Mistakes

Using Request or Response instead of Depends

Not wrapping the dependency function

Depends is used to declare dependencies in FastAPI.

3fill in blank

hard

Fix the error in the dependency injection to correctly inject the database session.

FastAPI

from fastapi import Depends

app = FastAPI()

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

@app.get("/users")
def read_users(db: Session = [1](get_db)):
    return db.query(User).all()

Drag options to blanks, or click blank then click option'

ARequest

BDepends

CFastAPI

DResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to use Depends causes runtime errors

Using Request or Response instead of Depends

Depends is required to inject the get_db dependency properly.

4fill in blank

hard

Fill both blanks to create a reusable dependency and inject it into the route.

FastAPI

from fastapi import Depends

app = FastAPI()

def common_parameters(q: str = None, limit: int = 10):
    return {"q": q, "limit": limit}

@app.get("/search")
def search(params: dict = [1](common_parameters)):
    return params if params[[2]] else {"limit": 10}

Drag options to blanks, or click blank then click option'

ADepends

B"q"

C"limit"

DRequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using Request instead of Depends

Using wrong dictionary keys

Depends injects the common_parameters dependency. The key "q" is used to check the query.

5fill in blank

hard

Fill all three blanks to declare a dependency with parameters and use it in a route.

FastAPI

from fastapi import Depends

app = FastAPI()

def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def get_items(p: dict = [1](pagination)):
    return {"skip": p[[2]], "limit": p[[3]]}

Drag options to blanks, or click blank then click option'

ADepends

B"skip"

C"limit"

D"page"

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong keys like "page"

Not using Depends to inject the dependency

Depends injects the pagination dependency. The keys "skip" and "limit" access pagination values.

Practice

1. Why is dependency injection important in FastAPI applications?

easy

A. It forces you to write all code inside one big function.

B. It automatically generates HTML pages for your API.

C. It speeds up the server by caching all responses.

D. It helps keep code clean and makes components easy to share or replace.

Solution

1. Step 1: Understand the purpose of dependency injection

   Dependency injection allows you to provide parts like services or database connections to your functions without hardcoding them.

2. Step 2: Recognize benefits in FastAPI

   This makes your code cleaner and more flexible, as you can easily swap or share components.

3. Final Answer:

   It helps keep code clean and makes components easy to share or replace. -> Option D

4. Quick Check:

   Dependency injection = clean, flexible code [OK]

Hint: Think: clean code and easy swapping [OK]

Common Mistakes:

• Confusing dependency injection with caching
• Thinking it generates HTML automatically
• Believing it forces monolithic code

2. Which of the following is the correct way to declare a dependency in a FastAPI path operation?

easy

A. def read_data(db = Depends(get_db)):

B. def read_data(db: Depends = get_db):

C. def read_data(db: Depends(get_db)):

D. def read_data(db = get_db()):

Solution

1. Step 1: Recall FastAPI dependency syntax

   FastAPI uses Depends() inside the function parameter default value to declare dependencies.

2. Step 2: Check each option

   def read_data(db = Depends(get_db)): correctly uses db = Depends(get_db). Others misuse type hints or call the function directly.

3. Final Answer:

   def read_data(db = Depends(get_db)): -> Option A

4. Quick Check:

   Depends() in default value = correct syntax [OK]

Hint: Use Depends() as default parameter value [OK]

Common Mistakes:

• Calling the dependency function instead of passing it
• Using Depends as a type hint incorrectly
• Assigning dependency without Depends()

3. Given this FastAPI code snippet, what will be printed when accessing the endpoint?

from fastapi import FastAPI, Depends
app = FastAPI()

def get_number():
    return 42

@app.get("/number")
def read_number(num: int = Depends(get_number)):
    print(f"Number is {num}")
    return {"number": num}

medium

A. Number is 42 printed in console, response JSON {"number": 42}

B. Number is 0 printed in console, response JSON {"number": 0}

C. Error because get_number is not awaited

D. Response JSON {"number": null} with no print

Solution

1. Step 1: Understand dependency injection behavior

   The get_number function returns 42 and is injected as the parameter num.

2. Step 2: Trace the endpoint execution

   When the endpoint is called, it prints "Number is 42" and returns JSON with number 42.

3. Final Answer:

   Number is 42 printed in console, response JSON {"number": 42} -> Option A

4. Quick Check:

   Depends injects 42, prints and returns it [OK]

Hint: Dependency returns 42, so print shows 42 [OK]

Common Mistakes:

• Thinking dependency must be async
• Expecting default 0 instead of injected value
• Confusing print output with response content

4. What is wrong with this FastAPI dependency usage?

def get_db():
    return "db_connection"

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

medium

A. The function get_db is missing async keyword.

B. The dependency function is called immediately instead of injected.

C. The endpoint is missing a return statement.

D. Depends() is used incorrectly inside the function body.

Solution

1. Step 1: Identify how dependency should be declared

   Dependencies must be passed as Depends(get_db), not by calling get_db() directly.

2. Step 2: Explain the problem in the code

   Calling get_db() runs it once at startup, not per request, losing flexibility and benefits of injection.

3. Final Answer:

   The dependency function is called immediately instead of injected. -> Option B

4. Quick Check:

   Call vs Depends() matters for injection [OK]

Hint: Use Depends(), don't call dependency function [OK]

Common Mistakes:

• Calling dependency function instead of passing Depends()
• Confusing async requirement with dependency injection
• Ignoring missing return statement (it exists here)

5. You want to share a database connection across multiple endpoints in FastAPI using dependency injection. Which approach best ensures the connection is created once per request and properly closed after?

hard

A. Pass the connection as a query parameter to each endpoint.

B. Create the connection globally once outside any function and reuse it everywhere.

C. Use a dependency function with yield that opens the connection, yields it, then closes it after.

D. Call the connection function directly inside each endpoint without Depends.

Solution

1. Step 1: Understand lifecycle management with dependencies

   Using yield in a dependency function allows setup before yield and cleanup after the request finishes.

2. Step 2: Compare options for connection management

   Use a dependency function with yield that opens the connection, yields it, then closes it after. correctly manages connection per request lifecycle. Others either create global state or misuse parameters.

3. Final Answer:

   Use a dependency function with yield that opens the connection, yields it, then closes it after. -> Option C

4. Quick Check:

   Yield in dependency = setup and cleanup per request [OK]

Hint: Use yield in dependency for setup and cleanup [OK]

Common Mistakes:

• Using global connection risking concurrency issues
• Calling connection directly losing cleanup control
• Passing connection via query parameters insecurely