generating-test-data

What this skill does

# Test Data Generator

## Overview

Generate realistic, type-safe test data including fixtures, factory functions, seed datasets, and edge case values. Supports Faker.js, Factory Bot patterns, Fishery (TypeScript factories), pytest fixtures, and database seed scripts.

## Prerequisites

- Data generation library installed (Faker.js/@faker-js/faker, Fishery, factory-boy for Python, or JavaFaker)
- Database schema or TypeScript/Python type definitions for the data models
- Test framework with fixture support (Jest, pytest, JUnit)
- Seed management for reproducible random data (`faker.seed()`)
- Database client for seed data insertion (if generating database fixtures)

## Instructions

1. Read the project's data models, TypeScript interfaces, database schemas, or ORM definitions to understand the shape of all entities.
2. For each entity, create a factory function that produces a valid default instance:
   - Use Faker methods matched to field semantics (e.g., `faker.person.fullName()` for names, `faker.internet.email()` for emails).
   - Provide sensible defaults for required fields.
   - Allow overrides via a partial parameter for test-specific customization.
   - Set a deterministic seed for reproducibility (`faker.seed(12345)`).
3. Generate edge case data variants for each entity:
   - **Empty values**: Empty strings, null, undefined, empty arrays.
   - **Boundary values**: Maximum string length, integer overflow, zero, negative numbers.
   - **Unicode and i18n**: Names with accents, CJK characters, RTL text, emoji.
   - **Adversarial inputs**: SQL injection strings, XSS payloads, excessively long strings.
   - **Temporal edge cases**: Leap years, timezone boundaries, epoch zero, far-future dates.
4. Create relationship factories that build connected entity graphs:
   - A user factory that also creates associated addresses and orders.
   - Configurable depth to avoid infinite recursion.
   - Lazy evaluation for optional relationships.
5. Generate database seed files for integration tests:
   - SQL insert scripts or ORM seed functions.
   - Idempotent operations (use `ON CONFLICT` or `INSERT IF NOT EXISTS`).
   - Separate seed sets for different test scenarios (empty state, populated state, edge cases).
6. Write fixture files in JSON, YAML, or TypeScript for static test data:
   - Group fixtures by test scenario.
   - Include both valid and invalid data sets.
7. Validate generated data against the schema to ensure factories remain in sync with model changes.

## Output

- Factory function files (one per entity) in `test/factories/` or `tests/factories/`
- Edge case data collections covering boundaries and adversarial inputs
- Database seed scripts for integration test environments
- JSON/YAML fixture files for static test data
- Factory index file exporting all factories for easy test imports

## Error Handling

| Error | Cause | Solution |
|-------|-------|---------|
| Factory produces invalid data | Schema changed but factory not updated | Add a validation step that runs the factory output through the schema validator |
| Duplicate unique values | Faker generates collisions in small datasets | Use sequential IDs or append a counter; increase Faker's unique retry limit |
| Database seed fails on foreign key | Seed insertion order violates referential integrity | Sort seed operations topologically by dependency; disable FK checks during seeding |
| Factory recursion overflow | Circular relationships (User -> Order -> User) | Limit relationship depth; use lazy references; break cycles with ID-only references |
| Non-deterministic test failures | Random seed not set consistently | Call `faker.seed()` in `beforeAll` or at factory module level; document seed values |

## Examples

**TypeScript factory with Fishery:**

```typescript
import { Factory } from 'fishery';
import { faker } from '@faker-js/faker';

interface User {
  id: string;
  name: string;
  email: string;
  role: 'admin' | 'user';
  createdAt: Date;
}

export const userFactory = Factory.define<User>(({ sequence }) => ({
  id: `user-${sequence}`,
  name: faker.person.fullName(),
  email: faker.internet.email(),
  role: 'user',
  createdAt: faker.date.past(),
}));

// Usage:
const user = userFactory.build();
const admin = userFactory.build({ role: 'admin' });
const users = userFactory.buildList(10);
```

**pytest fixture factory:**

```python
import pytest
from faker import Faker

fake = Faker()
Faker.seed(42)

@pytest.fixture
def make_user():
    def _make_user(**overrides):
        defaults = {
            "name": fake.name(),
            "email": fake.email(),
            "age": fake.random_int(min=18, max=99),
        }
        return {**defaults, **overrides}
    return _make_user

def test_user_validation(make_user):
    user = make_user(age=17)
    assert validate_age(user) is False
```

**Edge case data collection:**

```typescript
export const edgeCases = {
  strings: ['', ' ', '\t\n', 'a'.repeat(10000), '<script>alert(1)</script>',  # 10000: 10 seconds in ms
            "Robert'); DROP TABLE users;--", '\u0000null\u0000byte'],
  numbers: [0, -0, -1, Number.MAX_SAFE_INTEGER, NaN, Infinity, -Infinity],
  dates: [new Date(0), new Date('2024-02-29'), new Date('9999-12-31')],  # 2024: 9999 = configured value
};
```

## Resources

- Faker.js: https://fakerjs.dev/
- Fishery (TypeScript factories): https://github.com/thoughtbot/fishery
- factory_boy (Python): https://factoryboy.readthedocs.io/
- Chance.js: https://chancejs.com/
- Test data management patterns: https://martinfowler.com/bliki/ObjectMother.html