Creating Unit Tests

In this lesson you’ll learn how to create unit tests for a small FastAPI service and how tools like GitHub Copilot can speed up the process. We’ll start from a fragmented, hard-to-test example and refactor it into a compact, testable app/main.py. Then we’ll add pytest-based unit tests that mock database access so tests remain fast and deterministic.

Why this approach matters

Small modules with clear, testable boundaries make unit testing straightforward.
Isolating I/O (like the database) behind functions or context managers enables easy mocking.
Fast unit tests improve developer feedback loops and catch regressions early.

Initial (fragmented) example

The original code was split across many files and included duplicated logic. Below is a representative fragment showing an endpoint that relies on external modules. This fragmentation makes end-to-end tests slow and unit tests brittle.

from fastapi import APIRouter, HTTPException
from ..models.fake_data_request import FakeDataRequest
from ...data.fake_data_repository import get_fake_data

# Initialize FastAPI router instance
router = APIRouter()

@router.post("/getfakedata", response_model=dict)  # Changed from /fake-data to /getfakedata
async def generate_fake_data(request: FakeDataRequest) -> dict:
    """
    Generate fake data based on request parameters.

    Args:
        request (FakeDataRequest): The request model containing parameters

    Returns:
        dict: Generated fake data response
    """
    try:
        data = await get_fake_data(request.dict())
        return {"data": data}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Refactor: single-file, testable application

Consolidate the core application and database access into a small, well-documented module. This makes it clear where to patch/mocks during tests.

Main application (refactored app/main.py):

# app/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import sqlite3
from typing import List, Dict
from contextlib import contextmanager
from pathlib import Path

app = FastAPI(title="Fake Data API")

class DataRequest(BaseModel):
    count: int

BASE_DIR = Path(__file__).resolve().parent
DATA_DIR = BASE_DIR / "data" / "db"
DB_PATH = DATA_DIR / "fakedata.db"

# Create data directory if it doesn't exist
DATA_DIR.mkdir(parents=True, exist_ok=True)

@contextmanager
def get_db_connection():
    """
    Create and manage a database connection as a context manager.

    Yields:
        sqlite3.Connection: An active connection to the SQLite database.
    """
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    try:
        yield conn
    finally:
        conn.close()

def fetch_fake_data(count: int) -> List[Dict]:
    """
    Fetch `count` random rows from the fakedata table.

    Args:
        count (int): Number of rows to retrieve.

    Returns:
        List[Dict]: List of rows represented as dictionaries.
    """
    query = "SELECT * FROM fakedata ORDER BY RANDOM() LIMIT ?"
    with get_db_connection() as conn:
        cursor = conn.cursor()
        cursor.execute(query, (count,))
        rows = cursor.fetchall()
        return [dict(row) for row in rows]

@app.post("/api/v1/getfakedata")
async def get_fake_data(request: DataRequest):
    """
    Retrieve a specified number of fake data entries.

    Raises:
        HTTPException:
            400 if the count is <= 0 or > 1000
            404 if no data is found
            500 on database errors
    """
    count = request.count
    if count <= 0:
        raise HTTPException(status_code=400, detail="Count must be greater than 0")
    if count > 1000:
        raise HTTPException(status_code=400, detail="Count must not exceed 1000")

    try:
        data = fetch_fake_data(count)
        if not data:
            raise HTTPException(status_code=404, detail="No data found")
        return data
    except sqlite3.Error as e:
        raise HTTPException(status_code=500, detail=f"Database error: {e}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Run the app locally

Start with uvicorn and test an endpoint:

uvicorn app.main:app --reload

Sample uvicorn output:

INFO:     Started server process [23262]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO:     127.0.0.1:49774 - "POST /api/v1/getfakedata HTTP/1.1" 200 OK

Unit tests should not hit production or persistent databases. Mock database connections or use a temporary test database to keep unit tests fast and deterministic.

Generating tests with GitHub Copilot

GitHub Copilot can scaffold tests quickly if you add a focused comment like # generate unit tests near your functions or use a Copilot workspace flow. Always review and refine the generated tests to ensure they mock external dependencies and verify behavior (not just happy paths).

Choosing a test framework

pytest is used in this example because of its concise fixtures and compatibility with unittest-style tests.
Use fastapi.testclient.TestClient for synchronous tests against the FastAPI app.

Example pytest test file (app/test_main.py)

These unit tests patch the database access layer (get_db_connection or fetch_fake_data) so no real SQLite file is touched.

# app/test_main.py
import sqlite3
from unittest.mock import patch, MagicMock
import pytest
from fastapi.testclient import TestClient

from app.main import app, fetch_fake_data

client = TestClient(app)

@pytest.fixture
def sample_data():
    return [
        {
            "first_name": "John",
            "last_name": "Doe",
            "email_address": "john@example.com",
            "age": 30,
            "city": "New York",
            "occupation": "Engineer"
        },
        {
            "first_name": "Jane",
            "last_name": "Smith",
            "email_address": "jane@example.com",
            "age": 28,
            "city": "San Francisco",
            "occupation": "Designer"
        }
    ]

def test_fetch_fake_data_success(sample_data):
    """Test fetch_fake_data returns expected transformed rows."""
    # Patch get_db_connection to return a mock connection/cursor
    mock_conn = MagicMock()
    mock_cursor = MagicMock()
    # Emulate cursor.fetchall() returning rows that dict(row) can handle (use dicts)
    mock_cursor.fetchall.return_value = [sample_data[0], sample_data[1]]
    mock_conn.cursor.return_value = mock_cursor
    # Ensure the mocked context manager returns our mock connection when used with 'with'
    mock_conn.__enter__.return_value = mock_conn

    with patch("app.main.get_db_connection", return_value=mock_conn):
        result = fetch_fake_data(2)
        assert isinstance(result, list)
        assert len(result) == 2
        assert result[0]["first_name"] == "John"

def test_get_fake_data_success(sample_data):
    """Test endpoint returns data when fetch_fake_data succeeds."""
    with patch("app.main.fetch_fake_data", return_value=sample_data):
        response = client.post("/api/v1/getfakedata", json={"count": 2})
        assert response.status_code == 200
        assert isinstance(response.json(), list)
        assert response.json()[0]["first_name"] == "John"

def test_get_fake_endpoint_invalid_count():
    """Test API endpoint with invalid count values."""
    # count <= 0
    response = client.post("/api/v1/getfakedata", json={"count": 0})
    assert response.status_code == 400
    assert "greater than 0" in response.json()["detail"]

    # count > 1000
    response = client.post("/api/v1/getfakedata", json={"count": 1001})
    assert response.status_code == 400
    assert "must not exceed 1000" in response.json()["detail"]

def test_get_fake_data_endpoint_no_data():
    """Test API endpoint when no data is found."""
    with patch("app.main.fetch_fake_data", return_value=[]):
        response = client.post("/api/v1/getfakedata", json={"count": 1})
        assert response.status_code == 404
        assert "No data found" in response.json()["detail"]

def test_get_fake_data_endpoint_database_error():
    """Test API endpoint handling of database errors."""
    with patch("app.main.fetch_fake_data", side_effect=sqlite3.Error("Database error")):
        response = client.post("/api/v1/getfakedata", json={"count": 1})
        assert response.status_code == 500
        assert "Database error" in response.json()["detail"]

Why these tests work

Tests patch app.main.fetch_fake_data or app.main.get_db_connection so they do not access an actual SQLite database.
fastapi.testclient.TestClient allows synchronous testing of async endpoints.
unittest.mock.patch and MagicMock simulate connections, cursors, and database errors.

Running tests with pytest

Install pytest:

pip install pytest

Run tests:

pytest

Example pytest output:

collected 6 items

app/test_main.py ......                                         [100%]

6 passed in 0.21s

Validating tests catch regressions

Intentionally introduce a small bug (for example: count = request.count + 1) and rerun tests. A failure indicates your tests detect the regression and are valuable.

Testing strategy comparison

Test type	Typical scope	Recommendation
Unit	Single function or method; external I/O mocked	Fast, deterministic; use for most logic
Integration	Multiple components including DB or network	Run in CI with test-specific resources (e.g. temporary DB)
End-to-end (E2E)	Full system with real dependencies	Run less frequently; used for final verification

Note: when showing examples with object literals or placeholders, keep them wrapped in backticks to avoid MDX parsing issues (for example: {"first_name": "John"} or <NODEPORT>). Alternative: unittest-based tests

If you prefer the standard library, write tests with unittest.TestCase. pytest discovers and runs unittest-style tests too. For database integration tests, use a temporary or in-memory database (do not point tests to production DB).

Do not run unit tests that modify or connect to production databases. Always isolate unit tests from persistent environments and use mocks or test-specific databases.

Summary and best practices

Refactor code into a small, testable module with clear I/O boundaries (database access isolated).
Use pytest + TestClient for fast API endpoint tests.
Mock database access (get_db_connection or fetch_fake_data) so unit tests remain isolated and deterministic.
Use GitHub Copilot to scaffold tests, but review, refine, and add edge-case assertions.
Keep tests focused: fast, small, and meaningful.

Links and references

This completes the lesson on creating unit tests for a small FastAPI service.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Creating Unit Tests

Watch Video