FastAPI Backend Development Bootcamp · Lesson

Mocking Dependencies in FastAPI Tests

Learn how to isolate FastAPI endpoints in tests by overriding dependencies and mocking external services.

Mocking Dependencies in FastAPI Tests is a free FastAPI Backend Development Bootcamp lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the FastAPI Backend Development Bootcamp learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Mock Dependencies?

When testing a FastAPI endpoint, you often want to isolate the route logic from external systems like databases, payment gateways, or third-party APIs.

Mocking replaces those slow or unreliable parts with predictable fakes so your tests stay fast and deterministic.

FastAPI Dependency Overrides

FastAPI exposes app.dependency_overrides, a dictionary that maps a real dependency to a fake one during testing.

This is the cleanest way to swap a database session or auth check without touching production code.

app.dependency_overrides[get_db] = override_get_db

A Dependency to Override

Imagine an endpoint that depends on a database session.

from fastapi import Depends

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

@app.get("/users/{uid}")
def read_user(uid: int, db=Depends(get_db)):
    return db.query(User).get(uid)

Providing a Fake Session

In your test, define a function that yields an in-memory or test session, then register it as an override.

def override_get_db():
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()

app.dependency_overrides[get_db] = override_get_db

Clearing Overrides

Always clear overrides after a test so they do not leak into other tests.

Use app.dependency_overrides.clear() in teardown or a pytest fixture finalizer.

app.dependency_overrides.clear()

Mocking with unittest.mock

For non-dependency code such as a helper that calls an external API, use unittest.mock.patch to replace the function.

from unittest.mock import patch

with patch("app.services.send_email") as mock_send:
    mock_send.return_value = True
    response = client.post("/signup", json=payload)
    mock_send.assert_called_once()

Using MagicMock Return Values

A MagicMock lets you script return values and inspect how it was called.

from unittest.mock import MagicMock

fake_client = MagicMock()
fake_client.charge.return_value = {"status": "ok"}

Mocking Async Functions

FastAPI is async-friendly. To mock an async dependency, use AsyncMock so awaiting it works correctly.

from unittest.mock import AsyncMock

mock_repo = AsyncMock()
mock_repo.get_user.return_value = {"id": 1, "name": "Ada"}

Mocking Auth Dependencies

To bypass authentication in a test, override the auth dependency to return a fake user.

def fake_current_user():
    return User(id=1, role="admin")

app.dependency_overrides[get_current_user] = fake_current_user

Verifying Mock Calls

Mocks record every interaction. Assert that your code called the dependency the expected way.

mock_send.assert_called_once_with(to="a@b.com")
assert mock_repo.save.call_count == 1

Fixture-Based Overrides

Wrap overrides in a pytest fixture for reuse and automatic cleanup.

import pytest

@pytest.fixture
def client_with_db():
    app.dependency_overrides[get_db] = override_get_db
    yield TestClient(app)
    app.dependency_overrides.clear()

Quick Check

Test your mocking knowledge.

Recap

You learned how to isolate FastAPI endpoints in tests:

dependency_overrides swaps dependencies like DB sessions or auth
patch / MagicMock / AsyncMock fake external functions
Always clear overrides after each test

Mocking keeps tests fast, deterministic, and focused on your own logic.

Frequently asked questions

Is the “Mocking Dependencies in FastAPI Tests” lesson free?

Yes — the full text of “Mocking Dependencies in FastAPI Tests” is free to read here on the web, and the FastAPI Backend Development Bootcamp course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the FastAPI Backend Development Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Mocking Dependencies in FastAPI Tests”?

Learn how to isolate FastAPI endpoints in tests by overriding dependencies and mocking external services. You practise FastAPI Backend Development Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start FastAPI Backend Development Bootcamp?

No prior experience is required. FastAPI Backend Development Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Mocking Dependencies in FastAPI Tests” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this FastAPI Backend Development Bootcamp lesson?

Yes. Every FastAPI Backend Development Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to FastAPI Backend Development Bootcamp