Test Data Management

Test Data Management

Create and manage test data effectively.

Factory Pattern (Python)

from factory import Factory, Faker, SubFactory, LazyAttribute
from app.models import User, Analysis

class UserFactory(Factory):
    class Meta:
        model = User

    email = Faker('email')
    name = Faker('name')
    created_at = Faker('date_time_this_year')

class AnalysisFactory(Factory):
    class Meta:
        model = Analysis

    url = Faker('url')
    status = 'pending'
    user = SubFactory(UserFactory)

    @LazyAttribute
    def title(self):
        return f"Analysis of {self.url}"

# Usage
user = UserFactory()
analysis = AnalysisFactory(user=user, status='completed')

Factory Pattern (TypeScript)

import { faker } from '@faker-js/faker';

interface User {
  id: string;
  email: string;
  name: string;
}

const createUser = (overrides: Partial<User> = {}): User => ({
  id: faker.string.uuid(),
  email: faker.internet.email(),
  name: faker.person.fullName(),
  ...overrides,
});

const createAnalysis = (overrides = {}) => ({
  id: faker.string.uuid(),
  url: faker.internet.url(),
  status: 'pending',
  userId: createUser().id,
  ...overrides,
});

// Usage
const user = createUser({ name: 'Test User' });
const analysis = createAnalysis({ userId: user.id, status: 'completed' });

JSON Fixtures

// fixtures/users.json
{
  "admin": {
    "id": "user-001",
    "email": "admin@example.com",
    "role": "admin"
  },
  "basic": {
    "id": "user-002",
    "email": "user@example.com",
    "role": "user"
  }
}

import json
import pytest

@pytest.fixture
def users():
    with open('fixtures/users.json') as f:
        return json.load(f)

def test_admin_access(users):
    admin = users['admin']
    assert admin['role'] == 'admin'

Database Seeding

# seeds/test_data.py
async def seed_test_database(db: AsyncSession):
    """Seed database with test data."""
    # Create users
    users = [
        UserFactory.build(email=f"user{i}@test.com")
        for i in range(10)
    ]
    db.add_all(users)

    # Create analyses for each user
    for user in users:
        analyses = [
            AnalysisFactory.build(user_id=user.id)
            for _ in range(5)
        ]
        db.add_all(analyses)

    await db.commit()

@pytest.fixture
async def seeded_db(db_session):
    await seed_test_database(db_session)
    yield db_session

Fixture Composition

@pytest.fixture
def user():
    return UserFactory()

@pytest.fixture
def user_with_analyses(user):
    analyses = [AnalysisFactory(user=user) for _ in range(3)]
    return {"user": user, "analyses": analyses}

@pytest.fixture
def completed_workflow(user_with_analyses):
    for analysis in user_with_analyses["analyses"]:
        analysis.status = "completed"
    return user_with_analyses

Test Data Isolation

@pytest.fixture(autouse=True)
async def clean_database(db_session):
    """Reset database between tests."""
    yield

    # Clean up after test
    await db_session.execute("TRUNCATE users, analyses CASCADE")
    await db_session.commit()

Key Decisions

Common Mistakes

• Shared state between tests
• Hard-coded IDs (conflicts)
• No cleanup after tests
• Over-complex fixtures

Related Skills

• unit-testing - Test patterns
• integration-testing - Database tests
• database-schema-designer - Schema design

Capability Details

fixture-generation

Keywords: fixture, test fixture, pytest fixture, conftest Solves:

• Create reusable test fixtures
• Implement fixture composition
• Handle fixture cleanup

factory-patterns

Keywords: factory, FactoryBoy, test factory, model factory Solves:

• Generate test data with factories
• Implement factory inheritance
• Create related object graphs

data-seeding

Keywords: seed, seed data, database seed, initial data Solves:

• Seed databases for testing
• Create consistent test environments
• Implement idempotent seeding

cleanup-strategies

Keywords: cleanup, teardown, reset, isolation Solves:

• Clean up test data after runs
• Implement transaction rollback
• Ensure test isolation

data-anonymization

Keywords: anonymize, faker, synthetic data, mock data Solves:

• Generate realistic fake data
• Anonymize production data for tests
• Create synthetic datasets

Test Data Management Checklist

Fixtures

• [ ] Use factories over hardcoded data
• [ ] Minimal required fields
• [ ] Randomize non-essential data
• [ ] Version control fixtures

Data Generation

• [ ] Faker for realistic data
• [ ] Consistent seeds for reproducibility
• [ ] Edge case generators
• [ ] Bulk generation for perf tests

Database

• [ ] Transaction rollback for isolation
• [ ] Per-test database when needed
• [ ] Proper cleanup order
• [ ] Handle foreign keys

Cleanup

• [ ] Clean up after each test
• [ ] Handle test failures
• [ ] Verify clean state
• [ ] Prevent data leaks

Best Practices

• [ ] No test interdependencies
• [ ] Factories over fixtures
• [ ] Meaningful test data
• [ ] Document data requirements

Factory Patterns for Test Data

Generate consistent, realistic test data with factory patterns.

Implementation

import factory
from factory import Faker, SubFactory, LazyAttribute, Sequence
from datetime import datetime, timedelta
from app.models import User, Organization, Project

class OrganizationFactory(factory.Factory):
    """Factory for Organization entities."""
    class Meta:
        model = Organization

    id = Sequence(lambda n: f"org-{n:04d}")
    name = Faker("company")
    slug = LazyAttribute(lambda o: o.name.lower().replace(" ", "-"))
    created_at = Faker("date_time_this_year")


class UserFactory(factory.Factory):
    """Factory for User entities with organization relationship."""
    class Meta:
        model = User

    id = Sequence(lambda n: f"user-{n:04d}")
    email = Faker("email")
    name = Faker("name")
    organization = SubFactory(OrganizationFactory)
    is_active = True
    created_at = Faker("date_time_this_month")

    @LazyAttribute
    def username(self):
        return self.email.split("@")[0]


class ProjectFactory(factory.Factory):
    """Factory with traits for different project states."""
    class Meta:
        model = Project

    id = Sequence(lambda n: f"proj-{n:04d}")
    name = Faker("catch_phrase")
    owner = SubFactory(UserFactory)
    status = "active"

    class Params:
        archived = factory.Trait(
            status="archived",
            archived_at=Faker("date_time_this_month")
        )
        completed = factory.Trait(
            status="completed",
            completed_at=Faker("date_time_this_week")
        )

Usage Patterns

# Basic creation
user = UserFactory()

# Override specific fields
admin = UserFactory(email="admin@company.com", is_active=True)

# Use traits
archived_project = ProjectFactory(archived=True)

# Batch creation
users = UserFactory.create_batch(10)

# Build without persistence (in-memory only)
temp_user = UserFactory.build()

Checklist

• [ ] Use Sequence for unique identifiers
• [ ] Use SubFactory for related entities
• [ ] Use LazyAttribute for computed fields
• [ ] Use Traits for common variations (archived, deleted, premium)
• [ ] Keep factories close to model definitions
• [ ] Document factory-specific test data assumptions