Intermediate

// Red: Test user service without database
test("getUserName returns name from repository", () => {
  // => Test definition
  const userService = new UserService(); // => FAILS: needs repository
  // => UserService requires UserRepository dependency
  expect(userService.getUserName(1)).toBe("Alice"); // => Expect name "Alice"
  // => Test fails - no repository provided
});

interface UserRepository {
  // => Interface for dependency
  // => Defines contract for repository
  findById(id: number): { id: number; name: string } | null; // => Method signature
  // => Returns user object or null
}
 
class StubUserRepository implements UserRepository {
  // => Stub implementation
  // => Implements UserRepository interface
  findById(id: number): { id: number; name: string } | null {
    // => Method implementation
    // => Returns hardcoded data (stub behavior)
    return { id: 1, name: "Alice" }; // => Predetermined response
    // => Always returns same user regardless of id
  }
}
 
class UserService {
  // => Service under test
  constructor(private repository: UserRepository) {} // => Dependency injection
  // => Repository injected via constructor
 
  getUserName(id: number): string {
    // => Get name by user id
    const user = this.repository.findById(id); // => Calls stub
    // => Delegates to injected repository
    return user ? user.name : "Unknown"; // => Returns name or default
    // => Handles null case with fallback
  }
}
 
test("getUserName returns name from repository", () => {
  // => Test with stub
  const stubRepo = new StubUserRepository(); // => Create stub
  // => Stub provides controlled data
  const userService = new UserService(stubRepo); // => Inject stub
  // => Pass stub to service constructor
  expect(userService.getUserName(1)).toBe("Alice"); // => Test passes
  // => Stub returns "Alice", assertion succeeds
});

test("notifyUser sends email to correct address", () => {
  // => Test email notification
  const notifier = new UserNotifier(); // => FAILS: needs email service
  // => UserNotifier requires EmailService dependency
  notifier.notifyUser(1, "Welcome!"); // => Call notification method
  // => Need to verify email was sent
  // => Test fails - no way to verify interaction
});

interface EmailService {
  // => Email service contract
  send(to: string, message: string): void; // => Method to send email
  // => Takes recipient and message
}
 
class MockEmailService implements EmailService {
  // => Mock implementation
  // => Implements EmailService for testing
  calls: Array<{ to: string; message: string }> = []; // => Tracks calls
  // => Array stores each send() invocation
 
  send(to: string, message: string): void {
    // => Record send calls
    this.calls.push({ to, message }); // => Records interaction
    // => Stores recipient and message for verification
  }
 
  wasCalled(): boolean {
    // => Check if send was called
    return this.calls.length > 0; // => Verification helper
    // => Returns true if any calls recorded
  }
 
  wasCalledWith(to: string, message: string): boolean {
    // => Verify specific call
    // => Check for exact arguments match
    return this.calls.some((call) => call.to === to && call.message === message);
    // => Returns true if matching call found
  }
}
 
class UserNotifier {
  // => Service under test
  constructor(
    // => Constructor injection
    private emailService: EmailService, // => Injected email service
    private userRepo: UserRepository, // => Injected user repository
  ) {}
  // => Both dependencies injected for testability
 
  notifyUser(userId: number, message: string): void {
    // => Send notification
    const user = this.userRepo.findById(userId); // => Get user
    // => Fetch user data from repository
    if (user) {
      // => Check user exists
      this.emailService.send(user.email, message); // => Send email
      // => Calls email service with user's address
    }
  }
}
 
test("notifyUser sends email to user address", () => {
  // => Test notification
  const stubRepo = {
    // => Stub for user data
    // => Inline stub object
    findById: (id: number) => ({ id, name: "Alice", email: "alice@example.com" }),
    // => Returns predefined user
  };
  const mockEmail = new MockEmailService(); // => Mock for verification
  // => Creates mock to track email calls
  const notifier = new UserNotifier(mockEmail, stubRepo); // => Inject both
  // => Pass mock email and stub repo
 
  notifier.notifyUser(1, "Welcome!"); // => Execute behavior
  // => Call method under test
 
  expect(mockEmail.wasCalled()).toBe(true); // => Verify email sent
  // => Assert send() was called
  expect(mockEmail.wasCalledWith("alice@example.com", "Welcome!")).toBe(true);
  // => Verify correct arguments
  // => Assert called with right email and message
});

test("processOrder logs order processing", () => {
  // => Test logging behavior
  const processor = new OrderProcessor(); // => FAILS: needs to verify logging
  // => OrderProcessor requires Logger dependency
  processor.processOrder({ id: 1, total: 100 }); // => Execute processing
  // Need to verify logger was called without replacing logger behavior
  // => Test fails - can't verify logging without spy
});

interface Logger {
  // => Logger contract
  log(message: string): void; // => Log method signature
  // => Takes message string
}
 
class ConsoleLogger implements Logger {
  // => Real logger implementation
  log(message: string): void {
    // => Actual logging
    console.log(message); // => Real implementation
    // => Writes to console
  }
}
 
class SpyLogger implements Logger {
  // => Spy implementation
  // => Wraps real logger for tracking
  private realLogger: Logger; // => Wraps real logger
  // => Delegates to actual implementation
  calls: string[] = []; // => Tracks calls
  // => Array stores all logged messages
 
  constructor(realLogger: Logger) {
    // => Constructor takes real logger
    this.realLogger = realLogger; // => Stores wrapped logger
    // => Spy wraps the real implementation
  }
 
  log(message: string): void {
    // => Spy log method
    this.calls.push(message); // => Record call
    // => Track message for verification
    this.realLogger.log(message); // => Delegate to real logger
    // => Preserve actual logging behavior
  }
}
 
class OrderProcessor {
  // => Service under test
  constructor(private logger: Logger) {} // => Inject logger
  // => Logger dependency injected
 
  processOrder(order: { id: number; total: number }): void {
    // => Process order
    this.logger.log(`Processing order ${order.id}`); // => Log action
    // => Log start of processing
    // ... processing logic ...
    this.logger.log(`Order ${order.id} completed: $${order.total}`); // => Log completion
    // => Log end of processing with total
  }
}
 
test("processOrder logs start and completion", () => {
  // => Test logging
  const spyLogger = new SpyLogger(new ConsoleLogger()); // => Spy wraps real logger
  // => Create spy that delegates to ConsoleLogger
  const processor = new OrderProcessor(spyLogger); // => Inject spy
  // => Pass spy logger to processor
 
  processor.processOrder({ id: 1, total: 100 }); // => Execute processing
  // => Process order triggers logging
 
  expect(spyLogger.calls).toContain("Processing order 1"); // => Verify first log
  // => Check start message was logged
  expect(spyLogger.calls).toContain("Order 1 completed: $100"); // => Verify second log
  // => Check completion message was logged
  expect(spyLogger.calls.length).toBe(2); // => Verify call count
  // => Assert exactly 2 log calls made
});

test("createUser stores user in database", () => {
  // => Test user creation
  const userService = new UserService(); // => FAILS: needs database
  // => UserService requires Database dependency
  const user = userService.createUser("alice", "alice@example.com"); // => Create user
  // => Calls createUser method
  expect(userService.findById(user.id)).toEqual(user); // => Verify persistence
  // => Test fails - no database provided
});

interface Database {
  // => Database contract
  insert(table: string, data: any): number; // => Insert method
  // => Takes table name and data, returns ID
  findById(table: string, id: number): any; // => Find method
  // => Takes table and ID, returns record
}
 
class FakeDatabase implements Database {
  // => Fake implementation
  // => Simplified in-memory database
  private data: Map<string, Map<number, any>> = new Map(); // => In-memory storage
  // => Two-level map: table → (id → record)
  private nextId = 1; // => ID counter
  // => Auto-increment ID generator
 
  insert(table: string, data: any): number {
    // => Insert record
    if (!this.data.has(table)) {
      // => Check table exists
      this.data.set(table, new Map()); // => Create table if needed
      // => Initialize table as empty Map
    }
    const id = this.nextId++; // => Generate ID
    // => Increment counter and use value
    const record = { ...data, id }; // => Add ID to record
    // => Spread data and add generated ID
    this.data.get(table)!.set(id, record); // => Store record
    // => Save record in table by ID
    return id; // => Return generated ID
    // => Return ID to caller
  }
 
  findById(table: string, id: number): any {
    // => Find record
    return this.data.get(table)?.get(id); // => Retrieve record
    // => Get table, then get record by ID
    // => Returns undefined if table or ID not found
  }
}
 
class UserService {
  // => Service under test
  constructor(private db: Database) {} // => Inject database
  // => Database dependency injected
 
  createUser(name: string, email: string): { id: number; name: string; email: string } {
    // => Create user
    const id = this.db.insert("users", { name, email }); // => Insert user
    // => Call database insert method
    return { id, name, email }; // => Return created user
    // => Return user object with generated ID
  }
 
  findById(id: number): any {
    // => Find user by ID
    return this.db.findById("users", id); // => Retrieve user
    // => Delegate to database findById
  }
}
 
test("createUser stores and retrieves user", () => {
  // => Test persistence
  const fakeDb = new FakeDatabase(); // => Fake database
  // => Create in-memory fake
  const userService = new UserService(fakeDb); // => Inject fake
  // => Pass fake to service
 
  const user = userService.createUser("alice", "alice@example.com"); // => Create user
  // => Call createUser method
 
  expect(user.id).toBe(1); // => Verify ID generated
  // => First user gets ID 1
  expect(userService.findById(1)).toEqual({
    // => Verify stored correctly
    // => Retrieve user by ID
    id: 1, // => ID matches
    name: "alice", // => Name persisted
    email: "alice@example.com", // => Email persisted
  });
  // => All fields stored correctly
});

class PaymentProcessor {
  // => Untestable class
  process(amount: number): boolean {
    // => Process payment
    const gateway = new PayPalGateway(); // => FAIL: Hard-coded dependency
    // => Creates PayPalGateway directly - cannot mock
    return gateway.charge(amount); // => Cannot test without real PayPal
    // => Calls real PayPal API - testing requires live service
  }
}

interface PaymentGateway {
  // => Payment gateway contract
  charge(amount: number): boolean; // => Charge method signature
  // => Returns success/failure boolean
}
 
class PayPalGateway implements PaymentGateway {
  // => Real implementation
  charge(amount: number): boolean {
    // => Actual PayPal integration
    // Real PayPal API call
    // => Makes HTTP request to PayPal
    return true; // => Actual implementation
    // => Returns API response
  }
}
 
class MockPaymentGateway implements PaymentGateway {
  // => Mock for testing
  // => Test double implementation
  chargeAttempts: number[] = []; // => Track calls
  // => Records all charge attempts
 
  charge(amount: number): boolean {
    // => Mock charge logic
    this.chargeAttempts.push(amount); // => Record attempt
    // => Store amount for verification
    return amount < 1000; // => Mock logic: success under $1000
    // => Simple rule for testing
  }
}
 
class PaymentProcessor {
  // => Testable processor
  constructor(private gateway: PaymentGateway) {} // => Dependency injected
  // => Gateway passed via constructor
 
  process(amount: number): boolean {
    // => Process payment
    return this.gateway.charge(amount); // => Uses injected gateway
    // => Delegates to injected dependency
  }
}
 
test("process charges correct amount", () => {
  // => Test charging
  const mockGateway = new MockPaymentGateway(); // => Test double
  // => Create mock gateway
  const processor = new PaymentProcessor(mockGateway); // => Inject mock
  // => Pass mock to constructor
 
  const result = processor.process(500); // => Process $500
  // => Call process method
 
  expect(result).toBe(true); // => Verify success
  // => $500 < $1000 should succeed
  expect(mockGateway.chargeAttempts).toEqual([500]); // => Verify amount
  // => Check correct amount was charged
});
 
test("process handles large amounts", () => {
  // => Test failure case
  const mockGateway = new MockPaymentGateway(); // => Create mock
  // => Fresh mock for this test
  const processor = new PaymentProcessor(mockGateway); // => Inject mock
  // => Pass mock to processor
 
  const result = processor.process(1500); // => Over limit
  // => $1500 >= $1000 should fail
 
  expect(result).toBe(false); // => Verify failure
  // => Mock returns false for amounts >= $1000
});

test("fetchUser returns user data", async () => {
  // => Async test
  // => FAILS: fetchUser not defined
  // => Function doesn't exist yet
  const user = await fetchUser(1); // => Await promise
  // => Will fail with "fetchUser is not defined"
  expect(user.name).toBe("Alice"); // => Expected outcome
});

async function fetchUser(id: number): Promise<{ id: number; name: string }> {
  // => Async function
  // => Returns Promise containing user object
  return { id, name: "Alice" }; // => Resolved value
  // => Promise resolves immediately with object
}
 
test("fetchUser returns user data", async () => {
  // => async test function
  // => Mark test as async to use await
  const user = await fetchUser(1); // => Await promise
  // => Pauses test until promise resolves
  expect(user.name).toBe("Alice"); // => Assert on resolved value
  // => Test passes - name is "Alice"
});

async function fetchUser(id: number): Promise<{ id: number; name: string }> {
  // => Async with validation
  if (id <= 0) {
    // => Validation
    // => Check for invalid ID
    throw new Error("Invalid user ID"); // => Promise rejection
    // => Throwing in async function rejects promise
  }
  return { id, name: "Alice" }; // => Promise resolution
  // => Returns resolved promise with user data
}
 
describe("fetchUser", () => {
  // => Test suite
  test("resolves with user data for valid ID", async () => {
    // => Success path
    const user = await fetchUser(1); // => Await valid call
    // => Promise resolves with user object
    expect(user).toEqual({ id: 1, name: "Alice" }); // => Verify complete object
    // => All fields match expected values
  });
 
  test("rejects with error for invalid ID", async () => {
    // => Test rejection
    // => Validates error handling path
    await expect(fetchUser(-1)).rejects.toThrow("Invalid user ID"); // => Expect rejection
    // => Promise should reject with specific error message
  });
});

test("processData handles errors gracefully", async () => {
  // => Test error handling
  const result = await processData("invalid"); // => FAILS: processData not defined
  // => Function doesn't exist yet
  expect(result).toEqual({ success: false, error: "Invalid data" }); // => Expected error response
  // => Should return error object
});

async function processData(data: string): Promise<{ success: boolean; error?: string }> {
  // => Async with error handling
  try {
    // => Try block
    // => Attempt operation
    if (data === "invalid") {
      // => Validate input
      throw new Error("Invalid data"); // => Simulated error
      // => Throws to trigger catch block
    }
    return { success: true }; // => Success case
    // => Returns success object
  } catch (error) {
    // => Catch block
    // => Handles any errors from try block
    return { success: false, error: (error as Error).message }; // => Error response
    // => Converts error to result object
  }
}
 
test("processData returns success for valid data", async () => {
  // => Success path
  const result = await processData("valid"); // => Call with valid input
  // => Should execute try block successfully
  expect(result).toEqual({ success: true }); // => Verify success
  // => No error field present
});
 
test("processData handles errors gracefully", async () => {
  // => Error path
  const result = await processData("invalid"); // => Call with invalid input
  // => Triggers error in try block
  expect(result).toEqual({ success: false, error: "Invalid data" }); // => Verify error handling
  // => Returns structured error response
});

async function fetchAndProcess(id: number): Promise<{ data: string; processed: boolean }> {
  // => Multi-step async
  const response = await fetch(`/api/data/${id}`); // => Async operation 1
  // => HTTP request to API
  const rawData = await response.json(); // => Async operation 2
  // => Parse JSON response
 
  if (!rawData.valid) {
    // => Validate response
    throw new Error("Invalid response"); // => Reject invalid data
    // => Error handling for bad response
  }
 
  return { data: rawData.content, processed: true }; // => Combined result
  // => Returns processed data object
}
 
test("fetchAndProcess chains async operations", async () => {
  // => Test chained async
  // Mock global fetch
  global.fetch = jest.fn(() =>
    // => Create mock fetch
    // => Returns mock promise
    Promise.resolve({
      // => Mock Response object
      json: () => Promise.resolve({ valid: true, content: "test data" }), // => Mock JSON method
      // => Returns promise with mock data
    }),
  ) as jest.Mock;
  // => Type assertion for Jest mock
 
  const result = await fetchAndProcess(1); // => Execute function
  // => Calls mocked fetch
 
  expect(result).toEqual({ data: "test data", processed: true }); // => Verify result
  // => Check processed output
  expect(fetch).toHaveBeenCalledWith("/api/data/1"); // => Verify fetch called
  // => Assert correct URL used
});

test("readFile calls callback with data", (done) => {
  // => done parameter for async test
  // => Jest provides done callback for async tests
  readFile("data.txt", (error, data) => {
    // => Call function with callback
    // => FAILS: readFile not defined
    // => Function doesn't exist yet
    expect(error).toBeNull(); // => Expect no error
    expect(data).toBe("file contents"); // => Expect data
    done(); // => Signal test completion
    // => MUST call done() for async tests
  });
});

function readFile(path: string, callback: (error: Error | null, data: string | null) => void): void {
  // => Callback signature
  // => Function takes path and callback
  // => Callback follows Node.js error-first pattern
  if (path.includes("error")) {
    // => Simulate error condition
    callback(new Error("File not found"), null); // => Error case
    // => Calls callback with error, null data
  } else {
    // => Success path
    callback(null, "file contents"); // => Success case
    // => Calls callback with null error, data
  }
}
 
test("readFile calls callback with data", (done) => {
  // => Async test
  readFile("data.txt", (error, data) => {
    // => Execute function
    // => Callback invoked with results
    expect(error).toBeNull(); // => No error
    // => Error parameter is null
    expect(data).toBe("file contents"); // => Has data
    // => Data parameter contains content
    done(); // => Must call done() to pass
    // => Signals async test completion
  });
});

describe("readFile", () => {
  // => Test suite
  test("calls callback with data on success", (done) => {
    // => Success path
    readFile("data.txt", (error, data) => {
      // => Valid path
      // => Callback receives success result
      expect(error).toBeNull(); // => No error occurred
      expect(data).toBe("file contents"); // => Data returned
      done(); // => Signal completion
      // => Test passes when done() called
    });
  });
 
  test("calls callback with error on failure", (done) => {
    // => Error path
    readFile("error.txt", (error, data) => {
      // => Error path triggers
      // => Callback receives error result
      expect(error).toBeInstanceOf(Error); // => Has error
      // => Error object passed
      expect(error?.message).toBe("File not found"); // => Correct error message
      expect(data).toBeNull(); // => No data
      // => Data is null on error
      done(); // => Complete test
    });
  });
 
  test("handles callback errors properly", (done) => {
    // => Test error handling
    readFile("data.txt", (error, data) => {
      // => Execute operation
      try {
        // => Wrap assertions in try
        // => Catch assertion failures
        expect(data).toBe("file contents"); // => Assertion
        // => Verify data content
        done(); // => Success path
        // => Test passes
      } catch (assertionError) {
        // => Handle assertion failure
        done(assertionError); // => Fail test with assertion error
        // => Pass error to done() to fail test
      }
    });
  });
});

test("debounce delays function call", (done) => {
  // => Async test with done
  // => FAILS: debounce not defined
  // => Function doesn't exist yet
  let called = false; // => Track if function called
  const fn = debounce(() => {
    // => Create debounced function
    // => FAILS - debounce undefined
    called = true; // => Mark as called
  }, 1000); // => 1 second delay
  // => Delays execution by 1000ms
 
  fn(); // => Execute debounced function
  // => Starts timer
  setTimeout(() => {
    // => Check after delay
    // => Wait for debounce to complete
    expect(called).toBe(true); // => Should be called
    done(); // => Test takes 1+ seconds
    // => SLOW - real timer delays test
  }, 1100);
  // => Must wait full delay + buffer
});

function debounce(fn: () => void, delay: number): () => void {
  // => Debounce function
  // => Returns debounced version of fn
  let timeoutId: NodeJS.Timeout | null = null; // => Timer reference
  // => Stores current timeout ID
 
  return () => {
    // => Returned function
    // => Wraps original function
    if (timeoutId) clearTimeout(timeoutId); // => Clear existing timer
    // => Cancel previous timer if exists
    timeoutId = setTimeout(fn, delay); // => Set new timer
    // => Schedule function execution
  };
}
 
describe("debounce", () => {
  // => Test suite
  beforeEach(() => {
    // => Setup before each test
    jest.useFakeTimers(); // => Enable fake timers
    // => Replace real timers with fake ones
  });
 
  afterEach(() => {
    // => Cleanup after each test
    jest.useRealTimers(); // => Restore real timers
    // => Reset to normal timers
  });
 
  test("delays function call by specified time", () => {
    // => Test delay
    let called = false; // => Track execution
    const fn = debounce(() => {
      // => Create debounced fn
      called = true; // => Mark called
    }, 1000); // => 1 second delay
 
    fn(); // => Schedule call
    // => Starts fake timer
    expect(called).toBe(false); // => Not called immediately
    // => Function delayed
 
    jest.advanceTimersByTime(999); // => Fast-forward 999ms
    // => Jump forward in fake time
    expect(called).toBe(false); // => Still not called
    // => Delay not yet complete
 
    jest.advanceTimersByTime(1); // => Fast-forward 1ms (total 1000ms)
    // => Complete the delay
    expect(called).toBe(true); // => Now called
    // => Function executed after full delay
  }); // => Test runs instantly
  // => No real waiting - fake timers
 
  test("cancels previous timer on rapid calls", () => {
    // => Test cancellation
    let callCount = 0; // => Track call count
    const fn = debounce(() => {
      // => Debounced counter
      callCount++; // => Increment on call
    }, 1000); // => 1 second delay
 
    fn(); // => First call
    // => Sets first timer
    jest.advanceTimersByTime(500); // => Advance 500ms
    fn(); // => Second call (cancels first)
    // => Clears first timer, sets new one
    jest.advanceTimersByTime(500); // => Advance another 500ms
    // => Total 500ms since second call
    expect(callCount).toBe(0); // => Neither fired yet
    // => Second timer not complete
 
    jest.advanceTimersByTime(500); // => Complete second delay
    // => Total 1000ms since second call
    expect(callCount).toBe(1); // => Only second call executed
    // => First call was cancelled
  });
});

test("fetchUserData retrieves user from API", async () => {
  // => Test async HTTP
  // => FAILS: fetchUserData not defined
  // => Function doesn't exist yet
  const user = await fetchUserData(1); // => Call function
  // => Await async HTTP call
  expect(user.name).toBe("Alice"); // => Expected result
  // => Should return user object
});

async function fetchUserData(id: number): Promise<{ id: number; name: string }> {
  // => Async HTTP function
  const response = await fetch(`/api/users/${id}`); // => HTTP call
  // => Makes GET request to API
  return response.json(); // => Parse JSON
  // => Returns parsed response body
}
 
describe("fetchUserData", () => {
  // => Test suite
  beforeEach(() => {
    // => Setup before each test
    global.fetch = jest.fn(); // => Mock fetch globally
    // => Replace global fetch with Jest mock
  });
 
  afterEach(() => {
    // => Cleanup after each test
    jest.restoreAllMocks(); // => Clean up mocks
    // => Restore original fetch
  });
 
  test("retrieves user data from API", async () => {
    // => Test success path
    (global.fetch as jest.Mock).mockResolvedValue({
      // => Mock response
      // => Setup mock to return resolved promise
      json: async () => ({ id: 1, name: "Alice" }), // => Mock JSON method
      // => Returns user data
    });
 
    const user = await fetchUserData(1); // => Execute function
    // => Calls mocked fetch
 
    expect(user).toEqual({ id: 1, name: "Alice" }); // => Verify result
    // => Check returned user data
    expect(fetch).toHaveBeenCalledWith("/api/users/1"); // => Verify URL
    // => Assert correct endpoint called
  });
 
  test("handles API errors", async () => {
    // => Test error handling
    (global.fetch as jest.Mock).mockRejectedValue(new Error("Network error")); // => Mock error
    // => Setup fetch to reject with error
 
    await expect(fetchUserData(1)).rejects.toThrow("Network error"); // => Expect rejection
    // => Promise should reject with error
  });
});

interface HttpClient {
  // => HTTP client interface
  get(url: string): Promise<any>; // => GET method signature
  // => Returns promise with response
}
 
class FetchHttpClient implements HttpClient {
  // => Real HTTP client
  async get(url: string): Promise<any> {
    // => Real implementation
    const response = await fetch(url); // => Real fetch
    // => Makes actual HTTP request
    return response.json(); // => Parse response
    // => Returns JSON data
  }
}
 
class MockHttpClient implements HttpClient {
  // => Mock HTTP client
  responses: Map<string, any> = new Map(); // => Predefined responses
  // => Stores URL → response mappings
 
  async get(url: string): Promise<any> {
    // => Mock GET method
    if (this.responses.has(url)) {
      // => Check for mock response
      return this.responses.get(url); // => Return mock data
      // => Returns predefined response
    }
    throw new Error(`No mock response for ${url}`); // => Error if unmocked
    // => Fails test if URL not mocked
  }
}
 
class UserService {
  // => Service using HTTP client
  constructor(private http: HttpClient) {} // => Inject HTTP client
  // => Dependency injection for testability
 
  async fetchUserData(id: number): Promise<{ id: number; name: string }> {
    // => Fetch user
    return this.http.get(`/api/users/${id}`); // => Delegate to HTTP client
    // => Uses injected client
  }
}
 
test("fetchUserData uses HTTP client", async () => {
  // => Test with DI
  const mockHttp = new MockHttpClient(); // => Create mock
  // => Instantiate mock HTTP client
  mockHttp.responses.set("/api/users/1", { id: 1, name: "Alice" }); // => Setup response
  // => Configure mock for specific URL
 
  const userService = new UserService(mockHttp); // => Inject mock
  // => Pass mock to service
  const user = await userService.fetchUserData(1); // => Call method
  // => Uses mocked HTTP client
 
  expect(user).toEqual({ id: 1, name: "Alice" }); // => Verify result
  // => Check user data returned correctly
});

test("saveUser persists user to database", async () => {
  // => Test persistence
  const userRepo = new UserRepository(); // => FAILS: needs database
  // => UserRepository requires database connection
  await userRepo.save({ name: "Alice", email: "alice@example.com" }); // => Save user
  // => Attempts to persist to database
  const users = await userRepo.findAll(); // => Retrieve all users
  // => Query database for users
  expect(users).toHaveLength(1); // => Verify saved
  // => Test fails - no database available
});

interface User {
  // => User entity
  id?: number; // => Optional ID (generated on save)
  name: string; // => User name
  email: string; // => Email address
}
 
class InMemoryUserRepository {
  // => In-memory implementation
  // => Simulates database without I/O
  private users: User[] = []; // => In-memory storage
  // => Array stores all users
  private nextId = 1; // => ID counter
  // => Auto-increment ID generator
 
  async save(user: User): Promise<User> {
    // => Save operation
    const savedUser = { ...user, id: this.nextId++ }; // => Add ID
    // => Spread user and add generated ID
    this.users.push(savedUser); // => Store in memory
    // => Add to array
    return savedUser; // => Return saved user
    // => Includes generated ID
  }
 
  async findAll(): Promise<User[]> {
    // => Query all users
    return [...this.users]; // => Return copy
    // => Defensive copy prevents mutation
  }
 
  async findById(id: number): Promise<User | null> {
    // => Find by ID
    return this.users.find((u) => u.id === id) || null; // => Search array
    // => Returns user or null if not found
  }
 
  async deleteAll(): Promise<void> {
    // => Clear database
    this.users = []; // => Clear storage
    // => Empty array
    this.nextId = 1; // => Reset ID counter
    // => Start from 1 again
  }
}
 
describe("UserRepository", () => {
  // => Test suite
  let userRepo: InMemoryUserRepository; // => Repository instance
  // => Declare test-scoped variable
 
  beforeEach(() => {
    // => Setup before each test
    userRepo = new InMemoryUserRepository(); // => Fresh repository
    // => New instance for test isolation
  });
 
  test("saveUser persists user", async () => {
    // => Test save
    await userRepo.save({ name: "Alice", email: "alice@example.com" }); // => Save user
    // => Persist to in-memory storage
    const users = await userRepo.findAll(); // => Retrieve all
    // => Query stored users
 
    expect(users).toHaveLength(1); // => Verify count
    // => One user saved
    expect(users[0].name).toBe("Alice"); // => Verify data
    // => Name persisted correctly
  });
 
  test("findById retrieves correct user", async () => {
    // => Test query by ID
    const saved = await userRepo.save({ name: "Alice", email: "alice@example.com" }); // => Save user
    // => Returns user with generated ID
    const found = await userRepo.findById(saved.id!); // => Find by ID
    // => Query using generated ID
 
    expect(found).toEqual(saved); // => Verify match
    // => Retrieved user matches saved user
  });
 
  test("multiple saves maintain data", async () => {
    // => Test multiple saves
    await userRepo.save({ name: "Alice", email: "alice@example.com" }); // => Save first
    // => Persist Alice
    await userRepo.save({ name: "Bob", email: "bob@example.com" }); // => Save second
    // => Persist Bob
 
    const users = await userRepo.findAll(); // => Retrieve all
    // => Query all saved users
    expect(users).toHaveLength(2); // => Verify count
    // => Both users persisted
  });
});

test("reverse reverses strings", () => {
  // => Traditional test
  expect(reverse("hello")).toBe("olleh"); // => FAILS: reverse not defined
  // => Function doesn't exist yet
  expect(reverse("world")).toBe("dlrow"); // => Second example
  // => Tests another case
});

function reverse(str: string): string {
  // => Reverse function
  return str.split("").reverse().join(""); // => Split, reverse, join
  // => Converts to array, reverses, converts back
}

import fc from "fast-check"; // => Property-based testing library
// => fast-check generates random test data
 
describe("reverse", () => {
  // => Test suite
  test("reversing twice returns original", () => {
    // => Idempotence property
    fc.assert(
      // => Property assertion
      // => Runs property check with generated inputs
      fc.property(
        // => Define property
        fc.string(), // => Generate random strings
        // => Creates arbitrary string values
        (str) => {
          // => Property function
          const reversed = reverse(reverse(str)); // => Reverse twice
          // => Apply function twice
          return reversed === str; // => Property: equals original
          // => Reversing twice should restore original
        },
      ),
    ); // => Tests 100+ random strings
    // => Default runs 100 test cases
  });
 
  test("length is preserved", () => {
    // => Length invariant
    fc.assert(
      // => Assert property
      fc.property(fc.string(), (str) => {
        // => Generate and test
        // => For each random string
        const reversed = reverse(str); // => Reverse string
        // => Apply function
        return reversed.length === str.length; // => Length property
        // => Length must be preserved
      }),
    );
  });
 
  test("first char becomes last char", () => {
    // => Position property
    fc.assert(
      // => Property check
      fc.property(
        // => Define property
        fc.string({ minLength: 1 }), // => Non-empty strings
        // => Generate strings with at least 1 character
        (str) => {
          // => Test function
          const reversed = reverse(str); // => Reverse string
          // => Apply reversal
          return str[0] === reversed[reversed.length - 1]; // => Position property
          // => First char should become last char
        },
      ),
    );
  });
});

test("calculateDiscount applies discount", () => {
  const result = calculateDiscount(100, 0.1); // => FAILS: calculateDiscount not defined
  expect(result).toBeDefined(); // => WEAK: Only checks defined
});

function calculateDiscount(price: number, rate: number): number {
  return price - price * rate; // => Correct implementation
  // => Calculates: 100 - (100 * 0.1) = 90
}
 
test("calculateDiscount applies discount", () => {
  const result = calculateDiscount(100, 0.1); // => Calls function
  // => result is 90 (type: number)
  expect(result).toBeDefined(); // => Passes but doesn't verify correctness
  // => Weak: doesn't check if value is correct
});

function calculateDiscount(price: number, rate: number): number {
  return price; // => MUTATION: Removed discount calculation
  // => Now returns 100 instead of 90 (BUG!)
} // => Weak test doesn't catch this bug!
 
test("calculateDiscount applies discount", () => {
  const result = calculateDiscount(100, 0.1); // => Calls buggy function
  // => result is 100 (wrong but defined)
  expect(result).toBeDefined(); // => Still passes! (mutation survived)
  // => Test passes despite broken logic
});

describe("calculateDiscount", () => {
  test("applies correct discount percentage", () => {
    const result = calculateDiscount(100, 0.1); // => Calls with 10% discount
    // => result is 90 (100 - 10)
    expect(result).toBe(90); // => STRONG: Verifies exact value
    // => Would fail if mutation returns 100
  }); // => Would catch discount removal
 
  test("applies different discount rates", () => {
    expect(calculateDiscount(100, 0.2)).toBe(80); // => 20% discount: 100 - 20 = 80
    expect(calculateDiscount(100, 0.5)).toBe(50); // => 50% discount: 100 - 50 = 50
  }); // => Multiple assertions increase mutation detection
  // => Mutation changing formula would fail at least one
 
  test("handles zero discount", () => {
    expect(calculateDiscount(100, 0)).toBe(100); // => Edge case: 0% discount
    // => 100 - 0 = 100 (no change)
  });
 
  test("handles full discount", () => {
    expect(calculateDiscount(100, 1)).toBe(0); // => Another edge: 100% discount
    // => 100 - 100 = 0 (free)
  });
});
 
function calculateDiscount(price: number, rate: number): number {
  return price - price * rate; // => Correct implementation
  // => Formula: price - (price × rate)
}

function processPayment(amount: number, method: string): string {
  // => FAILS: processPayment not fully covered
  // => Function parameters: amount (number), method (string)
  if (amount < 0) {
    // => Validation check
    throw new Error("Invalid amount"); // => Edge case not tested
    // => Coverage gap: error path untested
  }
 
  if (method === "credit") {
    // => First payment type check
    return "Processed via credit card"; // => Happy path tested
  } else if (method === "debit") {
    // => Second payment type check
    return "Processed via debit card"; // => Not tested (coverage gap)
  }
 
  return "Unknown payment method"; // => Not tested (coverage gap)
  // => Default fallback path
}
 
test("processPayment handles credit cards", () => {
  expect(processPayment(100, "credit")).toBe("Processed via credit card");
  // => Calls with amount=100, method="credit"
  // => Only tests happy path
}); // => Only covers one path
// => Coverage: ~25% of branches

describe("processPayment", () => {
  test("processes credit card payments", () => {
    expect(processPayment(100, "credit")).toBe("Processed via credit card");
    // => Tests credit card path
    // => amount=100 (valid), method="credit"
  }); // => Covers credit path
  // => Branch coverage: if (method === "credit")
 
  test("processes debit card payments", () => {
    expect(processPayment(100, "debit")).toBe("Processed via debit card");
    // => Tests debit card path
    // => amount=100 (valid), method="debit"
  }); // => Covers debit path
  // => Branch coverage: else if (method === "debit")
 
  test("handles unknown payment methods", () => {
    expect(processPayment(100, "cash")).toBe("Unknown payment method");
    // => Tests fallback path
    // => amount=100 (valid), method="cash" (unknown)
  }); // => Covers default path
  // => Branch coverage: default return
 
  test("rejects negative amounts", () => {
    expect(() => processPayment(-10, "credit")).toThrow("Invalid amount");
    // => Tests validation path
    // => amount=-10 (invalid), expects Error
  }); // => Covers error path
  // => Branch coverage: if (amount < 0)
}); // => 100% coverage achieved
// => All 4 branches tested

// Coverage metrics:
// Line coverage: 100% (all lines executed)
// Branch coverage: 100% (all if/else paths taken)
// Function coverage: 100% (function called)
// Statement coverage: 100% (all statements run)
 
// But coverage doesn't catch logic errors:
test("high coverage doesn't guarantee correctness", () => {
  function add(a: number, b: number): number {
    return a * b; // => BUG: Multiply instead of add
  } // => Tests can achieve 100% coverage but be wrong
 
  expect(add(2, 3)).toBe(6); // => Wrong expectation (should be 5)
}); // => 100% coverage, 0% correctness

test("GET /users returns user list", async () => {
  // => FAILS: App not defined
  const response = await request(app).get("/users");
  expect(response.status).toBe(200);
  expect(response.body).toHaveLength(2);
});

import express from "express";
import request from "supertest";
 
const app = express();
 
const users = [
  // => In-memory data
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
];
 
app.get("/users", (req, res) => {
  // => Route handler
  res.json(users); // => Return JSON
});
 
describe("GET /users", () => {
  test("returns user list", async () => {
    const response = await request(app).get("/users"); // => Supertest request
 
    expect(response.status).toBe(200); // => Verify status code
    expect(response.body).toEqual([
      // => Verify response body
      { id: 1, name: "Alice" },
      { id: 2, name: "Bob" },
    ]);
  });
});

app.use(express.json()); // => Enable JSON parsing
 
app.post("/users", (req, res) => {
  const { name } = req.body;
 
  if (!name || name.trim().length === 0) {
    // => Validation
    return res.status(400).json({ error: "Name is required" });
  }
 
  const newUser = { id: users.length + 1, name };
  users.push(newUser);
  res.status(201).json(newUser); // => 201 Created
});
 
describe("POST /users", () => {
  test("creates user with valid data", async () => {
    const response = await request(app).post("/users").send({ name: "Charlie" }); // => POST with body
 
    expect(response.status).toBe(201);
    expect(response.body).toEqual({ id: 3, name: "Charlie" });
  });
 
  test("rejects request without name", async () => {
    const response = await request(app).post("/users").send({});
 
    expect(response.status).toBe(400);
    expect(response.body).toEqual({ error: "Name is required" });
  });
 
  test("rejects empty name", async () => {
    const response = await request(app).post("/users").send({ name: "   " });
 
    expect(response.status).toBe(400);
  });
});

test("Button renders with text", () => {
  // => FAILS: Button component not defined
  render(<Button>Click me</Button>);
  expect(screen.getByText("Click me")).toBeInTheDocument();
});

import React from "react";
import { render, screen, fireEvent } from "@testing-library/react";
 
interface ButtonProps {
  children: React.ReactNode;
  onClick?: () => void;
}
 
function Button({ children, onClick }: ButtonProps) {
  return <button onClick={onClick}>{children}</button>; // => Basic button
}
 
test("Button renders with text", () => {
  render(<Button>Click me</Button>); // => Render component
  expect(screen.getByText("Click me")).toBeInTheDocument(); // => Assert presence
});

describe("Button", () => {
  test("renders with provided text", () => {
    render(<Button>Click me</Button>);
    expect(screen.getByText("Click me")).toBeInTheDocument();
  });
 
  test("calls onClick handler when clicked", () => {
    const handleClick = jest.fn(); // => Mock function
    render(<Button onClick={handleClick}>Click me</Button>);
 
    fireEvent.click(screen.getByText("Click me")); // => Simulate click
 
    expect(handleClick).toHaveBeenCalledTimes(1); // => Verify call
  });
 
  test("calls onClick multiple times", () => {
    const handleClick = jest.fn();
    render(<Button onClick={handleClick}>Click me</Button>);
 
    const button = screen.getByText("Click me");
    fireEvent.click(button); // => First click
    fireEvent.click(button); // => Second click
 
    expect(handleClick).toHaveBeenCalledTimes(2);
  });
 
  test("renders without onClick handler", () => {
    render(<Button>Click me</Button>); // => No onClick prop
    const button = screen.getByText("Click me");
    fireEvent.click(button); // => Should not throw
  });
});

test("OrderProcessor emits orderPlaced event", () => {
  const processor = new OrderProcessor(); // => FAILS: OrderProcessor not defined
  const listener = jest.fn();
 
  processor.on("orderPlaced", listener);
  processor.placeOrder({ id: 1, total: 100 });
 
  expect(listener).toHaveBeenCalledWith({ id: 1, total: 100 });
});

import { EventEmitter } from "events";
 
interface Order {
  id: number;
  total: number;
}
 
class OrderProcessor extends EventEmitter {
  placeOrder(order: Order): void {
    // Order processing logic
    this.emit("orderPlaced", order); // => Emit event
  }
}
 
test("OrderProcessor emits orderPlaced event", () => {
  const processor = new OrderProcessor();
  const listener = jest.fn();
 
  processor.on("orderPlaced", listener); // => Register listener
  processor.placeOrder({ id: 1, total: 100 });
 
  expect(listener).toHaveBeenCalledWith({ id: 1, total: 100 });
});

class OrderProcessor extends EventEmitter {
  placeOrder(order: Order): void {
    this.emit("orderValidating", order); // => Event 1
    // Validation logic
    this.emit("orderPlaced", order); // => Event 2
  }
 
  cancelOrder(orderId: number): void {
    this.emit("orderCancelled", orderId); // => Different event
  }
}
 
describe("OrderProcessor events", () => {
  let processor: OrderProcessor;
 
  beforeEach(() => {
    processor = new OrderProcessor();
  });
 
  test("emits events in correct order", () => {
    const events: string[] = [];
 
    processor.on("orderValidating", () => events.push("validating"));
    processor.on("orderPlaced", () => events.push("placed"));
 
    processor.placeOrder({ id: 1, total: 100 });
 
    expect(events).toEqual(["validating", "placed"]); // => Verify order
  });
 
  test("passes correct data to listeners", () => {
    const validatingListener = jest.fn();
    const placedListener = jest.fn();
 
    processor.on("orderValidating", validatingListener);
    processor.on("orderPlaced", placedListener);
 
    const order = { id: 1, total: 100 };
    processor.placeOrder(order);
 
    expect(validatingListener).toHaveBeenCalledWith(order);
    expect(placedListener).toHaveBeenCalledWith(order);
  });
 
  test("supports multiple listeners", () => {
    const listener1 = jest.fn();
    const listener2 = jest.fn();
 
    processor.on("orderPlaced", listener1);
    processor.on("orderPlaced", listener2);
 
    processor.placeOrder({ id: 1, total: 100 });
 
    expect(listener1).toHaveBeenCalled();
    expect(listener2).toHaveBeenCalled(); // => Both called
  });
});

test("Document starts in Draft state", () => {
  const doc = new Document(); // => FAILS: Document not defined
  expect(doc.getState()).toBe("Draft");
});
 
test("Document can be published from Draft", () => {
  const doc = new Document();
  doc.publish();
  expect(doc.getState()).toBe("Published");
});

type DocumentState = "Draft" | "Published" | "Archived";
 
class Document {
  private state: DocumentState = "Draft"; // => Initial state
 
  getState(): DocumentState {
    return this.state;
  }
 
  publish(): void {
    if (this.state === "Draft") {
      // => Valid transition
      this.state = "Published";
    } else {
      throw new Error("Cannot publish from " + this.state);
    }
  }
 
  archive(): void {
    if (this.state === "Published") {
      this.state = "Archived";
    } else {
      throw new Error("Cannot archive from " + this.state);
    }
  }
 
  restore(): void {
    if (this.state === "Archived") {
      this.state = "Draft";
    } else {
      throw new Error("Cannot restore from " + this.state);
    }
  }
}
 
describe("Document state machine", () => {
  test("starts in Draft state", () => {
    const doc = new Document();
    expect(doc.getState()).toBe("Draft");
  });
 
  test("transitions Draft -> Published", () => {
    const doc = new Document();
    doc.publish();
    expect(doc.getState()).toBe("Published");
  });
 
  test("transitions Published -> Archived", () => {
    const doc = new Document();
    doc.publish();
    doc.archive();
    expect(doc.getState()).toBe("Archived");
  });
 
  test("transitions Archived -> Draft (restore)", () => {
    const doc = new Document();
    doc.publish();
    doc.archive();
    doc.restore();
    expect(doc.getState()).toBe("Draft");
  });
 
  test("rejects invalid transition (Archive from Draft)", () => {
    const doc = new Document();
    expect(() => doc.archive()).toThrow("Cannot archive from Draft");
  });
 
  test("rejects invalid transition (Restore from Draft)", () => {
    const doc = new Document();
    expect(() => doc.restore()).toThrow("Cannot restore from Draft");
  });
});

test("isEven returns true for 2", () => {
  expect(isEven(2)).toBe(true); // => FAILS: isEven not defined
});
 
test("isEven returns true for 4", () => {
  expect(isEven(4)).toBe(true);
});
 
test("isEven returns false for 1", () => {
  expect(isEven(1)).toBe(false);
});
 
test("isEven returns false for 3", () => {
  expect(isEven(3)).toBe(false);
});

function isEven(n: number): boolean {
  return n % 2 === 0;
}
 
describe("isEven", () => {
  test.each([
    // => Parameterized test table
    [2, true], // => [input, expected]
    [4, true],
    [6, true],
    [0, true],
    [1, false],
    [3, false],
    [5, false],
  ])("isEven(%i) returns %s", (input, expected) => {
    // => Test name template
    expect(isEven(input)).toBe(expected); // => Same assertion, different data
  });
});

describe("isEven edge cases", () => {
  test.each([
    { input: -2, expected: true, description: "negative even" },
    { input: -1, expected: false, description: "negative odd" },
    { input: 0, expected: true, description: "zero" },
  ])("$description: isEven($input) = $expected", ({ input, expected }) => {
    expect(isEven(input)).toBe(expected);
  });
});
 
describe("FizzBuzz with parameterized tests", () => {
  test.each([
    { input: 15, expected: "FizzBuzz", reason: "divisible by 3 and 5" },
    { input: 3, expected: "Fizz", reason: "divisible by 3" },
    { input: 5, expected: "Buzz", reason: "divisible by 5" },
    { input: 1, expected: "1", reason: "not divisible" },
  ])("$reason: fizzBuzz($input) = $expected", ({ input, expected }) => {
    function fizzBuzz(n: number): string {
      if (n % 15 === 0) return "FizzBuzz";
      if (n % 3 === 0) return "Fizz";
      if (n % 5 === 0) return "Buzz";
      return String(n);
    }
 
    expect(fizzBuzz(input)).toBe(expected);
  });
});

test("UserCard renders user information", () => {
  const user = { name: "Alice", email: "alice@example.com" }; // => Test data
  const { container } = render(<UserCard user={user} />); // => FAILS: UserCard not defined
  expect(container).toMatchSnapshot(); // => Snapshot assertion
});

interface User {
  name: string;
  email: string;
}
 
function UserCard({ user }: { user: User }) {
  return (
    <div className="user-card">
      {" "}
      {/* => Component structure */}
      <h2>{user.name}</h2>
      <p>{user.email}</p>
    </div>
  );
}
 
test("UserCard renders user information", () => {
  const user = { name: "Alice", email: "alice@example.com" };
  const { container } = render(<UserCard user={user} />);
  expect(container).toMatchSnapshot(); // => Creates snapshot file
});
 
// Generated snapshot (in __snapshots__ folder):
// exports[`UserCard renders user information 1`] = `
// <div>
//   <div class="user-card">
//     <h2>Alice</h2>
//     <p>alice@example.com</p>
//   </div>
// </div>
// `;

describe("Snapshot testing appropriate use cases", () => {
  test("captures complex JSON structure", () => {
    const apiResponse = {
      // => Complex output
      data: {
        users: [
          { id: 1, name: "Alice", roles: ["admin", "user"] },
          { id: 2, name: "Bob", roles: ["user"] },
        ],
        meta: { total: 2, page: 1 },
      },
    };
 
    expect(apiResponse).toMatchSnapshot(); // => Good use: complex structure
  });
 
  test("AVOID: simple values better with explicit assertions", () => {
    const sum = 2 + 2;
    expect(sum).toBe(4); // => GOOD: Explicit assertion
    // expect(sum).toMatchSnapshot(); // => BAD: Snapshot overkill
  });
 
  test("AVOID: snapshots for business logic", () => {
    function calculateDiscount(price: number): number {
      return price * 0.9; // => Business logic
    }
 
    expect(calculateDiscount(100)).toBe(90); // => GOOD: Explicit value
    // expect(calculateDiscount(100)).toMatchSnapshot(); // => BAD: Hides expected value
  });
});

test("saveData writes JSON to file", async () => {
  // => FAILS: saveData not defined
  await saveData("test.json", { name: "Alice" });
  const content = await readData("test.json");
  expect(content).toEqual({ name: "Alice" });
});

import fs from "fs/promises";
 
jest.mock("fs/promises"); // => Mock fs module
 
async function saveData(path: string, data: any): Promise<void> {
  await fs.writeFile(path, JSON.stringify(data, null, 2));
}
 
async function readData(path: string): Promise<any> {
  const content = await fs.readFile(path, "utf-8");
  return JSON.parse(content);
}
 
describe("File operations", () => {
  beforeEach(() => {
    jest.clearAllMocks(); // => Reset mocks
  });
 
  test("saveData writes JSON to file", async () => {
    (fs.writeFile as jest.Mock).mockResolvedValue(undefined); // => Mock write
    (fs.readFile as jest.Mock).mockResolvedValue('{"name":"Alice"}'); // => Mock read
 
    await saveData("test.json", { name: "Alice" });
    const content = await readData("test.json");
 
    expect(content).toEqual({ name: "Alice" });
    expect(fs.writeFile).toHaveBeenCalledWith("test.json", '{\n  "name": "Alice"\n}');
  });
 
  test("readData handles missing files", async () => {
    (fs.readFile as jest.Mock).mockRejectedValue(new Error("ENOENT: file not found"));
 
    await expect(readData("missing.json")).rejects.toThrow("ENOENT");
  });
});

class FakeFileSystem {
  private files: Map<string, string> = new Map(); // => In-memory storage
 
  async writeFile(path: string, content: string): Promise<void> {
    this.files.set(path, content); // => Store in memory
  }
 
  async readFile(path: string): Promise<string> {
    const content = this.files.get(path);
    if (!content) {
      throw new Error(`ENOENT: ${path} not found`);
    }
    return content;
  }
 
  reset(): void {
    this.files.clear();
  }
}
 
class DataStore {
  constructor(private fs: FakeFileSystem) {}
 
  async save(path: string, data: any): Promise<void> {
    await this.fs.writeFile(path, JSON.stringify(data));
  }
 
  async load(path: string): Promise<any> {
    const content = await this.fs.readFile(path);
    return JSON.parse(content);
  }
}
 
describe("DataStore with fake filesystem", () => {
  let fakeFs: FakeFileSystem;
  let store: DataStore;
 
  beforeEach(() => {
    fakeFs = new FakeFileSystem();
    store = new DataStore(fakeFs);
  });
 
  test("saves and loads data", async () => {
    await store.save("data.json", { name: "Alice" });
    const loaded = await store.load("data.json");
 
    expect(loaded).toEqual({ name: "Alice" });
  });
 
  test("handles non-existent files", async () => {
    await expect(store.load("missing.json")).rejects.toThrow("ENOENT");
  });
});