Testing FastAPI

Testing FastAPI: Your App’s Safety Net

The Story of the Quality Inspector

Imagine you’re building a LEGO castle. Before you show it to your friends, wouldn’t you want to make sure:

• All the pieces are connected properly?
• The doors open and close?
• The tower doesn’t fall over?

That’s exactly what testing does for your FastAPI app! It’s like having a tiny robot inspector that checks everything works perfectly before real users see it.

What is Testing?

Think of testing like a dress rehearsal before a big play. The actors (your code) perform their parts, and you watch to make sure everyone says their lines correctly and doesn’t bump into the furniture!

Why Test?

• Catch bugs BEFORE users find them
• Sleep better at night knowing your app works
• Change code confidently without breaking things

Meet TestClient: Your Robot Inspector

FastAPI gives you a special friend called TestClient. It pretends to be a user visiting your website, but it’s actually a robot that reports back what happened!

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

Analogy: TestClient is like a friend who volunteers to taste-test your cookies and honestly tells you if they’re good!

Testing FastAPI Applications

Your First Test: The Hello World Check

Let’s say your app has a simple endpoint:

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

Here’s how you test it:

# test_main.py
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {
        "message": "Hello World"
    }

What’s happening?

1. Robot inspector visits “/”
2. Checks: Did the server say “200 OK”?
3. Checks: Is the message correct?

Testing Different HTTP Methods

Your robot inspector can do ALL the actions:

# GET - Reading something
response = client.get("/items/5")

# POST - Creating something
response = client.post(
    "/items/",
    json={"name": "apple", "price": 1.5}
)

# PUT - Updating something
response = client.put(
    "/items/5",
    json={"name": "banana", "price": 2.0}
)

# DELETE - Removing something
response = client.delete("/items/5")

Think of it like:

• GET = “Can I see that toy?”
• POST = “Here’s a new toy!”
• PUT = “Let me fix this toy”
• DELETE = “Throw this toy away”

Testing with Query Parameters

When your endpoint takes extra info in the URL:

# Your endpoint
@app.get("/items/")
def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

# Your test
def test_read_items_with_params():
    response = client.get(
        "/items/?skip=5&limit=20"
    )
    assert response.status_code == 200
    assert response.json() == {
        "skip": 5,
        "limit": 20
    }

Testing with Request Bodies

When you need to send data:

def test_create_item():
    response = client.post(
        "/items/",
        json={
            "name": "Magic Wand",
            "price": 9.99,
            "is_offer": True
        }
    )
    assert response.status_code == 200
    data = response.json()
    assert data["name"] == "Magic Wand"

Testing with Dependencies

Here’s where it gets REALLY cool!

What are Dependencies?

Dependencies are like helper friends that your endpoints need. For example:

• A friend who checks if you’re logged in
• A friend who connects to the database
• A friend who validates your data

from fastapi import Depends

def get_current_user():
    # Normally checks authentication
    return {"username": "real_user"}

@app.get("/users/me")
def read_current_user(
    user = Depends(get_current_user)
):
    return user

The Problem with Real Dependencies

During testing, you DON’T want to:

• Use the real database (what if it deletes data?)
• Send real emails (awkward!)
• Check real authentication (too complicated)

Solution: Use FAKE friends (mock dependencies)!

Dependency Override: The Magic Swap

FastAPI lets you swap out real helpers for fake ones during tests. It’s like saying “During practice, use a stuffed animal instead of a real dog.”

# The REAL dependency
def get_db():
    db = RealDatabase()
    return db

# The FAKE dependency for testing
def override_get_db():
    fake_db = FakeDatabase()
    return fake_db

# SWAP them!
app.dependency_overrides[get_db] = override_get_db

Complete Example: Testing with Overrides

# main.py
from fastapi import FastAPI, Depends

app = FastAPI()

def get_settings():
    return {"mode": "production"}

@app.get("/info")
def get_info(
    settings = Depends(get_settings)
):
    return {"settings": settings}

# test_main.py
from fastapi.testclient import TestClient
from main import app, get_settings

def override_settings():
    return {"mode": "testing"}

app.dependency_overrides[get_settings] = (
    override_settings
)

client = TestClient(app)

def test_get_info():
    response = client.get("/info")
    assert response.json() == {
        "settings": {"mode": "testing"}
    }

# Clean up after yourself!
app.dependency_overrides = {}

Testing Authentication Dependencies

Here’s a common real-world pattern:

# main.py
from fastapi import Depends, HTTPException

def get_current_user(token: str):
    if token != "secret-token":
        raise HTTPException(
            status_code=401,
            detail="Invalid token"
        )
    return {"user": "john"}

@app.get("/protected")
def protected_route(
    user = Depends(get_current_user)
):
    return {"message": f"Hello {user}"}

# test_main.py
def override_current_user():
    return {"user": "test_user"}

app.dependency_overrides[get_current_user] = (
    override_current_user
)

def test_protected_route():
    # No need for real token!
    response = client.get("/protected")
    assert response.status_code == 200

The Testing Flow

graph TD
    A["Write Your Code"] --> B["Write Tests"]
    B --> C["Run Tests"]
    C --> D{All Pass?}
    D -->|Yes| E["Ship It!"]
    D -->|No| F["Fix Bugs"]
    F --> C

Running Your Tests

Use pytest (the friendly test runner):

pip install pytest
pytest test_main.py -v

Output looks like:

test_main.py::test_read_root PASSED
test_main.py::test_create_item PASSED
test_main.py::test_protected PASSED

Green checkmarks everywhere = Happy developer!

Pro Tips for Testing

1. Test Happy Paths AND Sad Paths

def test_item_not_found():
    response = client.get("/items/9999")
    assert response.status_code == 404

def test_invalid_input():
    response = client.post(
        "/items/",
        json={"name": ""}  # Empty name!
    )
    assert response.status_code == 422

2. Always Clean Up Overrides

def test_something():
    app.dependency_overrides[get_db] = fake_db
    # ... run test ...
    app.dependency_overrides = {}  # Reset!

3. Use Fixtures for Reusable Setup

import pytest

@pytest.fixture
def test_client():
    app.dependency_overrides[get_db] = fake_db
    yield TestClient(app)
    app.dependency_overrides = {}

Summary: Your Testing Toolkit

You Did It!

You now know how to:

• Create tests using TestClient
• Test all HTTP methods (GET, POST, PUT, DELETE)
• Override dependencies for safe testing
• Run tests with pytest

Remember: Testing isn’t about being paranoid. It’s about being confident. Every test you write is a promise that your code keeps!

Now go forth and test everything! Your users (and your future self) will thank you.