FastAPI Backend Development Bootcamp · Pelajaran

Mocking Dependensi dalam Pengujian FastAPI

Pelajari cara mengisolasi endpoint FastAPI dalam pengujian dengan mengganti dependensi dan melakukan mocking pada layanan eksternal.

Mocking Dependensi dalam Pengujian FastAPI adalah pelajaran FastAPI Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar FastAPI Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mocking Dependensi dalam Pengujian FastAPI” gratis?

Ya — teks lengkap “Mocking Dependensi dalam Pengujian FastAPI” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus FastAPI Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mocking Dependensi dalam Pengujian FastAPI”?

Pelajari cara mengisolasi endpoint FastAPI dalam pengujian dengan mengganti dependensi dan melakukan mocking pada layanan eksternal. Kamu berlatih FastAPI Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai FastAPI Backend Development Bootcamp?

Tidak diperlukan pengalaman sebelumnya. FastAPI Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Mocking Dependensi dalam Pengujian FastAPI” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran FastAPI Backend Development Bootcamp ini?

Ya. Setiap pelajaran FastAPI Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Pengujian Unit dengan Pytest
Pengujian Integrasi Titik Akhir FastAPI
Men-debug Aplikasi FastAPI
Mocking Dependensi dalam Pengujian FastAPI

← Kembali ke FastAPI Backend Development Bootcamp