The state your tests live on

// fixtures/users.json
[
  { "id": "u-1", "email": "alice@test.dev", "role": "admin" },
  { "id": "u-2", "email": "bob@test.dev",   "role": "member" }
]

// In Playwright fixture
import users from './fixtures/users.json';

test.beforeEach(async ({ request }) => {
  await request.post('/api/test/seed', { data: { users } });
});

test('admin can delete users', async ({ page }) => {
  await loginAs(page, 'alice@test.dev'); // from fixture
  // ...
});

// factories/order.ts
import { faker } from '@faker-js/faker';

export function orderFactory(overrides: Partial<Order> = {}): Order {
  return {
    id: faker.string.uuid(),
    userId: faker.string.uuid(),
    items: [{ sku: 'DEFAULT-SKU', qty: 1, price: 10.0 }],
    total: 10.0,
    currency: 'USD',
    status: 'pending',
    createdAt: new Date().toISOString(),
    ...overrides,
  };
}

// In tests — you only spell out what matters
const bigOrder = orderFactory({ total: 9999 });
const returned = orderFactory({ status: 'returned' });

// builders/order-builder.ts
export class OrderBuilder {
  private order: Partial<Order> = { status: 'pending', items: [] };

  forUser(user: User) {
    this.order.userId = user.id;
    return this;
  }

  withItem(sku: string, qty: number, price: number) {
    this.order.items!.push({ sku, qty, price });
    return this;
  }

  shipped() {
    this.order.status = 'shipped';
    return this;
  }

  build(): Order {
    return orderFactory(this.order);  // delegate defaults to factory
  }
}

// In tests — reads like a spec
const order = new OrderBuilder()
  .forUser(alice)
  .withItem('KEYBOARD', 1, 80)
  .withItem('MOUSE',   1, 30)
  .shipped()
  .build();

// Jest / Vitest snapshot
test('invoice PDF renders correctly', () => {
  const html = renderInvoice(sampleOrder);
  expect(html).toMatchSnapshot();
});

// Playwright visual snapshot
test('checkout page matches baseline', async ({ page }) => {
  await page.goto('/checkout');
  await expect(page).toHaveScreenshot('checkout-filled.png', {
    maxDiffPixelRatio: 0.02,
  });
});

// Inline snapshot — diff lives next to the test
expect(result).toMatchInlineSnapshot(`
  Object {
    "total": 100,
    "currency": "USD",
  }
`);

// Per-test reset via fixture
import { test as base } from '@playwright/test';

export const test = base.extend<{ db: DatabaseFixture }>({
  db: async ({}, use) => {
    await resetDatabase();
    await seed({ users: [alice, bob], products: productCatalog });

    await use({ /* helpers */ });

    // Cleanup — even if the test failed
    await resetDatabase();
  },
});

// Per-file: much faster, but order-sensitive tests leak state
test.beforeAll(async () => {
  await resetDatabase();
  await seed(...);
});

// Transactional rollback — fastest, only works for DB-only tests
test.beforeEach(async () => {
  await beginTransaction();
});
test.afterEach(async () => {
  await rollbackTransaction();  // nothing was committed
});