test(commands): dedupe command and onboarding test cases

src/channels/typing.test.ts

@@ -6,11 +6,36 @@ const flushMicrotasks = async () => {
   await Promise.resolve();
 };
 
+async function withFakeTimers(run: () => Promise<void>) {
+  vi.useFakeTimers();
+  try {
+    await run();
+  } finally {
+    vi.useRealTimers();
+  }
+}
+
+function createTypingHarness(overrides: Partial<Parameters<typeof createTypingCallbacks>[0]> = {}) {
+  const start = overrides.start ?? vi.fn().mockResolvedValue(undefined);
+  const stop = overrides.stop ?? vi.fn().mockResolvedValue(undefined);
+  const onStartError = overrides.onStartError ?? vi.fn();
+  const onStopError = overrides.onStopError ?? vi.fn();
+  const callbacks = createTypingCallbacks({
+    start,
+    stop,
+    onStartError,
+    ...(onStopError ? { onStopError } : {}),
+    ...(overrides.maxConsecutiveFailures !== undefined
+      ? { maxConsecutiveFailures: overrides.maxConsecutiveFailures }
+      : {}),
+    ...(overrides.maxDurationMs !== undefined ? { maxDurationMs: overrides.maxDurationMs } : {}),
+  });
+  return { start, stop, onStartError, onStopError, callbacks };
+}
+
 describe("createTypingCallbacks", () => {
   it("invokes start on reply start", async () => {
-    const start = vi.fn().mockResolvedValue(undefined);
-    const onStartError = vi.fn();
-    const callbacks = createTypingCallbacks({ start, onStartError });
+    const { start, onStartError, callbacks } = createTypingHarness();
 
     await callbacks.onReplyStart();
 
@@ -19,9 +44,9 @@ describe("createTypingCallbacks", () => {
   });
 
   it("reports start errors", async () => {
-    const start = vi.fn().mockRejectedValue(new Error("fail"));
-    const onStartError = vi.fn();
-    const callbacks = createTypingCallbacks({ start, onStartError });
+    const { onStartError, callbacks } = createTypingHarness({
+      start: vi.fn().mockRejectedValue(new Error("fail")),
+    });
 
     await callbacks.onReplyStart();
 
@@ -29,11 +54,9 @@ describe("createTypingCallbacks", () => {
   });
 
   it("invokes stop on idle and reports stop errors", async () => {
-    const start = vi.fn().mockResolvedValue(undefined);
-    const stop = vi.fn().mockRejectedValue(new Error("stop"));
-    const onStartError = vi.fn();
-    const onStopError = vi.fn();
-    const callbacks = createTypingCallbacks({ start, stop, onStartError, onStopError });
+    const { stop, onStopError, callbacks } = createTypingHarness({
+      stop: vi.fn().mockRejectedValue(new Error("stop")),
+    });
 
     callbacks.onIdle?.();
     await flushMicrotasks();
@@ -43,13 +66,8 @@ describe("createTypingCallbacks", () => {
   });
 
   it("sends typing keepalive pings until idle cleanup", async () => {
-    vi.useFakeTimers();
-    try {
-      const start = vi.fn().mockResolvedValue(undefined);
-      const stop = vi.fn().mockResolvedValue(undefined);
-      const onStartError = vi.fn();
-      const callbacks = createTypingCallbacks({ start, stop, onStartError });
-
+    await withFakeTimers(async () => {
+      const { start, stop, callbacks } = createTypingHarness();
       await callbacks.onReplyStart();
       expect(start).toHaveBeenCalledTimes(1);
 
@@ -68,18 +86,14 @@ describe("createTypingCallbacks", () => {
 
       await vi.advanceTimersByTimeAsync(9_000);
       expect(start).toHaveBeenCalledTimes(3);
-    } finally {
-      vi.useRealTimers();
-    }
+    });
   });
 
   it("stops keepalive after consecutive start failures", async () => {
-    vi.useFakeTimers();
-    try {
-      const start = vi.fn().mockRejectedValue(new Error("gone"));
-      const onStartError = vi.fn();
-      const callbacks = createTypingCallbacks({ start, onStartError });
-
+    await withFakeTimers(async () => {
+      const { start, onStartError, callbacks } = createTypingHarness({
+        start: vi.fn().mockRejectedValue(new Error("gone")),
+      });
       await callbacks.onReplyStart();
       expect(start).toHaveBeenCalledTimes(1);
       expect(onStartError).toHaveBeenCalledTimes(1);
@@ -90,19 +104,13 @@ describe("createTypingCallbacks", () => {
 
       await vi.advanceTimersByTimeAsync(9_000);
       expect(start).toHaveBeenCalledTimes(2);
-    } finally {
-      vi.useRealTimers();
-    }
+    });
   });
 
   it("does not restart keepalive when breaker trips on initial start", async () => {
-    vi.useFakeTimers();
-    try {
-      const start = vi.fn().mockRejectedValue(new Error("gone"));
-      const onStartError = vi.fn();
-      const callbacks = createTypingCallbacks({
-        start,
-        onStartError,
+    await withFakeTimers(async () => {
+      const { start, onStartError, callbacks } = createTypingHarness({
+        start: vi.fn().mockRejectedValue(new Error("gone")),
         maxConsecutiveFailures: 1,
       });
 
@@ -112,28 +120,21 @@ describe("createTypingCallbacks", () => {
       await vi.advanceTimersByTimeAsync(9_000);
       expect(start).toHaveBeenCalledTimes(1);
       expect(onStartError).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.useRealTimers();
-    }
+    });
   });
 
   it("resets failure counter after a successful keepalive tick", async () => {
-    vi.useFakeTimers();
-    try {
+    await withFakeTimers(async () => {
       let callCount = 0;
-      const start = vi.fn().mockImplementation(async () => {
-        callCount += 1;
-        if (callCount % 2 === 1) {
-          throw new Error("flaky");
-        }
-      });
-      const onStartError = vi.fn();
-      const callbacks = createTypingCallbacks({
-        start,
-        onStartError,
+      const { start, onStartError, callbacks } = createTypingHarness({
+        start: vi.fn().mockImplementation(async () => {
+          callCount += 1;
+          if (callCount % 2 === 1) {
+            throw new Error("flaky");
+          }
+        }),
         maxConsecutiveFailures: 2,
       });
-
       await callbacks.onReplyStart(); // fail
       await vi.advanceTimersByTimeAsync(3_000); // success
       await vi.advanceTimersByTimeAsync(3_000); // fail
@@ -142,16 +143,11 @@ describe("createTypingCallbacks", () => {
 
       expect(start).toHaveBeenCalledTimes(5);
       expect(onStartError).toHaveBeenCalledTimes(3);
-    } finally {
-      vi.useRealTimers();
-    }
+    });
   });
 
   it("deduplicates stop across idle and cleanup", async () => {
-    const start = vi.fn().mockResolvedValue(undefined);
-    const stop = vi.fn().mockResolvedValue(undefined);
-    const onStartError = vi.fn();
-    const callbacks = createTypingCallbacks({ start, stop, onStartError });
+    const { stop, callbacks } = createTypingHarness();
 
     callbacks.onIdle?.();
     callbacks.onCleanup?.();
@@ -161,12 +157,8 @@ describe("createTypingCallbacks", () => {
   });
 
   it("does not restart keepalive after idle cleanup", async () => {
-    vi.useFakeTimers();
-    try {
-      const start = vi.fn().mockResolvedValue(undefined);
-      const stop = vi.fn().mockResolvedValue(undefined);
-      const onStartError = vi.fn();
-      const callbacks = createTypingCallbacks({ start, stop, onStartError });
+    await withFakeTimers(async () => {
+      const { start, stop, callbacks } = createTypingHarness();
 
       await callbacks.onReplyStart();
       expect(start).toHaveBeenCalledTimes(1);
@@ -179,26 +171,15 @@ describe("createTypingCallbacks", () => {
 
       expect(start).toHaveBeenCalledTimes(1);
       expect(stop).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.useRealTimers();
-    }
+    });
   });
 
   // ========== TTL Safety Tests ==========
   describe("TTL safety", () => {
     it("auto-stops typing after maxDurationMs", async () => {
-      vi.useFakeTimers();
-      try {
+      await withFakeTimers(async () => {
         const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {});
-        const start = vi.fn().mockResolvedValue(undefined);
-        const stop = vi.fn().mockResolvedValue(undefined);
-        const onStartError = vi.fn();
-        const callbacks = createTypingCallbacks({
-          start,
-          stop,
-          onStartError,
-          maxDurationMs: 10_000,
-        });
+        const { start, stop, callbacks } = createTypingHarness({ maxDurationMs: 10_000 });
 
         await callbacks.onReplyStart();
         expect(start).toHaveBeenCalledTimes(1);
@@ -212,24 +193,13 @@ describe("createTypingCallbacks", () => {
         expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("TTL exceeded"));
 
         consoleWarn.mockRestore();
-      } finally {
-        vi.useRealTimers();
-      }
+      });
     });
 
     it("does not auto-stop if idle is called before TTL", async () => {
-      vi.useFakeTimers();
-      try {
+      await withFakeTimers(async () => {
         const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {});
-        const start = vi.fn().mockResolvedValue(undefined);
-        const stop = vi.fn().mockResolvedValue(undefined);
-        const onStartError = vi.fn();
-        const callbacks = createTypingCallbacks({
-          start,
-          stop,
-          onStartError,
-          maxDurationMs: 10_000,
-        });
+        const { stop, callbacks } = createTypingHarness({ maxDurationMs: 10_000 });
 
         await callbacks.onReplyStart();
 
@@ -249,18 +219,12 @@ describe("createTypingCallbacks", () => {
         expect(stop).toHaveBeenCalledTimes(1);
 
         consoleWarn.mockRestore();
-      } finally {
-        vi.useRealTimers();
-      }
+      });
     });
 
     it("uses default 60s TTL when not specified", async () => {
-      vi.useFakeTimers();
-      try {
-        const start = vi.fn().mockResolvedValue(undefined);
-        const stop = vi.fn().mockResolvedValue(undefined);
-        const onStartError = vi.fn();
-        const callbacks = createTypingCallbacks({ start, stop, onStartError });
+      await withFakeTimers(async () => {
+        const { stop, callbacks } = createTypingHarness();
 
         await callbacks.onReplyStart();
 
@@ -271,46 +235,24 @@ describe("createTypingCallbacks", () => {
         // Should stop at 60s
         await vi.advanceTimersByTimeAsync(1_000);
         expect(stop).toHaveBeenCalledTimes(1);
-      } finally {
-        vi.useRealTimers();
-      }
+      });
     });
 
     it("disables TTL when maxDurationMs is 0", async () => {
-      vi.useFakeTimers();
-      try {
-        const start = vi.fn().mockResolvedValue(undefined);
-        const stop = vi.fn().mockResolvedValue(undefined);
-        const onStartError = vi.fn();
-        const callbacks = createTypingCallbacks({
-          start,
-          stop,
-          onStartError,
-          maxDurationMs: 0,
-        });
+      await withFakeTimers(async () => {
+        const { stop, callbacks } = createTypingHarness({ maxDurationMs: 0 });
 
         await callbacks.onReplyStart();
 
         // Should not auto-stop even after long time
         await vi.advanceTimersByTimeAsync(300_000);
         expect(stop).not.toHaveBeenCalled();
-      } finally {
-        vi.useRealTimers();
-      }
+      });
     });
 
     it("resets TTL timer on restart after idle", async () => {
-      vi.useFakeTimers();
-      try {
-        const start = vi.fn().mockResolvedValue(undefined);
-        const stop = vi.fn().mockResolvedValue(undefined);
-        const onStartError = vi.fn();
-        const callbacks = createTypingCallbacks({
-          start,
-          stop,
-          onStartError,
-          maxDurationMs: 10_000,
-        });
+      await withFakeTimers(async () => {
+        const { stop, callbacks } = createTypingHarness({ maxDurationMs: 10_000 });
 
         // First start
         await callbacks.onReplyStart();
@@ -330,9 +272,7 @@ describe("createTypingCallbacks", () => {
 
         // Should not trigger stop again since it's closed
         expect(stop).not.toHaveBeenCalled();
-      } finally {
-        vi.useRealTimers();
-      }
+      });
     });
   });
 });