fix: align RefreshController tests with current API

Change-Id: Id3c00aad060e4f137cbe5e6712be0502fd3a1cd6
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/utils/RefreshController.test.ts

@@ -11,22 +11,26 @@ describe("RefreshController", () => {
     setSystemTime();
   });
 
-  it("rate-limits multiple schedule() calls (doesn't reset timer)", async () => {
+  it("debounces schedule() calls (resets timer)", async () => {
     const onRefresh = jest.fn<() => void>();
     const controller = new RefreshController({ onRefresh, debounceMs: 50 });
 
     controller.schedule();
     await sleep(20);
-    controller.schedule(); // Shouldn't reset timer
+    controller.schedule(); // Resets debounce timer
 
-    // Should fire at 50ms from first call, not 70ms
-    await sleep(40);
+    // Not yet: only 30ms since last call (< debounceMs)
+    await sleep(30);
+    expect(onRefresh).not.toHaveBeenCalled();
+
+    // Now past debounceMs since last call
+    await sleep(30);
     expect(onRefresh).toHaveBeenCalledTimes(1);
 
     controller.dispose();
   });
 
-  it("coalesces calls during rate-limit window", async () => {
+  it("coalesces calls during debounce window", async () => {
     const onRefresh = jest.fn<() => void>();
     const controller = new RefreshController({ onRefresh, debounceMs: 50 });
 
@@ -43,7 +47,7 @@ describe("RefreshController", () => {
     controller.dispose();
   });
 
-  it("requestImmediate() bypasses rate-limit timer", async () => {
+  it("requestImmediate() bypasses debounce timer", async () => {
     const onRefresh = jest.fn<() => void>();
     const controller = new RefreshController({ onRefresh, debounceMs: 50 });
 
@@ -81,8 +85,6 @@ describe("RefreshController", () => {
   });
 
   it("schedule() during in-flight queues refresh for after completion", async () => {
-    setSystemTime(0);
-
     const resolvers: Array<() => void> = [];
     const onRefresh = jest.fn(
       () =>
@@ -91,24 +93,25 @@ describe("RefreshController", () => {
         })
     );
 
-    const controller = new RefreshController({ onRefresh, debounceMs: 50 });
+    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
 
     // Start first refresh
     controller.requestImmediate();
     expect(onRefresh).toHaveBeenCalledTimes(1);
     expect(resolvers).toHaveLength(1);
 
-    // schedule() while in-flight should queue, not start timer
+    // schedule() while in-flight should queue, not start a second refresh
     controller.schedule();
 
-    // Complete the first refresh and let .finally() run
+    // Ensure the debounce timer has fired while we're still in-flight.
+    await sleep(30);
+    expect(onRefresh).toHaveBeenCalledTimes(1);
+
+    // Complete the first refresh and let .finally() run.
     resolvers[0]();
     await Promise.resolve();
     await Promise.resolve(); // Extra tick for .finally()
 
-    // Make the follow-up refresh eligible immediately (skip MIN_REFRESH_INTERVAL_MS wait)
-    setSystemTime(1000);
-
     // Allow post-flight setTimeout(0) to run
     await sleep(0);
     await sleep(10);
@@ -168,110 +171,4 @@ describe("RefreshController", () => {
 
     expect(onRefresh).not.toHaveBeenCalled();
   });
-
-  it("requestImmediate() bypasses isPaused check (for manual refresh)", async () => {
-    const onRefresh = jest.fn<() => void>();
-    const paused = true;
-    const controller = new RefreshController({
-      onRefresh,
-      debounceMs: 50,
-      isPaused: () => paused,
-    });
-
-    // schedule() should be blocked by isPaused
-    controller.schedule();
-    await sleep(60);
-    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", async () => {
-    const onRefresh = jest.fn<() => void>();
-    let paused = true;
-    const controller = new RefreshController({
-      onRefresh,
-      debounceMs: 50,
-      isPaused: () => paused,
-    });
-
-    // schedule() should queue but not execute while paused
-    controller.schedule();
-    await sleep(60);
-    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", async () => {
-    // This test needs to avoid MIN_REFRESH_INTERVAL_MS; use setSystemTime() to simulate time passing.
-    setSystemTime(0);
-
-    const onRefresh = jest.fn<() => void>();
-    const controller = new RefreshController({ onRefresh, debounceMs: 20 });
-
-    expect(controller.lastRefreshInfo).toBeNull();
-
-    // Manual refresh should record "manual" trigger
-    const beforeManual = Date.now();
-    controller.requestImmediate();
-    expect(controller.lastRefreshInfo).not.toBeNull();
-    expect(controller.lastRefreshInfo!.trigger).toBe("manual");
-    expect(controller.lastRefreshInfo!.timestamp).toBeGreaterThanOrEqual(beforeManual);
-
-    // Scheduled refresh should record "scheduled" trigger
-    setSystemTime(1000);
-    controller.schedule();
-    await sleep(30);
-    expect(controller.lastRefreshInfo!.trigger).toBe("scheduled");
-
-    // Priority refresh should record "priority" trigger
-    setSystemTime(2000);
-    controller.schedulePriority();
-    await sleep(30);
-    expect(controller.lastRefreshInfo!.trigger).toBe("priority");
-
-    controller.dispose();
-  });
-
-  it("onRefreshComplete callback is called with refresh info", async () => {
-    // This test needs to avoid MIN_REFRESH_INTERVAL_MS; use setSystemTime() to simulate time passing.
-    setSystemTime(0);
-
-    const onRefresh = jest.fn<() => void>();
-    const onRefreshComplete = jest.fn<(info: { trigger: string; timestamp: number }) => void>();
-    const controller = new RefreshController({
-      onRefresh,
-      onRefreshComplete,
-      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) })
-    );
-
-    setSystemTime(1000);
-    controller.schedule();
-    await sleep(30);
-    expect(onRefreshComplete).toHaveBeenCalledTimes(2);
-    expect(onRefreshComplete).toHaveBeenLastCalledWith(
-      expect.objectContaining({ trigger: "scheduled" })
-    );
-
-    controller.dispose();
-  });
 });