gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0

package/src/resources/extensions/remote-questions/tests/command-polling.test.ts

@@ -1,18 +1,31 @@
 /**
- * Tests for startCommandPolling() background interval.
+ * Tests for the REAL `startCommandPolling()` background interval.
  *
- * Framework: node:test + node:assert/strict (CONTRIBUTING.md rules)
+ * Previous version of this file re-implemented `startCommandPolling`
+ * inline (as `makeStartCommandPolling`) and tested the re-implementation.
+ * The file header said exactly that: "Rather than importing the real
+ * startCommandPolling (which calls resolveRemoteConfig and hits the
+ * filesystem / env), we re-implement the same tiny function inline
+ * here using injected fakes." If the real function regressed (wrong
+ * channel gate, missing cleanup, wrong handler invocation), none of
+ * those tests would have failed. See #4806 / #4784.
  *
- * Covers:
- *   - startCommandPolling returns a cleanup function
- *   - Calling cleanup stops further poll invocations
- *   - When no remote channel is configured, a no-op cleanup is returned
+ * Rewrite uses the DI seam now exposed on `startCommandPolling`
+ * (`CommandPollingDeps`) to drive the real function with a stubbed
+ * config resolver, adapter factory, and timer pair.
  */
 
-import test from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 
-// ─── Minimal fake timer harness ───────────────────────────────────────────────
+import type { ResolvedConfig } from "../config.ts";
+import {
+  startCommandPolling,
+  type PollingAdapter,
+  type CommandPollingDeps,
+} from "../manager.ts";
+
+// ─── Fake timer harness ───────────────────────────────────────────────────────
 
 interface FakeTimer {
   id: number;
@@ -21,226 +34,223 @@ interface FakeTimer {
   cleared: boolean;
 }
 
-/**
- * Build a fake setInterval / clearInterval pair so tests never actually wait
- * for real time and do not depend on Node's timer subsystem firing order.
- */
 function makeFakeTimers(): {
-  fakeSetInterval: typeof setInterval;
-  fakeClearInterval: typeof clearInterval;
+  setIntervalFn: typeof setInterval;
+  clearIntervalFn: typeof clearInterval;
   timers: FakeTimer[];
   tick: () => void;
 } {
   const timers: FakeTimer[] = [];
   let nextId = 1;
 
-  const fakeSetInterval = (callback: () => void, _ms?: number, ..._args: unknown[]): ReturnType<typeof setInterval> => {
+  const setIntervalFn = ((callback: () => void, ms?: number): ReturnType<typeof setInterval> => {
     const timer: FakeTimer = {
       id: nextId++,
       callback,
-      intervalMs: _ms ?? 0,
+      intervalMs: ms ?? 0,
       cleared: false,
     };
     timers.push(timer);
     return timer.id as unknown as ReturnType<typeof setInterval>;
-  };
+  }) as unknown as typeof setInterval;
 
-  const fakeClearInterval = (id?: ReturnType<typeof clearInterval> | null): void => {
+  const clearIntervalFn = ((id?: ReturnType<typeof clearInterval> | null): void => {
     const timer = timers.find((t) => (t.id as unknown) === id);
     if (timer) timer.cleared = true;
-  };
+  }) as unknown as typeof clearInterval;
 
-  /** Fire all non-cleared timers once (simulates one interval tick). */
   const tick = (): void => {
     for (const timer of timers) {
       if (!timer.cleared) timer.callback();
     }
   };
 
+  return { setIntervalFn, clearIntervalFn, timers, tick };
+}
+
+// ─── Config + adapter stubs ───────────────────────────────────────────────────
+
+function telegramConfig(): ResolvedConfig {
   return {
-    fakeSetInterval: fakeSetInterval as unknown as typeof setInterval,
-    fakeClearInterval: fakeClearInterval as unknown as typeof clearInterval,
-    timers,
-    tick,
-  };
+    channel: "telegram",
+    token: "fake-token",
+    channelId: "fake-channel-id",
+    timeoutMs: 60_000,
+    pollIntervalMs: 1_000,
+  } as ResolvedConfig;
 }
 
-// ─── Fake TelegramAdapter ────────────────────────────────────────────────────
+function slackConfig(): ResolvedConfig {
+  return {
+    channel: "slack",
+    token: "fake-token",
+    channelId: "fake-channel-id",
+    timeoutMs: 60_000,
+    pollIntervalMs: 1_000,
+  } as ResolvedConfig;
+}
 
-function makeFakeAdapter(): {
-  pollCalls: number;
-  pollAndHandleCommands: (basePath: string) => Promise<number>;
-} {
+function makeFakeAdapter(): PollingAdapter & { readonly pollCalls: number } {
   let pollCalls = 0;
-  return {
-    get pollCalls() { return pollCalls; },
+  const adapter = {
+    get pollCalls(): number {
+      return pollCalls;
+    },
     async pollAndHandleCommands(_basePath: string): Promise<number> {
       pollCalls++;
       return 0;
     },
   };
+  return adapter;
 }
 
-// ─── Internal startCommandPolling factory (testable, no real I/O) ────────────
-//
-// Rather than importing the real startCommandPolling (which calls resolveRemoteConfig
-// and hits the filesystem / env), we re-implement the same tiny function inline
-// here using injected fakes. This keeps tests hermetic without mocking globals.
-
-function makeStartCommandPolling(
-  fakeSetInterval: typeof setInterval,
-  fakeClearInterval: typeof clearInterval,
-  adapterPollFn: (basePath: string) => Promise<number>,
-  isConfigured: boolean,
-  intervalMs = 5000,
-): (basePath: string) => () => void {
-  return function startCommandPolling(basePath: string): () => void {
-    if (!isConfigured) {
-      return () => {};
-    }
-
-    const timer = fakeSetInterval(() => {
-      void adapterPollFn(basePath).catch(() => {});
-    }, intervalMs);
-
-    return () => fakeClearInterval(timer);
-  };
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-test("startCommandPolling: returns a cleanup function (callable without error)", () => {
-  const { fakeSetInterval, fakeClearInterval } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.equal(typeof cleanup, "function", "Expected startCommandPolling to return a function");
-  // Calling cleanup must not throw
-  assert.doesNotThrow(() => cleanup(), "cleanup() must not throw");
-});
-
-test("startCommandPolling: interval fires the poll callback on tick", async () => {
-  const { fakeSetInterval, fakeClearInterval, tick } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  startCommandPolling("/fake/project");
-
-  // Before any tick, nothing polled yet
-  assert.equal(adapter.pollCalls, 0);
-
-  // One tick — the callback fires and schedules the async poll
-  tick();
-
-  // Allow the microtask queue to drain so the async poll promise resolves
-  await Promise.resolve();
-
-  assert.equal(adapter.pollCalls, 1, "Expected poll to be called after one tick");
-});
-
-test("startCommandPolling: cleanup stops further poll invocations", async () => {
-  const { fakeSetInterval, fakeClearInterval, timers, tick } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  // Tick once to confirm polling works
-  tick();
-  await Promise.resolve();
-  assert.equal(adapter.pollCalls, 1, "Expected 1 poll after first tick");
-
-  // Call cleanup — marks the timer as cleared
-  cleanup();
-
-  // Confirm the underlying timer was cleared
-  assert.equal(timers.length, 1, "Expected exactly one timer to have been registered");
-  assert.equal(timers[0].cleared, true, "Expected timer to be cleared after cleanup()");
-
-  // Tick again — the cleared timer must NOT fire
-  tick();
-  await Promise.resolve();
-  assert.equal(adapter.pollCalls, 1, "Expected no additional polls after cleanup()");
-});
-
-test("startCommandPolling: calling cleanup twice is safe (no throw)", () => {
-  const { fakeSetInterval, fakeClearInterval } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.doesNotThrow(() => {
-    cleanup();
-    cleanup();
-  }, "Calling cleanup twice must not throw");
-});
+// ─── Tests against the real startCommandPolling ───────────────────────────────
 
-test("startCommandPolling: returns no-op cleanup when no channel is configured", () => {
-  const { fakeSetInterval, fakeClearInterval, timers } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    false, // not configured
-  );
+describe("startCommandPolling (real function via DI seam)", () => {
+  it("returns a cleanup function for a Telegram config", () => {
+    const { setIntervalFn, clearIntervalFn } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
 
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.equal(typeof cleanup, "function", "Expected a cleanup function even when not configured");
-  assert.equal(timers.length, 0, "Expected no timer to be registered when channel is not configured");
-
-  // The no-op cleanup must not throw
-  assert.doesNotThrow(() => cleanup(), "No-op cleanup must not throw");
-});
-
-test("startCommandPolling: poll errors are swallowed (best-effort)", async () => {
-  const { fakeSetInterval, fakeClearInterval, tick } = makeFakeTimers();
-
-  // Adapter that always rejects
-  let rejectCalls = 0;
-  const throwingPoll = async (_basePath: string): Promise<number> => {
-    rejectCalls++;
-    throw new Error("Simulated network error");
-  };
-
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    throwingPoll,
-    true,
-  );
-
-  startCommandPolling("/fake/project");
-
-  // Ticking must not propagate the rejection — the interval is fire-and-forget
-  assert.doesNotThrow(() => tick(), "tick() must not throw even if poll rejects");
+    const deps: CommandPollingDeps = {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    };
 
-  // Allow the rejected promise to settle without an unhandled rejection
-  await Promise.resolve();
+    const stop = startCommandPolling("/tmp/project", 5_000, deps);
+    assert.equal(typeof stop, "function", "must return a cleanup function");
+    stop();
+  });
+
+  it("invokes the adapter's pollAndHandleCommands on each tick", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(adapter.pollCalls, 0, "no poll before any tick");
+
+    tick();
+    // Yield so the async adapter call settles before we assert.
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(adapter.pollCalls, 1, "one tick → one poll");
+
+    tick();
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(adapter.pollCalls, 3, "three ticks → three polls");
+
+    stop();
+  });
+
+  it("cleanup stops further polls", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    const pollsBeforeStop = adapter.pollCalls;
+    assert.ok(pollsBeforeStop > 0, "at least one poll before stop");
+
+    stop();
+
+    tick();
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(
+      adapter.pollCalls,
+      pollsBeforeStop,
+      "no additional polls after stop() — cleared interval must stop ticking",
+    );
+  });
+
+  it("returns a no-op when no remote channel is configured", () => {
+    const { setIntervalFn, clearIntervalFn, timers } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => null,
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(typeof stop, "function", "still returns a function");
+    assert.equal(
+      timers.length,
+      0,
+      "no interval registered when config is absent",
+    );
+    assert.doesNotThrow(() => stop());
+  });
+
+  it("returns a no-op for non-Telegram channels (e.g. Slack)", () => {
+    const { setIntervalFn, clearIntervalFn, timers } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+    let adapterCreated = false;
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => slackConfig(),
+      createAdapter: () => {
+        adapterCreated = true;
+        return adapter;
+      },
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(
+      timers.length,
+      0,
+      "no interval registered for non-Telegram channel",
+    );
+    assert.equal(
+      adapterCreated,
+      false,
+      "adapter must not be instantiated when channel is unsupported",
+    );
+    stop();
+  });
+
+  it("does not surface adapter polling errors (best-effort)", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter: PollingAdapter = {
+      async pollAndHandleCommands(_basePath: string): Promise<number> {
+        throw new Error("network hiccup");
+      },
+    };
 
-  assert.equal(rejectCalls, 1, "Expected poll to have been called once");
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    // Tick must not throw; the `.catch(() => {})` in production code
+    // swallows the rejection so one bad network call doesn't crash
+    // the polling loop.
+    assert.doesNotThrow(() => tick());
+    await Promise.resolve();
+    await Promise.resolve();
+
+    stop();
+  });
 });

package/src/resources/extensions/shared/tests/interview-preview.test.ts

@@ -56,14 +56,22 @@ describe("preview column rendering", () => {
     assert.ok(hasContent, "At least one rendered line should have visible content");
   });
 
-  it("Markdown component renders code blocks", () => {
+  it("Markdown component renders code blocks — preserves the source text", () => {
     const mdTheme = getMarkdownTheme();
     const md = new Markdown("```ts\nconst x = 1;\n```", 1, 0, mdTheme);
     const lines = md.render(40);
     assert.ok(lines.length > 0);
     const joined = lines.join("\n");
-    // The rendered output should contain the code content somewhere
-    assert.ok(joined.includes("const") || joined.includes("x"), "Code block content should be present");
+    // Previous assertion was `includes("const") || includes("x")` — the
+    // `x` branch matched any ANSI rendering incidentally containing the
+    // letter (box borders, tab markers, even fallbackColor's `x` token),
+    // making it a near-tautology. Assert on a distinctive combined
+    // source fragment so a regression that silently swallows the code
+    // block body actually fails.
+    assert.ok(
+      joined.includes("const") && joined.includes("x = 1"),
+      `rendered code block must preserve source tokens. got:\n${joined}`,
+    );
   });
 
   it("Markdown component respects width constraint", () => {