reverse-engineering-anything/src/browser/PlaywrightExecutionBoundary.test.ts

import { afterEach, describe, expect, it, vi } from "vitest";

import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
import {
  AnalysisCancelledError,
  AnalysisTimeoutError,
} from "../domain/analysisErrorCore.js";

describe("withPlaywrightExecutionBoundary", () => {
  afterEach(() => {
    vi.useRealTimers();
    vi.restoreAllMocks();
  });

  it("rejects work that exceeds its absolute remaining duration", async () => {
    vi.useFakeTimers();
    const result = withPlaywrightExecutionBoundary(
      () => new Promise<never>(() => undefined),
      25,
    );
    const rejection =
      expect(result).rejects.toBeInstanceOf(AnalysisTimeoutError);
    await vi.advanceTimersByTimeAsync(25);
    await rejection;
  });

  it("rejects when the caller cancels active work", async () => {
    const controller = new AbortController();
    const result = withPlaywrightExecutionBoundary(
      () => new Promise<never>(() => undefined),
      1_000,
      controller.signal,
    );
    controller.abort();
    await expect(result).rejects.toBeInstanceOf(AnalysisCancelledError);
  });

  it("keeps its timeout stable across a wall-clock jump", async () => {
    vi.spyOn(Date, "now")
      .mockReturnValueOnce(1_000)
      .mockReturnValue(10_000_000);

    await expect(
      withPlaywrightExecutionBoundary(
        () =>
          new Promise<string>((resolve) =>
            setTimeout(() => resolve("done"), 5),
          ),
        1_000,
      ),
    ).resolves.toBe("done");
  });
});