integration-test-writer

Integration Test Writer Skill

Purpose

This skill provides systematic guidance for writing integration tests that verify component interactions, API endpoints, database operations, and end-to-end workflows. Integration tests validate that multiple components work together correctly.

When to Use

• Test API endpoints and routes
• Verify database interactions
• Test multi-component workflows
• Validate authentication and authorization flows
• Test external service integrations
• Verify error handling across boundaries

Integration vs Unit Testing

Unit Tests:

• Test single component in isolation
• Mock all dependencies
• Fast execution (< 1 second)
• High coverage of edge cases

Integration Tests:

• Test multiple components together
• Use real or test doubles (minimal mocking)
• Slower execution (seconds to minutes)
• Focus on component interactions

---

Integration Testing Workflow

1. Identify Integration Points

Map the system:

# Identify components to test together
- API controllers + Services + Database
- Services + External APIs
- Authentication + Authorization + Resources
- Multi-step workflows

Integration test targets:

• API endpoints (all HTTP methods)
• Database CRUD operations
• Authentication flows
• Authorization checks
• External service calls
• Multi-component workflows
• Error propagation across boundaries

Deliverable: Integration test plan

---

2. Setup Test Environment

Test environment components:

1. Test Database:

   • Separate database for testing
   • Reset between tests
   • Seed data for tests

2. Test Configuration:

   • Override production settings
   • Use test credentials
   • Mock external services

3. Test Fixtures:

   • Factory functions for test data
   • Reusable setup/teardown
   • Consistent test state

Python example (pytest + FastAPI):

# tests/conftest.py
import pytest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, Session

from src.main import app
from src.database import Base, get_db
from src.models import User, Resource

# Test database
TEST_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(TEST_DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)


@pytest.fixture(scope="function")
def db() -> Session:
    """
    Database fixture with setup and teardown.

    Yields:
        Database session for testing

    Notes:
        - Creates all tables before test
        - Drops all tables after test
        - Each test gets fresh database
    """
    Base.metadata.create_all(bind=engine)
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()
        Base.metadata.drop_all(bind=engine)


@pytest.fixture
def client(db: Session) -> TestClient:
    """
    Test client with database dependency override.

    Args:
        db: Database session fixture

    Returns:
        FastAPI TestClient configured for testing
    """
    def override_get_db():
        try:
            yield db
        finally:
            pass

    app.dependency_overrides[get_db] = override_get_db
    client = TestClient(app)
    yield client
    app.dependency_overrides.clear()


@pytest.fixture
def test_user(db: Session) -> User:
    """
    Create test user in database.

    Args:
        db: Database session

    Returns:
        Created user instance
    """
    user = User(
        name="Test User",
        email="[email protected]",
        password_hash="hashed_password"
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture
def auth_token(client: TestClient, test_user: User) -> str:
    """
    Generate authentication token for test user.

    Args:
        client: Test client
        test_user: Test user fixture

    Returns:
        JWT authentication token
    """
    response = client.post(
        "/api/auth/login",
        json={"email": test_user.email, "password": "password"}
    )
    return response.json()["access_token"]


@pytest.fixture
def auth_headers(auth_token: str) -> dict:
    """
    Generate authorization headers with token.

    Args:
        auth_token: JWT token

    Returns:
        Headers dictionary with Authorization header
    """
    return {"Authorization": f"Bearer {auth_token}"}