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
});

test("model predicts spam classification", () => {
  const model = new SpamClassifier(); // => FAILS: Model not defined
  const result = model.predict("Buy now! Limited offer!");
  expect(result.label).toBe("spam");
  expect(result.confidence).toBeGreaterThan(0.8);
});

interface Prediction {
  label: "spam" | "ham";
  confidence: number;
}
 
class SpamClassifier {
  predict(text: string): Prediction {
    // => Simplified model (real ML model would be complex)
    const spamKeywords = ["buy now", "limited offer", "click here"];
    const hasSpamKeyword = spamKeywords.some((keyword) => text.toLowerCase().includes(keyword));
    // => Checks for spam indicators
 
    return {
      label: hasSpamKeyword ? "spam" : "ham", // => Classification
      confidence: hasSpamKeyword ? 0.95 : 0.6, // => Confidence score
    };
  }
}
 
describe("SpamClassifier", () => {
  test("classifies obvious spam", () => {
    const model = new SpamClassifier();
    const result = model.predict("Buy now! Limited offer!");
 
    expect(result.label).toBe("spam"); // => Correct classification
    expect(result.confidence).toBeGreaterThan(0.8); // => High confidence
  });
 
  test("classifies normal email", () => {
    const model = new SpamClassifier();
    const result = model.predict("Meeting at 3pm today");
 
    expect(result.label).toBe("ham"); // => Correct classification
  });
 
  test("handles empty input", () => {
    const model = new SpamClassifier();
    const result = model.predict("");
 
    expect(result.label).toBe("ham"); // => Default classification
  });
});

describe("ML System Testing", () => {
  test("data preprocessing pipeline", () => {
    function preprocessText(text: string): string[] {
      // => Tokenization
      return text.toLowerCase().split(/\s+/); // => Split into words
    }
 
    const tokens = preprocessText("Buy Now Limited Offer");
    expect(tokens).toEqual(["buy", "now", "limited", "offer"]); // => Verify preprocessing
  });
 
  test("model prediction boundaries", () => {
    const model = new SpamClassifier();
 
    // Test known spam examples
    const spamExamples = ["Buy now!", "Click here for free", "Limited time offer"];
 
    spamExamples.forEach((example) => {
      const result = model.predict(example);
      expect(result.label).toBe("spam"); // => All should be spam
    });
  });
});

test("sentiment model handles sarcasm", () => {
  const model = new SentimentAnalyzer(); // => FAILS: Model not defined
  const result = model.analyze("Oh great, another Monday!");
  expect(result.sentiment).toBe("negative"); // Sarcasm detection
});

interface SentimentResult {
  sentiment: "positive" | "negative" | "neutral";
  score: number;
}
 
class SentimentAnalyzer {
  analyze(text: string): SentimentResult {
    // => Simplified model
    const positiveWords = ["great", "excellent", "amazing"];
    const negativeWords = ["terrible", "awful", "hate", "monday"];
 
    const hasNegative = negativeWords.some((word) => text.toLowerCase().includes(word));
    const hasPositive = positiveWords.some((word) => text.toLowerCase().includes(word));
 
    if (hasNegative && hasPositive) {
      // => Sarcasm indicator
      return { sentiment: "negative", score: 0.3 }; // => Assume sarcasm is negative
    } else if (hasNegative) {
      return { sentiment: "negative", score: 0.8 };
    } else if (hasPositive) {
      return { sentiment: "positive", score: 0.8 };
    }
 
    return { sentiment: "neutral", score: 0.5 }; // => Default neutral
  }
}
 
describe("SentimentAnalyzer behavior", () => {
  test("detects positive sentiment", () => {
    const model = new SentimentAnalyzer();
    const result = model.analyze("This is amazing!");
    expect(result.sentiment).toBe("positive");
  });
 
  test("detects negative sentiment", () => {
    const model = new SentimentAnalyzer();
    const result = model.analyze("This is terrible");
    expect(result.sentiment).toBe("negative");
  });
 
  test("handles sarcasm", () => {
    const model = new SentimentAnalyzer();
    const result = model.analyze("Oh great, another Monday!");
    expect(result.sentiment).toBe("negative"); // => Sarcasm interpreted as negative
  });
 
  test("handles neutral text", () => {
    const model = new SentimentAnalyzer();
    const result = model.analyze("The meeting is at 3pm");
    expect(result.sentiment).toBe("neutral");
  });
});

test("modules do not have circular dependencies", () => {
  const dependencies = analyzeDependencies(); // => FAILS: Analysis not implemented
  const hasCycles = detectCycles(dependencies);
  expect(hasCycles).toBe(false); // Architectural constraint
});

type DependencyGraph = Map<string, Set<string>>;
 
function analyzeDependencies(): DependencyGraph {
  // => Simplified dependency analysis
  const graph: DependencyGraph = new Map();
  graph.set("moduleA", new Set(["moduleB"])); // => A depends on B
  graph.set("moduleB", new Set(["moduleC"])); // => B depends on C
  graph.set("moduleC", new Set()); // => C has no dependencies
  return graph;
}
 
function detectCycles(graph: DependencyGraph): boolean {
  const visited = new Set<string>();
  const recursionStack = new Set<string>();
 
  function hasCycle(node: string): boolean {
    if (recursionStack.has(node)) return true; // => Cycle detected
    if (visited.has(node)) return false; // => Already checked
 
    visited.add(node);
    recursionStack.add(node);
 
    const neighbors = graph.get(node) || new Set();
    for (const neighbor of neighbors) {
      if (hasCycle(neighbor)) return true;
    }
 
    recursionStack.delete(node);
    return false;
  }
 
  for (const node of graph.keys()) {
    if (hasCycle(node)) return true;
  }
 
  return false; // => No cycles found
}
 
describe("Evolutionary Architecture Fitness Functions", () => {
  test("detects no cycles in valid dependency graph", () => {
    const dependencies = analyzeDependencies();
    const hasCycles = detectCycles(dependencies);
    expect(hasCycles).toBe(false); // => Valid architecture
  });
 
  test("detects cycles in invalid dependency graph", () => {
    const graph: DependencyGraph = new Map();
    graph.set("A", new Set(["B"]));
    graph.set("B", new Set(["C"]));
    graph.set("C", new Set(["A"])); // => Cycle: A → B → C → A
 
    const hasCycles = detectCycles(graph);
    expect(hasCycles).toBe(true); // => Cycle detected
  });
});

// Test Pyramid Structure
describe("Test Pyramid for Continuous Deployment", () => {
  // Layer 1: Unit Tests (70% of tests) - Fast, isolated
  describe("Unit Tests", () => {
    test("business logic is correct", () => {
      const calculator = new PriceCalculator();
      expect(calculator.calculateDiscount(100, 0.1)).toBe(90);
    }); // => Millisecond execution
 
    // 1000+ unit tests covering all business logic
  });
 
  // Layer 2: Integration Tests (20% of tests) - Medium speed
  describe("Integration Tests", () => {
    test("service integrates with database", async () => {
      const db = new InMemoryDatabase(); // => Fake database
      const service = new UserService(db);
 
      await service.createUser("alice@example.com", { name: "Alice" });
      const user = await service.getUser("alice@example.com");
 
      expect(user?.name).toBe("Alice");
    }); // => Sub-second execution
 
    // 200+ integration tests covering component interactions
  });
 
  // Layer 3: End-to-End Tests (10% of tests) - Slow but comprehensive
  describe("E2E Tests", () => {
    test("user can complete checkout flow", async () => {
      const browser = await launchBrowser();
      await browser.goto("/products");
      await browser.click("[data-testid=add-to-cart]");
      await browser.click("[data-testid=checkout]");
      const confirmation = await browser.text("[data-testid=order-confirmation]");
 
      expect(confirmation).toContain("Order confirmed");
      await browser.close();
    }); // => Seconds to minutes
 
    // 50+ E2E tests covering critical user flows
  });
});
 
// Deployment Pipeline
test("deployment pipeline validates quality gates", () => {
  const pipeline = {
    stages: [
      { name: "Unit Tests", threshold: 95, coverage: 96, status: "pass" }, // => 95% required
      { name: "Integration Tests", threshold: 85, coverage: 88, status: "pass" }, // => 85% required
      { name: "E2E Tests", threshold: 100, passed: 50, total: 50, status: "pass" }, // => All must pass
      { name: "Deploy to Production", status: "ready" }, // => Automated deployment
    ],
  };
 
  const allStagesPassed = pipeline.stages.slice(0, -1).every((stage) => stage.status === "pass");
  expect(allStagesPassed).toBe(true); // => Quality gates met
}); // => Deploy with confidence

interface CDMetrics {
  deploymentFrequency: string; // => "10+ per day"
  leadTime: string; // => "< 1 hour (commit to production)"
  mttr: string; // => "< 15 minutes (mean time to recovery)"
  changeFailureRate: number; // => "< 5% (failed deployments)"
}
 
const cdMetrics: CDMetrics = {
  deploymentFrequency: "10+ per day", // => High deployment frequency
  leadTime: "< 1 hour", // => Fast feedback
  mttr: "< 15 minutes", // => Quick recovery
  changeFailureRate: 0.03, // => 3% failure rate (97% success)
};
 
test("CD metrics meet industry benchmarks", () => {
  expect(cdMetrics.changeFailureRate).toBeLessThan(0.05); // => Less than 5%
}); // => Automated testing enables safe CD

test("canary deployment serves 5% of traffic", () => {
  const deployment = new CanaryDeployment(); // => FAILS: Not implemented
  deployment.deploy("v2.0", { canaryPercentage: 5 });
 
  const trafficDistribution = deployment.getTrafficDistribution();
  expect(trafficDistribution.v1).toBe(95);
  expect(trafficDistribution.v2).toBe(5);
});

interface DeploymentConfig {
  canaryPercentage: number;
}
 
class CanaryDeployment {
  private currentVersion = "v1.0";
  private canaryVersion: string | null = null;
  private canaryPercentage = 0;
 
  deploy(version: string, config: DeploymentConfig): void {
    this.canaryVersion = version; // => New version
    this.canaryPercentage = config.canaryPercentage; // => Traffic percentage
  }
 
  routeRequest(requestId: number): string {
    // => Deterministic routing based on request ID
    const isCanary = requestId % 100 < this.canaryPercentage;
    return isCanary && this.canaryVersion ? this.canaryVersion : this.currentVersion;
  }
 
  getTrafficDistribution(): Record<string, number> {
    const distribution: Record<string, number> = {};
    distribution[this.currentVersion] = 100 - this.canaryPercentage;
    if (this.canaryVersion) {
      distribution[this.canaryVersion] = this.canaryPercentage;
    }
    return distribution;
  }
}
 
describe("Canary Deployment", () => {
  test("routes 5% traffic to canary", () => {
    const deployment = new CanaryDeployment();
    deployment.deploy("v2.0", { canaryPercentage: 5 });
 
    const distribution = deployment.getTrafficDistribution();
    expect(distribution["v1.0"]).toBe(95); // => 95% to stable
    expect(distribution["v2.0"]).toBe(5); // => 5% to canary
  });
 
  test("routes requests correctly", () => {
    const deployment = new CanaryDeployment();
    deployment.deploy("v2.0", { canaryPercentage: 5 });
 
    const results = Array.from({ length: 100 }, (_, i) => deployment.routeRequest(i));
    const canaryCount = results.filter((v) => v === "v2.0").length;
 
    expect(canaryCount).toBe(5); // => Exactly 5% routed to canary
  });
});

test("feature flag controls new checkout flow", () => {
  const flags = new FeatureFlags(); // => FAILS: Not implemented
  flags.enable("new-checkout", { percentage: 10 });
 
  const isEnabled = flags.isEnabled("new-checkout", "user-123");
  expect(typeof isEnabled).toBe("boolean"); // Should return true or false
});

interface FlagConfig {
  percentage?: number;
  users?: string[];
}
 
class FeatureFlags {
  private flags: Map<string, FlagConfig> = new Map();
 
  enable(flagName: string, config: FlagConfig = {}): void {
    this.flags.set(flagName, config); // => Enable flag with config
  }
 
  isEnabled(flagName: string, userId: string): boolean {
    const config = this.flags.get(flagName);
    if (!config) return false; // => Flag not enabled
 
    // Check user whitelist
    if (config.users?.includes(userId)) return true;
 
    // Check percentage rollout
    if (config.percentage) {
      const hash = this.hashUserId(userId); // => Deterministic hash
      return hash % 100 < config.percentage; // => Percentage-based rollout
    }
 
    return false;
  }
 
  private hashUserId(userId: string): number {
    // => Simple hash function
    let hash = 0;
    for (let i = 0; i < userId.length; i++) {
      hash = (hash << 5) - hash + userId.charCodeAt(i);
      hash = hash & hash; // => Convert to 32-bit integer
    }
    return Math.abs(hash);
  }
}
 
describe("Feature Flags", () => {
  test("enables feature for whitelisted users", () => {
    const flags = new FeatureFlags();
    flags.enable("new-checkout", { users: ["user-123", "user-456"] });
 
    expect(flags.isEnabled("new-checkout", "user-123")).toBe(true); // => Whitelisted
    expect(flags.isEnabled("new-checkout", "user-789")).toBe(false); // => Not whitelisted
  });
 
  test("enables feature for percentage of users", () => {
    const flags = new FeatureFlags();
    flags.enable("new-checkout", { percentage: 10 });
 
    const results = Array.from({ length: 1000 }, (_, i) => flags.isEnabled("new-checkout", `user-${i}`));
    const enabledCount = results.filter((enabled) => enabled).length;
 
    expect(enabledCount).toBeGreaterThan(50); // => Approximately 10% (100)
    expect(enabledCount).toBeLessThan(150); // => Within reasonable variance
  });
 
  test("consistent rollout for same user", () => {
    const flags = new FeatureFlags();
    flags.enable("new-checkout", { percentage: 50 });
 
    const result1 = flags.isEnabled("new-checkout", "user-123");
    const result2 = flags.isEnabled("new-checkout", "user-123");
 
    expect(result1).toBe(result2); // => Deterministic for same user
  });
});