fix: make RefreshController tests bun-compatible

Change-Id: I73e70a106d775fe476864725b484c74a210e0775
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: ThomasK33

src/browser/utils/RefreshController.test.ts

@@ -1,50 +1,49 @@
-import { describe, it, expect, beforeEach, afterEach, jest } from "bun:test";
-import { RefreshController } from "./RefreshController";
+import { describe, it, expect, mock } from "bun:test";
 
-describe("RefreshController", () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
+import { RefreshController, type LastRefreshInfo } from "./RefreshController";
 
-  afterEach(() => {
-    jest.useRealTimers();
-  });
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
-  it("rate-limits multiple schedule() calls (doesn't reset timer)", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+// NOTE: Bun's Jest-compat layer does not currently expose timer controls like
+// jest.advanceTimersByTime(), so these tests use real timers.
+
+describe("RefreshController", () => {
+  it("rate-limits multiple schedule() calls (doesn't reset timer)", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     controller.schedule();
-    jest.advanceTimersByTime(50);
+    await sleep(10);
     controller.schedule(); // Shouldn't reset timer
-    jest.advanceTimersByTime(50);
 
-    // Should fire at 100ms from first call, not 150ms
+    await sleep(40);
+
+    // Should fire ~20ms after first call, not ~30ms after second.
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
   });
 
-  it("coalesces calls during rate-limit window", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+  it("coalesces calls during rate-limit window", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     controller.schedule();
     controller.schedule();
     controller.schedule();
 
     expect(onRefresh).not.toHaveBeenCalled();
 
-    jest.advanceTimersByTime(100);
+    await sleep(60);
 
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
   });
 
-  it("requestImmediate() bypasses rate-limit timer", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+  it("requestImmediate() bypasses rate-limit timer", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({ onRefresh, debounceMs: 50 });
 
     controller.schedule();
     expect(onRefresh).not.toHaveBeenCalled();
@@ -53,7 +52,7 @@ describe("RefreshController", () => {
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     // Original timer should be cleared
-    jest.advanceTimersByTime(100);
+    await sleep(80);
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
@@ -62,17 +61,14 @@ describe("RefreshController", () => {
   it("guards against concurrent sync refreshes (in-flight queuing)", () => {
     // Track if refresh is currently in-flight
     let inFlight = false;
-    const onRefresh = jest.fn(() => {
-      // Simulate sync operation that takes time
+    const onRefresh = mock(() => {
       expect(inFlight).toBe(false); // Should never be called while already in-flight
       inFlight = true;
-      // Immediately complete (sync)
       inFlight = false;
     });
 
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
-    // Multiple immediate requests should only call once (queued ones execute after)
     controller.requestImmediate();
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
@@ -81,169 +77,170 @@ describe("RefreshController", () => {
 
   it("schedule() during in-flight queues refresh for after completion", async () => {
     let resolveRefresh: () => void;
-    const onRefresh = jest.fn(
+    const onRefresh = mock(
       () =>
         new Promise<void>((resolve) => {
           resolveRefresh = resolve;
         })
     );
 
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
-    // Start first refresh
     controller.requestImmediate();
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
-    // schedule() while in-flight should queue, not start timer
+    // schedule() while in-flight should queue for after completion.
     controller.schedule();
 
-    // Complete the first refresh and let .finally() run
     resolveRefresh!();
     await Promise.resolve();
-    await Promise.resolve(); // Extra tick for .finally()
 
-    // Should trigger follow-up refresh, but never more frequently than the minimum interval.
-    // First tick runs the post-flight setTimeout(0), then we wait out the min interval.
-    jest.advanceTimersByTime(0);
-    jest.advanceTimersByTime(500);
+    // Follow-up refresh is subject to MIN_REFRESH_INTERVAL_MS (500ms).
+    await sleep(650);
+
     expect(onRefresh).toHaveBeenCalledTimes(2);
 
     controller.dispose();
   });
 
-  it("isRefreshing reflects in-flight state", () => {
+  it("isRefreshing reflects in-flight state", async () => {
     let resolveRefresh: () => void;
     const refreshPromise = new Promise<void>((resolve) => {
       resolveRefresh = resolve;
     });
 
-    const onRefresh = jest.fn(() => refreshPromise);
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+    const onRefresh = mock(() => refreshPromise);
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     expect(controller.isRefreshing).toBe(false);
 
     controller.requestImmediate();
     expect(controller.isRefreshing).toBe(true);
 
-    // Complete the promise
     resolveRefresh!();
+    await Promise.resolve();
+
+    expect(controller.isRefreshing).toBe(false);
 
     controller.dispose();
   });
 
-  it("dispose() cleans up debounce timer", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+  it("dispose() cleans up debounce timer", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     controller.schedule();
     controller.dispose();
 
-    jest.advanceTimersByTime(100);
+    await sleep(80);
 
     expect(onRefresh).not.toHaveBeenCalled();
   });
 
-  it("does not refresh after dispose", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+  it("does not refresh after dispose", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     controller.dispose();
     controller.schedule();
     controller.requestImmediate();
 
-    jest.advanceTimersByTime(100);
+    await sleep(80);
 
     expect(onRefresh).not.toHaveBeenCalled();
   });
 
-  it("requestImmediate() bypasses isPaused check (for manual refresh)", () => {
-    const onRefresh = jest.fn<() => void>();
+  it("requestImmediate() bypasses isPaused check (for manual refresh)", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
     const paused = true;
     const controller = new RefreshController({
       onRefresh,
-      debounceMs: 100,
+      debounceMs: 20,
       isPaused: () => paused,
     });
 
-    // schedule() should be blocked by isPaused
     controller.schedule();
-    jest.advanceTimersByTime(100);
+    await sleep(80);
     expect(onRefresh).not.toHaveBeenCalled();
 
-    // requestImmediate() should bypass isPaused (manual refresh)
     controller.requestImmediate();
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
   });
 
-  it("schedule() respects isPaused and flushes on notifyUnpaused", () => {
-    const onRefresh = jest.fn<() => void>();
+  it("schedule() respects isPaused and flushes on notifyUnpaused", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
     let paused = true;
     const controller = new RefreshController({
       onRefresh,
-      debounceMs: 100,
+      debounceMs: 20,
       isPaused: () => paused,
     });
 
-    // schedule() should queue but not execute while paused
     controller.schedule();
-    jest.advanceTimersByTime(100);
+    await sleep(80);
     expect(onRefresh).not.toHaveBeenCalled();
 
-    // Unpausing should flush the pending refresh
     paused = false;
     controller.notifyUnpaused();
+
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
   });
 
-  it("lastRefreshInfo tracks trigger and timestamp", () => {
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 100 });
+  it("lastRefreshInfo tracks trigger and timestamp", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const controller = new RefreshController({
+      onRefresh,
+      debounceMs: 20,
+      priorityDebounceMs: 20,
+    });
 
     expect(controller.lastRefreshInfo).toBeNull();
 
-    // Manual refresh should record "manual" trigger
     const beforeManual = Date.now();
     controller.requestImmediate();
+
+    expect(onRefresh).toHaveBeenCalledTimes(1);
     expect(controller.lastRefreshInfo).not.toBeNull();
     expect(controller.lastRefreshInfo!.trigger).toBe("manual");
     expect(controller.lastRefreshInfo!.timestamp).toBeGreaterThanOrEqual(beforeManual);
 
-    // Scheduled refresh should record "scheduled" trigger
     controller.schedule();
-    jest.advanceTimersByTime(500);
+    await sleep(650);
+    expect(onRefresh).toHaveBeenCalledTimes(2);
     expect(controller.lastRefreshInfo!.trigger).toBe("scheduled");
 
-    // Priority refresh should record "priority" trigger
     controller.schedulePriority();
-    jest.advanceTimersByTime(500);
+    await sleep(650);
+    expect(onRefresh).toHaveBeenCalledTimes(3);
     expect(controller.lastRefreshInfo!.trigger).toBe("priority");
 
     controller.dispose();
   });
 
-  it("onRefreshComplete callback is called with refresh info", () => {
-    const onRefresh = jest.fn<() => void>();
-    const onRefreshComplete = jest.fn<(info: { trigger: string; timestamp: number }) => void>();
+  it("onRefreshComplete callback is called with refresh info", async () => {
+    const onRefresh = mock<() => void>(() => undefined);
+    const onRefreshComplete = mock<(info: LastRefreshInfo) => void>(() => undefined);
     const controller = new RefreshController({
       onRefresh,
       onRefreshComplete,
-      debounceMs: 100,
+      debounceMs: 20,
     });
 
     expect(onRefreshComplete).not.toHaveBeenCalled();
 
     controller.requestImmediate();
     expect(onRefreshComplete).toHaveBeenCalledTimes(1);
     expect(onRefreshComplete).toHaveBeenCalledWith(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       expect.objectContaining({ trigger: "manual", timestamp: expect.any(Number) })
     );
 
     controller.schedule();
-    jest.advanceTimersByTime(500);
+    await sleep(650);
     expect(onRefreshComplete).toHaveBeenCalledTimes(2);
     expect(onRefreshComplete).toHaveBeenLastCalledWith(
       expect.objectContaining({ trigger: "scheduled" })