Create reusable data generators:

function createUser(overrides = {}) {
  return {
    id: Math.floor(Math.random() * 1000),
    name: 'Test User',
    email: 'test@example.com',
    role: 'user',
    createdAt: new Date().toISOString(),
    ...overrides
  }
}

// Usage
const admin = createUser({ role: 'admin', name: 'Admin User' })
const regularUser = createUser()

def create_user(**kwargs):
    defaults = {
        'id': random.randint(1, 1000),
        'name': 'Test User',
        'email': 'test@example.com',
        'role': 'user',
        'created_at': datetime.now()
    }
    return {**defaults, **kwargs}

# Usage
admin = create_user(role='admin', name='Admin User')

Builder Pattern

For complex objects:

class UserBuilder {
  constructor() {
    this.user = {
      id: 1,
      name: 'Test User',
      email: 'test@example.com',
      role: 'user',
      preferences: {}
    }
  }
  
  withId(id) {
    this.user.id = id
    return this
  }
  
  withName(name) {
    this.user.name = name
    return this
  }
  
  withRole(role) {
    this.user.role = role
    return this
  }
  
  withPreferences(preferences) {
    this.user.preferences = preferences
    return this
  }
  
  build() {
    return this.user
  }
}

// Usage
const user = new UserBuilder()
  .withId(123)
  .withName('John Doe')
  .withRole('admin')
  .withPreferences({ theme: 'dark' })
  .build()

Test Fixtures

JavaScript/TypeScript:

// fixtures/users.js
export const users = {
  admin: {
    id: 1,
    name: 'Admin User',
    email: 'admin@example.com',
    role: 'admin'
  },
  regular: {
    id: 2,
    name: 'Regular User',
    email: 'user@example.com',
    role: 'user'
  }
}

// In tests
import { users } from './fixtures/users'

test('admin can delete posts', () => {
  expect(canDelete(users.admin)).toBe(true)
})

Python (pytest):

# conftest.py
import pytest

@pytest.fixture
def sample_user():
    return {
        'id': 1,
        'name': 'Test User',
        'email': 'test@example.com',
        'role': 'user'
    }

@pytest.fixture
def admin_user():
    return {
        'id': 2,
        'name': 'Admin User',
        'email': 'admin@example.com',
        'role': 'admin'
    }

# In tests
def test_user_permissions(sample_user, admin_user):
    assert can_delete(admin_user)
    assert not can_delete(sample_user)

Mock Data

API Responses:

const mockApiResponse = {
  data: {
    users: [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' }
    ]
  },
  status: 200,
  statusText: 'OK'
}

// Mock fetch
global.fetch = jest.fn(() =>
  Promise.resolve({
    json: () => Promise.resolve(mockApiResponse.data)
  })
)

Database Records:

mock_db_records = [
    {'id': 1, 'name': 'Product A', 'price': 10.99},
    {'id': 2, 'name': 'Product B', 'price': 20.99},
    {'id': 3, 'name': 'Product C', 'price': 15.99}
]

@patch('app.database.query')
def test_get_products(mock_query):
    mock_query.return_value = mock_db_records
    products = get_products()
    assert len(products) == 3

Random Data Generation

Using faker (JavaScript):

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

function generateUser() {
  return {
    id: faker.string.uuid(),
    name: faker.person.fullName(),
    email: faker.internet.email(),
    avatar: faker.image.avatar(),
    address: {
      street: faker.location.streetAddress(),
      city: faker.location.city(),
      country: faker.location.country()
    }
  }
}

// Generate multiple users
const users = Array.from({ length: 10 }, generateUser)

Using Faker (Python):

from faker import Faker

fake = Faker()

def generate_user():
    return {
        'id': fake.uuid4(),
        'name': fake.name(),
        'email': fake.email(),
        'phone': fake.phone_number(),
        'address': {
            'street': fake.street_address(),
            'city': fake.city(),
            'country': fake.country()
        }
    }

# Generate multiple users
users = [generate_user() for _ in range(10)]

Seeded Random Data

For reproducible tests:

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

test('generates consistent data with seed', () => {
  faker.seed(123)
  const user1 = generateUser()
  
  faker.seed(123)
  const user2 = generateUser()
  
  expect(user1).toEqual(user2)
})

from faker import Faker

def test_consistent_data():
    fake = Faker()
    Faker.seed(123)
    user1 = generate_user(fake)
    
    Faker.seed(123)
    user2 = generate_user(fake)
    
    assert user1 == user2

Mock Functions

Jest:

const mockCallback = jest.fn(x => x * 2)

test('calls callback for each item', () => {
  const items = [1, 2, 3]
  items.forEach(mockCallback)
  
  expect(mockCallback).toHaveBeenCalledTimes(3)
  expect(mockCallback).toHaveBeenCalledWith(1)
  expect(mockCallback).toHaveBeenCalledWith(2)
  expect(mockCallback).toHaveBeenCalledWith(3)
})

Python (unittest.mock):

from unittest.mock import Mock

def test_callback():
    mock_callback = Mock(return_value=42)
    
    result = process_data([1, 2, 3], mock_callback)
    
    assert mock_callback.call_count == 3
    mock_callback.assert_called_with(3)

Time-based Data

Freeze time:

import { jest } from '@jest/globals'

test('creates timestamp', () => {
  const mockDate = new Date('2024-01-01T00:00:00Z')
  jest.useFakeTimers()
  jest.setSystemTime(mockDate)
  
  const record = createRecord()
  expect(record.createdAt).toBe('2024-01-01T00:00:00.000Z')
  
  jest.useRealTimers()
})

from freezegun import freeze_time

@freeze_time("2024-01-01 00:00:00")
def test_timestamp():
    record = create_record()
    assert record['created_at'] == datetime(2024, 1, 1, 0, 0, 0)

Common Patterns

Pattern: Array of test cases:

const testCases = [
  { input: 'hello', expected: 'HELLO' },
  { input: 'world', expected: 'WORLD' },
  { input: '', expected: '' }
]

testCases.forEach(({ input, expected }) => {
  test(`converts "${input}" to "${expected}"`, () => {
    expect(toUpperCase(input)).toBe(expected)
  })
})

Pattern: Shared setup:

describe('UserService', () => {
  let service
  let mockDb
  
  beforeEach(() => {
    mockDb = {
      query: jest.fn(),
      insert: jest.fn()
    }
    service = new UserService(mockDb)
  })
  
  test('fetches users', async () => {
    mockDb.query.mockResolvedValue([{ id: 1 }])
    const users = await service.getUsers()
    expect(users).toHaveLength(1)
  })
})

Pattern: Test data files:

// testData/users.json
[
  {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com"
  },
  {
    "id": 2,
    "name": "Bob",
    "email": "bob@example.com"
  }
]

// In tests
import users from './testData/users.json'

test('processes user data', () => {
  const result = processUsers(users)
  expect(result).toHaveLength(2)
})

Advanced

For complex scenarios:

Use factory libraries (factory-bot, fishery, rosie)
Generate GraphQL mock data
Create database seeders
Build test data pipelines

test-data-generator

Test Data Generator

Quick Start

Instructions

Factory Functions