38Test Data Management (TDM)

38.1 Bad TDM looks like…

• Tests fail Monday because "the QA data got refreshed over the weekend"
• Engineer A's test depends on User #42 that Engineer B deleted
• A flaky test only flakes after lunch because two engineers happened to run it concurrently
• Half the suite breaks because someone changed the seed
• Personal data of real customers ends up in the test environment

38.2 The four classical TDM strategies

38.3 Per-test factories (code-driven TDM)

// src/factories/userFactory.ts
import { faker } from '@faker-js/faker';
import type { APIRequestContext } from '@playwright/test';

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

export function userPayload(over: Partial<User> = {}) {
  return {
    email: faker.internet.email({ provider: 'qa.acme.test' }),  // never @gmail.com
    name: faker.person.fullName(),
    role: 'user' as const,
    ...over,
  };
}

export async function createUser(api: APIRequestContext, over: Partial<User> = {}): Promise<User> {
  const res = await api.post('/test/users', { data: userPayload(over) });
  if (!res.ok()) throw new Error(`createUser failed: ${res.status()}`);
  return res.json();
}

export async function deleteUser(api: APIRequestContext, id: string) {
  await api.delete(`/test/users/${id}`);
}

Use in a fixture:

export const test = base.extend<{ user: User }>({
  user: async ({ request }, use) => {
    const u = await createUser(request);
    await use(u);
    await deleteUser(request, u.id);
  },
});

38.4 Builder pattern for complex objects

class OrderBuilder {
  private order: Partial<Order> = { items: [], status: 'pending' };
  withUser(u: User)          { this.order.userId = u.id; return this; }
  withItem(sku: string, qty=1){ this.order.items!.push({ sku, qty }); return this; }
  withCoupon(code: string)   { this.order.coupon = code; return this; }
  withStatus(s: OrderStatus) { this.order.status = s; return this; }
  async build(api: APIRequestContext): Promise<Order> {
    return (await api.post('/test/orders', { data: this.order })).json();
  }
}

const order = await new OrderBuilder()
  .withUser(user).withItem('SHOE-42', 2).withCoupon('TEST50').build(request);

38.5 Per-tenant isolation

Each parallel test slot gets its own tenant (a top-level data namespace). Tests within a slot share the tenant safely; tests across slots can't collide.

// fixtures.ts
export const test = base.extend<{}, { tenant: string }>({
  tenant: [async ({}, use, info) => {
    const t = `qa-slot-${info.parallelIndex}`;
    await use(t);
  }, { scope: 'worker' }],
});

The factory / API call includes tenant in headers; the backend scopes data accordingly.

38.6 PII masking — non-negotiable for prod-derived data

Tools: Tonic.ai, Delphix, GDPR-mask, custom Python pipeline. Whatever you pick: keep the mapping deterministic within a refresh (the same prod email always maps to the same test email) — otherwise referential integrity breaks.

38.7 Cleanup & leases

• Per-test factories should clean up via teardown (covered above).
• For long-lived seeds (one user per slot), use leases: "this slot owns user X for the next 1 hour". Expire on TTL so crashed runs don't lock data forever.
• Nightly job: delete all qa-slot-* records older than 7 days — catches leaks.

38.8 Time-sensitive data

• Frozen clocks — backend exposes a test-only endpoint to set "now". Tests asserting on relative times (e.g. "expires in 2 days") need this.
• Schedule fast-forward — endpoint to advance time (cron triggers, expiry).
• Playwright clock API — page.clock.install() + page.clock.setSystemTime freeze the browser clock for client-side date logic.

38.9 Common SDET TDM mistakes

• Hardcoded ids that "always work" — until they don't (env reset, parallel run)
• Reusing the same email and getting 409 in parallel tests
• Manual cleanup in afterAll that doesn't run when the test crashes — use try/finally or fixture teardown
• Relying on database snapshots that drift from real schema
• Treating test users as "real" data — they should be ephemeral, tagged, and trivially deletable