Overriding dependencies in tests in FastAPI - Step-by-Step Execution

Concept Flow - Overriding dependencies in tests

Define original dependency

↓

Create FastAPI app

↓

Use dependency in route

↓

Write test function

↓

Override dependency with test version

↓

Run test client request

↓

Check response uses overridden dependency

This flow shows how FastAPI uses a dependency in a route, then in tests, the dependency is replaced with a test version to control behavior.

Execution Sample

FastAPI

from fastapi import FastAPI, Depends
app = FastAPI()

def get_number():
    return 42

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

Defines a FastAPI app with a route that depends on a function returning 42.

Execution Table

Step	Action	Dependency Used	Request Result	Notes
1	App starts	get_number	N/A	Original dependency returns 42
2	Test starts	get_number	N/A	Prepare to override dependency
3	Override dependency with get_test_number	get_test_number	N/A	Test dependency returns 99
4	Test client sends GET /number	get_test_number	{"number": 99}	Response uses overridden dependency
5	Test ends	get_number	N/A	Dependency override removed

💡 Test finishes after verifying response uses overridden dependency

Variable Tracker

Variable	Start	After Override	After Test Request	Final
dependency_function	get_number (returns 42)	get_test_number (returns 99)	get_test_number (returns 99)	get_number (returns 42)

Key Moments - 2 Insights

Why does the test response show 99 instead of 42?

Because in step 3 of the execution_table, the original dependency get_number is overridden by get_test_number which returns 99, so the route uses the test version during the test request.

Does the original dependency stay overridden after the test?

No, as shown in step 5, the override is removed after the test ends, so the app uses the original dependency again.

Visual Quiz - 3 Questions

Look at the execution_table, what does the dependency_function return after override?

A 99

B None

C 42

D 0

💡 Hint

Check the 'After Override' column in variable_tracker for dependency_function

At which step does the test client send the GET request?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Action' column in execution_table for when the test client sends the request

If the override was not removed after the test, what would happen?

A The app would always return 42

B The app would crash

C The app would always return 99

D The app would return None

💡 Hint

Refer to the 'Final' column in variable_tracker and step 5 in execution_table

Concept Snapshot

FastAPI lets you replace dependencies during tests.
Define your original dependency function.
In tests, override it with app.dependency_overrides.
Run test client requests using the overridden version.
After tests, remove overrides to restore original behavior.

Full Transcript

This visual execution shows how FastAPI dependencies can be overridden in tests. First, the app uses a dependency function that returns 42. During testing, this dependency is replaced with a test version returning 99. When the test client sends a request, the route uses the overridden dependency, so the response contains 99. After the test, the override is removed, restoring the original dependency. This allows controlled testing of routes depending on external or variable data.