Advanced

test("characterize calculation logic", () => {
  // => FAILS: Don't know what legacyCalculate returns
  const result = legacyCalculate(100, 10, "SPECIAL");
  expect(result).toBe(???); // Unknown expected value
});

function legacyCalculate(amount: number, rate: number, type: string): number {
  // => Complex legacy logic
  let result = amount * rate; // => Multiply amount by rate
  if (type === "SPECIAL") {
    // => Branch for SPECIAL type
    result = result * 1.5 + 25; // => Apply mysterious formula
  } // => result after SPECIAL formula
  return result; // => Return calculated value
}

describe("legacyCalculate characterization", () => {
  test("characterizes normal calculation", () => {
    const result = legacyCalculate(100, 10, "NORMAL");
    expect(result).toBe(1000); // => Captured actual behavior
  }); // => Documents what system does now

  test("characterizes SPECIAL type calculation", () => {
    const result = legacyCalculate(100, 10, "SPECIAL");
    expect(result).toBe(1525); // => Captured: (100*10)*1.5 + 25 = 1525
  }); // => Mysterious formula now documented

  test("characterizes edge case", () => {
    const result = legacyCalculate(0, 5, "SPECIAL");
    expect(result).toBe(25); // => Captured: (0*5)*1.5 + 25 = 25
  }); // => Documents zero case behavior
});

test("generates user report", () => {
  // => FAILS: Complex report structure
  const report = generateReport(users);
  // How to assert on 50+ line report?
});

import { verify } from "approvals";

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

function generateReport(users: User[]): string {
  // => Generates multi-line report
  let report = "USER REPORT\n"; // => Header
  report += "===========\n";

  users.forEach((user) => {
    // => For each user
    report += `ID: ${user.id}\n`; // => Add ID line
    report += `Name: ${user.name}\n`; // => Add name line
    report += `Email: ${user.email}\n`; // => Add email line
    report += `Role: ${user.role}\n`; // => Add role line
    report += "---\n"; // => Separator
  });

  return report; // => Return formatted report
}

test("approval test for user report", () => {
  const users = [
    // => Test data
    { id: 1, name: "Alice", email: "alice@example.com", role: "Admin" },
    { id: 2, name: "Bob", email: "bob@example.com", role: "User" },
  ];

  const report = generateReport(users); // => Generate report

  verify(report); // => Compare against approved baseline
}); // => On first run, saves baseline; future runs compare

describe("Report approval tests", () => {
  test("approves empty report", () => {
    const report = generateReport([]); // => Empty user list
    verify(report); // => Baseline: header only
  });

  test("approves single user report", () => {
    const users = [{ id: 1, name: "Alice", email: "alice@example.com", role: "Admin" }];
    const report = generateReport(users);
    verify(report); // => Baseline: one user section
  });

  test("approves multi-user report", () => {
    const users = [
      { id: 1, name: "Alice", email: "alice@example.com", role: "Admin" },
      { id: 2, name: "Bob", email: "bob@example.com", role: "User" },
      { id: 3, name: "Charlie", email: "charlie@example.com", role: "Guest" },
    ];
    const report = generateReport(users);
    verify(report); // => Baseline: three user sections
  });
});

class OrderProcessor {
  processOrder(orderId: number): boolean {
    const db = new Database(); // => FAIL: Hard-coded dependency
    const order = db.getOrder(orderId); // => Cannot test without real DB

    const payment = new PaymentGateway(); // => FAIL: Hard-coded payment
    return payment.charge(order.total); // => Cannot test without real gateway
  }
}

interface Database {
  getOrder(id: number): { id: number; total: number };
}

interface PaymentGateway {
  charge(amount: number): boolean;
}

class OrderProcessor {
  constructor(
    // => Seam 1: Constructor injection
    private db: Database,
    private payment: PaymentGateway,
  ) {}

  processOrder(orderId: number): boolean {
    const order = this.db.getOrder(orderId); // => Uses injected DB
    return this.payment.charge(order.total); // => Uses injected gateway
  }
}

test("processOrder with test doubles", () => {
  const fakeDb = {
    // => Fake database seam
    getOrder: (id: number) => ({ id, total: 100 }),
  };

  const fakePayment = {
    // => Fake payment seam
    charge: (amount: number) => amount < 1000,
  };

  const processor = new OrderProcessor(fakeDb, fakePayment); // => Inject seams

  const result = processor.processOrder(1);

  expect(result).toBe(true); // => Verify behavior
}); // => Tested without real dependencies

class UserService {
  createUser(name: string, email: string): void {
    // => Multiple hard dependencies
    const db = new Database(); // => Hard dependency 1
    const emailer = new EmailService(); // => Hard dependency 2
    const logger = new Logger(); // => Hard dependency 3

    db.saveUser({ name, email }); // => Cannot test
    emailer.sendWelcome(email); // => Cannot test
    logger.log(`User created: ${name}`); // => Cannot test
  }
}

interface Database {
  saveUser(user: { name: string; email: string }): void;
}

interface EmailService {
  sendWelcome(email: string): void;
}

interface Logger {
  log(message: string): void;
}

class UserService {
  constructor(
    // => Parameterize constructor
    private db: Database,
    private emailer: EmailService,
    private logger: Logger,
  ) {}

  createUser(name: string, email: string): void {
    this.db.saveUser({ name, email }); // => Uses injected DB
    this.emailer.sendWelcome(email); // => Uses injected emailer
    this.logger.log(`User created: ${name}`); // => Uses injected logger
  }
}

test("createUser calls all services", () => {
  const mockDb = {
    saveUser: jest.fn(),
  }; // => Mock database
  const mockEmailer = {
    sendWelcome: jest.fn(),
  }; // => Mock emailer
  const mockLogger = {
    log: jest.fn(),
  }; // => Mock logger

  const service = new UserService(mockDb, mockEmailer, mockLogger); // => Inject mocks
  service.createUser("Alice", "alice@example.com");

  expect(mockDb.saveUser).toHaveBeenCalledWith({ name: "Alice", email: "alice@example.com" });
  expect(mockEmailer.sendWelcome).toHaveBeenCalledWith("alice@example.com");
  expect(mockLogger.log).toHaveBeenCalledWith("User created: Alice");
}); // => All interactions verified

test("UserService gets user orders", async () => {
  const userService = new UserService(); // => FAILS: Needs OrderService running
  const orders = await userService.getUserOrders(1);
  expect(orders).toHaveLength(2);
});

interface HttpClient {
  get(url: string): Promise<any>;
}

class UserService {
  constructor(
    private http: HttpClient,
    private orderServiceUrl: string,
  ) {}

  async getUserOrders(userId: number): Promise<any[]> {
    const response = await this.http.get(`${this.orderServiceUrl}/users/${userId}/orders`);
    // => Calls order service
    return response.data; // => Returns order data
  }
}

test("UserService gets user orders via HTTP", async () => {
  const mockHttp = {
    // => Mock HTTP client
    get: jest.fn().mockResolvedValue({
      // => Mock response
      data: [
        { id: 1, total: 100 },
        { id: 2, total: 200 },
      ],
    }),
  };

  const userService = new UserService(mockHttp, "http://order-service"); // => Inject mock
  const orders = await userService.getUserOrders(1);

  expect(orders).toHaveLength(2); // => Verify result
  expect(mockHttp.get).toHaveBeenCalledWith("http://order-service/users/1/orders");
}); // => Tested without real OrderService

test("UserService integrates with OrderService", async () => {
  // => FAILS: Requires both services running
  const orderService = new OrderService(); // Real service
  const userService = new UserService(orderService);
  const orders = await userService.getUserOrders(1);
  expect(orders[0].id).toBe(1);
});

// Contract definition
interface OrderServiceContract {
  "GET /users/:userId/orders": {
    response: {
      data: Array<{ id: number; total: number; status: string }>;
    };
  };
}

// Consumer test (UserService side)
test("UserService expects OrderService contract", async () => {
  const mockHttp = {
    get: jest.fn().mockResolvedValue({
      // => Contract shape
      data: [
        { id: 1, total: 100, status: "pending" }, // => Matches contract
        { id: 2, total: 200, status: "shipped" },
      ],
    }),
  };

  const userService = new UserService(mockHttp, "http://order-service");
  const orders = await userService.getUserOrders(1);

  expect(orders).toEqual([
    // => Verify contract structure
    { id: 1, total: 100, status: "pending" },
    { id: 2, total: 200, status: "shipped" },
  ]);
}); // => Consumer validates expected contract

// Provider test (OrderService side)
test("OrderService fulfills contract", async () => {
  const orderService = new OrderService();
  const response = await orderService.getOrdersByUserId(1);

  // Verify response matches contract
  expect(response.data).toEqual(
    expect.arrayContaining([
      expect.objectContaining({
        // => Contract fields required
        id: expect.any(Number),
        total: expect.any(Number),
        status: expect.any(String),
      }),
    ]),
  );
}); // => Provider guarantees contract compliance

test("replication happens immediately", async () => {
  await primaryDb.write({ id: 1, name: "Alice" }); // => Write to primary
  const data = await replicaDb.read(1); // => FAILS: Replica not updated yet
  expect(data.name).toBe("Alice"); // Race condition
});

async function waitForReplication<T>(
  fetchFn: () => Promise<T>,
  predicate: (value: T) => boolean,
  timeout = 5000,
): Promise<T> {
  // => Poll until condition met
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    // => Keep trying until timeout
    const value = await fetchFn(); // => Fetch current value
    if (predicate(value)) {
      return value;
    } // => Return when predicate true
    await new Promise((resolve) => setTimeout(resolve, 100)); // => Wait 100ms
  }

  throw new Error("Timeout waiting for replication"); // => Failed to meet condition
}

test("replication happens eventually", async () => {
  await primaryDb.write({ id: 1, name: "Alice" }); // => Write to primary

  const data = await waitForReplication(
    () => replicaDb.read(1), // => Fetch function
    (value) => value !== null && value.name === "Alice", // => Predicate
    5000, // => 5 second timeout
  ); // => Polls until replicated

  expect(data.name).toBe("Alice"); // => Verify after eventual consistency
}); // => Test accounts for async propagation

test("applies events to rebuild state", () => {
  const account = new Account(); // => FAILS: Needs event store
  account.applyEvent({ type: "Deposited", amount: 100 });
  expect(account.getBalance()).toBe(100);
});

type Event = { type: "Deposited"; amount: number } | { type: "Withdrawn"; amount: number };

class Account {
  private balance = 0;

  applyEvent(event: Event): void {
    // => Apply event to state
    if (event.type === "Deposited") {
      this.balance += event.amount; // => Increase balance
    } else if (event.type === "Withdrawn") {
      this.balance -= event.amount; // => Decrease balance
    }
  }

  getBalance(): number {
    return this.balance;
  }
}

test("applies deposit events", () => {
  const account = new Account();
  account.applyEvent({ type: "Deposited", amount: 100 }); // => Apply deposit
  expect(account.getBalance()).toBe(100); // => Balance increased
});

test("applies multiple events in order", () => {
  const account = new Account();
  account.applyEvent({ type: "Deposited", amount: 100 }); // => Deposit 100
  account.applyEvent({ type: "Withdrawn", amount: 30 }); // => Withdraw 30
  account.applyEvent({ type: "Deposited", amount: 50 }); // => Deposit 50

  expect(account.getBalance()).toBe(120); // => 100 - 30 + 50 = 120
}); // => Events applied in sequence

class EventStore {
  private events: Map<string, Event[]> = new Map(); // => In-memory event storage

  append(streamId: string, event: Event): void {
    if (!this.events.has(streamId)) {
      this.events.set(streamId, []); // => Initialize stream
    }
    this.events.get(streamId)!.push(event); // => Append event
  }

  getEvents(streamId: string): Event[] {
    return this.events.get(streamId) || []; // => Retrieve event stream
  }
}

function replayEvents(events: Event[]): Account {
  // => Rebuild state from events
  const account = new Account();
  events.forEach((event) => account.applyEvent(event)); // => Apply each event
  return account; // => Return reconstructed state
}

test("rebuilds state from event store", () => {
  const store = new EventStore();
  const accountId = "account-1";

  store.append(accountId, { type: "Deposited", amount: 100 });
  store.append(accountId, { type: "Withdrawn", amount: 30 });
  store.append(accountId, { type: "Deposited", amount: 50 });

  const events = store.getEvents(accountId); // => Retrieve all events
  const account = replayEvents(events); // => Rebuild from events

  expect(account.getBalance()).toBe(120); // => State reconstructed correctly
});

test("updates and queries user", () => {
  const service = new UserService(); // => FAILS: Needs read/write separation
  service.updateUser(1, { name: "Alice" });
  const user = service.getUser(1);
  expect(user.name).toBe("Alice");
});

// Write model (Commands)
interface UpdateUserCommand {
  userId: number;
  data: { name: string };
}

class UserCommandHandler {
  private writeDb: Map<number, any> = new Map(); // => Write model storage

  handle(command: UpdateUserCommand): void {
    this.writeDb.set(command.userId, command.data); // => Store update
    // In production: publish event to sync read model
  }
}

// Read model (Queries)
interface UserQuery {
  userId: number;
}

class UserQueryHandler {
  private readDb: Map<number, any> = new Map(); // => Read model storage

  query(query: UserQuery): any {
    return this.readDb.get(query.userId); // => Retrieve from read model
  }

  syncFromEvent(userId: number, data: any): void {
    // => Sync from event
    this.readDb.set(userId, data); // => Update read model
  }
}

describe("CQRS pattern", () => {
  test("command handler processes updates", () => {
    const commandHandler = new UserCommandHandler();
    commandHandler.handle({ userId: 1, data: { name: "Alice" } }); // => Execute command
    // Command side doesn't return data, only processes
  });

  test("query handler retrieves data", () => {
    const queryHandler = new UserQueryHandler();
    queryHandler.syncFromEvent(1, { name: "Alice" }); // => Simulate event sync

    const user = queryHandler.query({ userId: 1 }); // => Execute query
    expect(user.name).toBe("Alice"); // => Verify read model
  });
});

@Test
void calculateDiscount_appliesCorrectRate() {
    // => Given
    PriceCalculator calculator = new PriceCalculator();
    // => Calculator instance created

    // => When
    BigDecimal result = calculator.calculateDiscount(
        new BigDecimal("100"),
        new BigDecimal("0.1")
    );
    // => Calls calculateDiscount with 100 and 10% rate

    // => Then
    assertEquals(
        new BigDecimal("90.00"),
        result.setScale(2, RoundingMode.HALF_UP)
    );
    // => Verifies result is 90.00 (100 - 10%)
}

test("calculateDiscount applies correct rate", () => {
  // => Arrange
  const calculator = new PriceCalculator();
  // => Calculator instance created

  // => Act
  const result = calculator.calculateDiscount(100, 0.1);
  // => Calls calculateDiscount with 100 and 10% rate

  // => Assert
  expect(result).toBe(90); // => Verifies result is 90 (100 - 10%)
});

1. **Arrange-Act-Assert pattern** - Both use AAA structure
2. **Descriptive test names** - `calculateDiscount_appliesCorrectRate` vs `calculateDiscount applies correct rate`
3. **Single assertion focus** - Each test verifies one behavior
4. **Fast execution** - Both run in milliseconds
5. **Red-Green-Refactor** - Same TDD cycle

| Aspect          | Java                      | TypeScript                  |
| --------------- | ------------------------- | --------------------------- |
| **Test Runner** | JUnit 5                   | Jest                        |
| **Mocking**     | Mockito                   | jest.fn()                   |
| **Assertions**  | assertEquals, assertTrue  | expect().toBe(), .toEqual() |
| **Async**       | CompletableFuture         | async/await                 |
| **Type Safety** | Compile-time (static)     | Compile-time (TypeScript)   |
| **Naming**      | camelCase_withUnderscores | camelCase with spaces       |
| **Lifecycle**   | @BeforeEach, @AfterEach   | beforeEach(), afterEach()   |

test("sorts array correctly", () => {
  const input = [3, 1, 4, 1, 5, 9, 2, 6];
  const result = sort(input); // => FAILS: Function not defined
  expect(result).toEqual([1, 1, 2, 3, 4, 5, 6, 9]);
});

function sort(arr: number[]): number[] {
  // => Bubble sort (O(n²))
  const result = [...arr]; // => Copy array
  for (let i = 0; i < result.length; i++) {
    // => Outer loop
    for (let j = 0; j < result.length - 1; j++) {
      // => Inner loop
      if (result[j] > result[j + 1]) {
        // => Compare adjacent
        [result[j], result[j + 1]] = [result[j + 1], result[j]]; // => Swap
      }
    }
  }
  return result; // => Sorted array
}

test("sorts array correctly", () => {
  const input = [3, 1, 4, 1, 5, 9, 2, 6];
  const result = sort(input);
  expect(result).toEqual([1, 1, 2, 3, 4, 5, 6, 9]); // => Passes
});

function sort(arr: number[]): number[] {
  // => Native sort (O(n log n))
  return [...arr].sort((a, b) => a - b); // => Optimized algorithm
}

describe("sort", () => {
  test("sorts array correctly", () => {
    const input = [3, 1, 4, 1, 5, 9, 2, 6];
    const result = sort(input);
    expect(result).toEqual([1, 1, 2, 3, 4, 5, 6, 9]); // => Functional correctness
  });

  test("sorts large array within performance constraint", () => {
    const input = Array.from({ length: 10000 }, () => Math.random()); // => 10k items
    const startTime = Date.now();

    const result = sort(input); // => Sort large array

    const duration = Date.now() - startTime; // => Measure time
    expect(duration).toBeLessThan(100); // => Must complete in <100ms
    expect(result[0]).toBeLessThanOrEqual(result[result.length - 1]); // => Verify sorted
  }); // => Performance test
});

test("rejects unauthenticated access", () => {
  const middleware = authMiddleware(); // => FAILS: Not defined
  const req = { headers: {} }; // No auth header
  const res = { status: jest.fn(), send: jest.fn() };

  middleware(req, res, jest.fn());

  expect(res.status).toHaveBeenCalledWith(401);
});

interface Request {
  headers: { authorization?: string };
}

interface Response {
  status(code: number): Response;
  send(body: any): void;
}

function authMiddleware() {
  return (req: Request, res: Response, next: () => void) => {
    if (!req.headers.authorization) {
      // => Check authorization header
      res.status(401).send({ error: "Unauthorized" }); // => Reject
      return;
    }

    const token = req.headers.authorization.replace("Bearer ", ""); // => Extract token
    if (token !== "valid-token") {
      // => Validate token
      res.status(403).send({ error: "Forbidden" }); // => Invalid token
      return;
    }

    next(); // => Allow request
  };
}

describe("authMiddleware", () => {
  test("rejects unauthenticated access", () => {
    const middleware = authMiddleware();
    const req = { headers: {} };
    const res = { status: jest.fn().mockReturnThis(), send: jest.fn() };

    middleware(req as Request, res as Response, jest.fn());

    expect(res.status).toHaveBeenCalledWith(401); // => Unauthorized
    expect(res.send).toHaveBeenCalledWith({ error: "Unauthorized" });
  });

  test("rejects invalid token", () => {
    const middleware = authMiddleware();
    const req = { headers: { authorization: "Bearer invalid" } };
    const res = { status: jest.fn().mockReturnThis(), send: jest.fn() };

    middleware(req as Request, res as Response, jest.fn());

    expect(res.status).toHaveBeenCalledWith(403); // => Forbidden
  });

  test("allows valid token", () => {
    const middleware = authMiddleware();
    const req = { headers: { authorization: "Bearer valid-token" } };
    const res = { status: jest.fn(), send: jest.fn() };
    const next = jest.fn();

    middleware(req as Request, res as Response, next);

    expect(next).toHaveBeenCalled(); // => Request allowed
  });
});

class ShoppingCart {
  private items: any[] = []; // => Private field

  addItem(item: any): void {
    this.items.push(item); // => Internal implementation
  }

  getTotal(): number {
    return this.items.reduce((sum, item) => sum + item.price, 0);
  }
}

// FAIL: BAD - Tests private implementation
test("adds item to items array", () => {
  const cart = new ShoppingCart();
  cart.addItem({ id: 1, price: 10 });

  expect(cart["items"]).toHaveLength(1); // => Accesses private field
  expect(cart["items"][0].price).toBe(10); // => Tests internal structure
}); // => Brittle test, breaks when implementation changes

// PASS: GOOD - Tests observable behavior
describe("ShoppingCart", () => {
  test("adds item and increases total", () => {
    const cart = new ShoppingCart();
    cart.addItem({ id: 1, price: 10 }); // => Public API

    expect(cart.getTotal()).toBe(10); // => Observable behavior
  }); // => Tests what cart does, not how it does it

  test("calculates total for multiple items", () => {
    const cart = new ShoppingCart();
    cart.addItem({ id: 1, price: 10 });
    cart.addItem({ id: 2, price: 20 });

    expect(cart.getTotal()).toBe(30); // => Behavior test
  });
});

| Approach            | Implementation Testing (BAD)       | Behavior Testing (GOOD) |
| ------------------- | ---------------------------------- | ----------------------- |
| **What it tests**   | Internal structure (items array)   | Public behavior (total) |
| **Coupling**        | Tightly coupled to internals       | Coupled to API only     |
| **Refactor safety** | Breaks when implementation changes | Survives refactoring    |
| **Value**           | Tests how it works                 | Tests what it does      |
| **Maintenance**     | High (brittle tests)               | Low (stable tests)      |

// FAIL: BAD - Excessive abstraction for testability
interface TimeProvider {
  now(): Date;
}

interface RandomProvider {
  random(): number;
}

interface LoggerProvider {
  log(message: string): void;
}

class UserService {
  constructor(
    private timeProvider: TimeProvider,
    private randomProvider: RandomProvider,
    private loggerProvider: LoggerProvider,
    // ... 5 more providers
  ) {} // => 8 constructor parameters for simple service

  createUser(name: string): any {
    const id = Math.floor(this.randomProvider.random() * 1000000);
    const createdAt = this.timeProvider.now();
    this.loggerProvider.log(`User created: ${name}`);
    return { id, name, createdAt };
  }
}

// PASS: GOOD - Inject only what needs variation in tests
class UserService {
  constructor(private idGenerator: () => number = () => Math.floor(Math.random() * 1000000)) {
    // => Only inject what varies in tests
  }

  createUser(name: string): any {
    const id = this.idGenerator(); // => Injected dependency
    const createdAt = new Date(); // => Simple, deterministic in most tests
    console.log(`User created: ${name}`); // => Logging doesn't affect behavior
    return { id, name, createdAt };
  }
}

test("createUser generates unique ID", () => {
  let nextId = 1;
  const service = new UserService(() => nextId++); // => Inject only ID generator

  const user1 = service.createUser("Alice");
  const user2 = service.createUser("Bob");

  expect(user1.id).toBe(1); // => Deterministic ID
  expect(user2.id).toBe(2); // => Controlled behavior
}); // => Simple test without excessive mocking

| Aspect              | Over-Engineered          | Pragmatic                  |
| ------------------- | ------------------------ | -------------------------- |
| **Constructor**     | 8+ parameters            | 1 parameter                |
| **Complexity**      | High (many abstractions) | Low (focused abstractions) |
| **Testability**     | 100% mockable            | Mockable where needed      |
| **Production Code** | Complex setup            | Simple setup               |
| **Maintenance**     | High (many interfaces)   | Low (minimal abstractions) |

// 1. Shared Testing Standards (documented in wiki/guide)
const TESTING_STANDARDS = {
  coverage: {
    minimum: 80, // => 80% line coverage required
    target: 95, // => 95% target for critical paths
  },
  naming: {
    pattern: "descriptive test names with spaces", // => Readable names
    structure: "should [expected behavior] when [condition]",
  },
  organization: {
    pattern: "describe → test hierarchy", // => Consistent structure
    oneAssertPerTest: false, // => Allow related assertions
  },
};

// 2. CI Enforcement (in pipeline config)
test("CI enforces coverage threshold", () => {
  const coverageReport = {
    // => Mock coverage report
    lines: { pct: 85 },
    statements: { pct: 84 },
    functions: { pct: 86 },
    branches: { pct: 82 },
  };

  const meetsThreshold = Object.values(coverageReport).every((metric) => metric.pct >= 80);
  // => Check all metrics

  expect(meetsThreshold).toBe(true); // => Enforced in CI
}); // => Build fails if coverage drops

// 3. Shared Test Utilities (npm package)
class TestHelpers {
  static createMockUser(overrides = {}): any {
    // => Shared test data builder
    return {
      id: 1,
      name: "Test User",
      email: "test@example.com",
      role: "user",
      ...overrides, // => Customizable fields
    };
  }

  static waitFor(condition: () => boolean, timeout = 5000): Promise<void> {
    // => Shared async helper
    return new Promise((resolve, reject) => {
      const startTime = Date.now();
      const check = () => {
        if (condition()) {
          resolve();
        } else if (Date.now() - startTime > timeout) {
          reject(new Error("Timeout"));
        } else {
          setTimeout(check, 100);
        }
      };
      check();
    });
  }
}

// 4. Cross-Team Knowledge Sharing
describe("Testing Guild Practices", () => {
  test("teams share testing patterns", () => {
    const guild = {
      // => Testing guild structure
      members: ["Team A", "Team B", "Team C"],
      meetings: "bi-weekly",
      activities: ["pattern sharing", "code reviews", "training"],
    };

    expect(guild.activities).toContain("pattern sharing"); // => Knowledge transfer
  });
});

- [ ] Document testing standards (wiki, guide)
- [ ] Enforce coverage thresholds in CI (80% minimum)
- [ ] Create shared test utility packages
- [ ] Establish testing guild for cross-team learning
- [ ] Implement pre-commit hooks for test quality
- [ ] Run periodic test health reviews
- [ ] Provide TDD training for new team members
- [ ] Share success stories and metrics

FAIL: BAD Approach:

1. Presentation: "Introduction to TDD" (60 minutes)
2. Slides: Red-Green-Refactor cycle (30 slides)
3. Demo: Instructor codes alone (20 minutes)
4. Q&A: Students ask questions (10 minutes)
5. Result: Students understand theory, can't apply it

// 1. Kata Exercise: FizzBuzz (Pair Programming)
describe("FizzBuzz Kata", () => {
  // Kata steps:
  // - Driver: Write failing test
  // - Navigator: Suggest minimal implementation
  // - Switch roles every 5 minutes
  // - Complete 15 rules in 75 minutes

  test("returns number for non-multiples", () => {
    expect(fizzBuzz(1)).toBe("1"); // => Failing test (Red)
  });

  // Student implements minimal code (Green)
  function fizzBuzz(n: number): string {
    return String(n); // => Simplest implementation
  }

  test("returns Fizz for multiples of 3", () => {
    expect(fizzBuzz(3)).toBe("Fizz"); // => Next failing test
  });

  // Student refactors implementation (Refactor)
});

// 2. Code Review Feedback (Real Production Code)
class CodeReviewFeedback {
  // FAIL: BAD - Testing implementation details
  test_BAD_example() {
    const cart = new ShoppingCart();
    cart.addItem({ price: 10 });
    expect(cart["items"].length).toBe(1); // => Reviewer flags this
  }

  // PASS: GOOD - Testing behavior
  test_GOOD_example() {
    const cart = new ShoppingCart();
    cart.addItem({ price: 10 });
    expect(cart.getTotal()).toBe(10); // => Reviewer approves
  }
}

// 3. Mobbing Session (Team Learning)
describe("Mob Programming TDD", () => {
  // Setup:
  // - One driver (keyboard)
  // - 4-6 navigators (giving directions)
  // - Rotate driver every 10 minutes
  // - Solve real production problem as team

  test("team solves problem together", () => {
    const mobSession = {
      driver: "Alice",
      navigators: ["Bob", "Charlie", "Diana"],
      problem: "Implement user authentication",
      learnings: ["TDD rhythm", "Test design", "Refactoring"],
    };

    expect(mobSession.learnings).toContain("TDD rhythm"); // => Collective learning
  });
});

| Week | Activity                          | Duration | Focus                     |
| ---- | --------------------------------- | -------- | ------------------------- |
| 1    | FizzBuzz Kata (Pair Programming)  | 90 min   | Red-Green-Refactor rhythm |
| 2    | String Calculator Kata            | 90 min   | Test design               |
| 3    | Bowling Game Kata                 | 90 min   | Refactoring               |
| 4    | Production Code (Mob Programming) | 2 hours  | Real-world application    |
| 5    | Code Reviews with TDD Feedback    | Ongoing  | Continuous improvement    |

interface TDDMetrics {
  defectDensity: number; // => Defects per 1000 lines of code
  developmentVelocity: number; // => Story points per sprint
  maintenanceCost: number; // => Hours spent on bug fixes
  testCoverage: number; // => Percentage of code covered
  cycleTime: number; // => Time from commit to production
}

// Before TDD baseline (Month 0)
const beforeTDD: TDDMetrics = {
  defectDensity: 15, // => 15 defects per 1000 LOC
  developmentVelocity: 20, // => 20 story points per sprint
  maintenanceCost: 120, // => 120 hours per month on bugs
  testCoverage: 40, // => 40% coverage
  cycleTime: 168, // => 1 week (hours)
};

// After TDD adoption (Month 6)
const afterTDD: TDDMetrics = {
  defectDensity: 3, // => 3 defects per 1000 LOC (80% reduction)
  developmentVelocity: 28, // => 28 story points per sprint (40% increase)
  maintenanceCost: 30, // => 30 hours per month on bugs (75% reduction)
  testCoverage: 92, // => 92% coverage
  cycleTime: 24, // => 1 day (hours) (86% reduction)
};

test("calculates TDD ROI", () => {
  const defectReduction = ((beforeTDD.defectDensity - afterTDD.defectDensity) / beforeTDD.defectDensity) * 100;
  // => 80% defect reduction

  const velocityIncrease =
    ((afterTDD.developmentVelocity - beforeTDD.developmentVelocity) / beforeTDD.developmentVelocity) * 100;
  // => 40% velocity increase

  const maintenanceSavings = ((beforeTDD.maintenanceCost - afterTDD.maintenanceCost) / beforeTDD.maintenanceCost) * 100;
  // => 75% maintenance cost reduction

  expect(defectReduction).toBeGreaterThan(70); // => Significant quality improvement
  expect(velocityIncrease).toBeGreaterThan(30); // => Productivity gain
  expect(maintenanceSavings).toBeGreaterThan(60); // => Cost savings
});

// ROI Calculation
function calculateTDDROI(before: TDDMetrics, after: TDDMetrics): number {
  const costReduction = before.maintenanceCost - after.maintenanceCost; // => 90 hours saved
  const hourlyRate = 75; // => Average developer hourly rate
  const monthlySavings = costReduction * hourlyRate; // => substantial amounts per month

  const tddInvestment = 40; // => 40 hours TDD training cost
  const investmentCost = tddInvestment * hourlyRate; // => substantial amounts one-time

  const paybackMonths = investmentCost / monthlySavings; // => 0.44 months (2 weeks)
  return paybackMonths; // => ROI achieved in < 1 month
}

test("TDD investment pays back quickly", () => {
  const payback = calculateTDDROI(beforeTDD, afterTDD);
  expect(payback).toBeLessThan(1); // => Pays back in under 1 month
});

test("logs all financial transactions for audit", () => {
  const processor = new TransactionProcessor(); // => FAILS: No audit logging
  processor.processPayment(100, "USD");
  const auditLog = processor.getAuditLog();
  expect(auditLog).toHaveLength(1);
});

interface AuditEntry {
  timestamp: Date;
  action: string;
  amount: number;
  currency: string;
  userId: string;
}

class TransactionProcessor {
  private auditLog: AuditEntry[] = []; // => Audit trail storage

  processPayment(amount: number, currency: string, userId = "system"): void {
    // Process payment logic
    this.logAudit("PAYMENT_PROCESSED", amount, currency, userId); // => Audit logging
  }

  private logAudit(action: string, amount: number, currency: string, userId: string): void {
    this.auditLog.push({
      // => Immutable audit entry
      timestamp: new Date(),
      action,
      amount,
      currency,
      userId,
    });
  }

  getAuditLog(): AuditEntry[] {
    return [...this.auditLog]; // => Return copy (immutable)
  }
}

describe("TransactionProcessor audit compliance", () => {
  test("logs all financial transactions", () => {
    const processor = new TransactionProcessor();
    processor.processPayment(100, "USD", "user-123");

    const auditLog = processor.getAuditLog();
    expect(auditLog).toHaveLength(1); // => One entry logged
    expect(auditLog[0].action).toBe("PAYMENT_PROCESSED");
    expect(auditLog[0].amount).toBe(100);
    expect(auditLog[0].currency).toBe("USD");
    expect(auditLog[0].userId).toBe("user-123");
  }); // => Regulatory requirement tested

  test("audit log is immutable", () => {
    const processor = new TransactionProcessor();
    processor.processPayment(100, "USD");

    const log1 = processor.getAuditLog();
    const log2 = processor.getAuditLog();

    expect(log1).not.toBe(log2); // => Different array instances
    expect(log1).toEqual(log2); // => Same content
  }); // => Prevents tampering
});

test("deletes user data on request (GDPR Right to be Forgotten)", () => {
  const userService = new UserService(); // => FAILS: No deletion logic
  userService.createUser("alice@example.com", { name: "Alice" });
  userService.deleteUserData("alice@example.com");

  const user = userService.getUser("alice@example.com");
  expect(user).toBeNull(); // GDPR: User data must be deleted
});

interface UserData {
  email: string;
  name: string;
  createdAt: Date;
}

class UserService {
  private users: Map<string, UserData> = new Map();
  private deletionLog: Array<{ email: string; deletedAt: Date }> = [];

  createUser(email: string, data: Omit<UserData, "email" | "createdAt">): void {
    this.users.set(email, {
      // => Store user data
      email,
      ...data,
      createdAt: new Date(),
    });
  }

  deleteUserData(email: string): void {
    this.users.delete(email); // => Delete user data
    this.deletionLog.push({
      // => Log deletion for compliance
      email,
      deletedAt: new Date(),
    });
  }

  getUser(email: string): UserData | null {
    return this.users.get(email) || null;
  }

  getDeletionLog(): Array<{ email: string; deletedAt: Date }> {
    return [...this.deletionLog]; // => Audit trail
  }
}

describe("GDPR Compliance", () => {
  test("deletes user data on request", () => {
    const service = new UserService();
    service.createUser("alice@example.com", { name: "Alice" });
    service.deleteUserData("alice@example.com");

    const user = service.getUser("alice@example.com");
    expect(user).toBeNull(); // => Data deleted
  });

  test("logs data deletion for audit", () => {
    const service = new UserService();
    service.createUser("alice@example.com", { name: "Alice" });
    service.deleteUserData("alice@example.com");

    const log = service.getDeletionLog();
    expect(log).toHaveLength(1); // => Deletion logged
    expect(log[0].email).toBe("alice@example.com");
  }); // => Compliance audit trail
});