pikasTech-HWLAB/web/hwlab-cloud-web/scripts/fetchJson-inactivity.test.ts

import assert from "node:assert/strict";
import test from "node:test";

import type { ActivityRef } from "../src/services/api/client.ts";

const win = globalThis as unknown as { window: { setTimeout: typeof setTimeout; clearTimeout: typeof clearTimeout } };
if (!win.window) {
  win.window = {
    setTimeout: (handler, delay) => setTimeout(handler, delay),
    clearTimeout: (timer) => clearTimeout(timer as unknown as ReturnType<typeof setTimeout>)
  };
}

function bindSignalFetch(): typeof fetch {
  return (async (_input, init) => {
    return await new Promise<Response>((_, reject) => {
      const signal = init?.signal;
      if (signal) {
        if (signal.aborted) reject(new DOMException("aborted", "AbortError"));
        else signal.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")), { once: true });
      }
    });
  }) as typeof fetch;
}

function buildMutableActivityRef(initial: number): { ref: ActivityRef; update: (at: number) => void } {
  const ref: ActivityRef = {
    lastActivityAt: initial,
    lastActivityIso: new Date(initial).toISOString(),
    waitingFor: "test",
    lastEventLabel: null
  };
  return {
    ref,
    update: (at: number) => {
      ref.lastActivityAt = at;
      ref.lastActivityIso = new Date(at).toISOString();
    }
  };
}

test("fetchJson 总超时：未传 activityRef 时 timeoutMs 走总窗口", { timeout: 5000 }, async () => {
  const originalFetch = globalThis.fetch;
  globalThis.fetch = bindSignalFetch();
  try {
    const { fetchJson } = await import("../src/services/api/client.ts");
    const startedAt = Date.now();
    const result = await fetchJson("/v1/agent/chat", { timeoutMs: 200, timeoutName: "test-total" });
    const elapsed = Date.now() - startedAt;
    assert.equal(result.ok, false, "fetch should fail when no activity is supplied");
    assert.match(result.error ?? "", /超时/u, `expected timeout error, got: ${result.error}`);
    assert.ok(elapsed < 1500, `fetchJson should abort near 200ms but took ${elapsed}ms`);
  } finally {
    globalThis.fetch = originalFetch;
  }
});

test("fetchJson inactivity：activityRef 每 100ms 推一次活动，stop 后 ~2s abort", { timeout: 15000 }, async () => {
  const { ref, update } = buildMutableActivityRef(Date.now());
  const originalFetch = globalThis.fetch;
  globalThis.fetch = bindSignalFetch();

  const interval = setInterval(() => {
    update(Date.now());
  }, 100);

  try {
    const { fetchJson } = await import("../src/services/api/client.ts");
    const startedAt = Date.now();
    const promise = fetchJson("/v1/agent/chat", { timeoutMs: 2000, timeoutName: "test-inactivity", activityRef: () => ref });
    setTimeout(() => clearInterval(interval), 1800);
    const result = await promise;
    const elapsed = Date.now() - startedAt;
    assert.equal(result.ok, false, "fetch should fail once activity stops");
    assert.match(result.error ?? "", /无新活动/u, `expected inactivity-timeout error, got: ${result.error}`);
    assert.ok(elapsed >= 1800, `should not abort before 1800ms with continuous activity, got ${elapsed}ms`);
    assert.ok(elapsed < 6000, `should abort ~1-2s after activity stops, got ${elapsed}ms`);
  } finally {
    clearInterval(interval);
    globalThis.fetch = originalFetch;
  }
});

test("fetchJson inactivity：trace poll 风格的 1.5s 间隔在 6.5s 内不会触发总超时", { timeout: 20000 }, async () => {
  // HWLAB #795 regression + PR feedback: the runner-trace poll loop must
  // NOT use any client-side total timeout. The fetchJson request aborts
  // only on inactivity (no activity for timeoutMs). To make the contract
  // explicit, this case runs 200ms-cadence activity for 10 seconds with
  // a 3-second inactivity window set on the request — the request must
  // keep living for the full 10 seconds even though 3s << 10s.
  const { ref, update } = buildMutableActivityRef(Date.now());
  const originalFetch = globalThis.fetch;
  globalThis.fetch = bindSignalFetch();

  const interval = setInterval(() => {
    update(Date.now());
  }, 200);

  try {
    const { fetchJson } = await import("../src/services/api/client.ts");
    const startedAt = Date.now();
    const promise = fetchJson("/v1/agent/chat/result/abc", { timeoutMs: 3000, timeoutName: "trace-poll", activityRef: () => ref });
    setTimeout(() => clearInterval(interval), 10_000);
    const result = await promise;
    const elapsed = Date.now() - startedAt;
    assert.equal(result.ok, false, "fetch should fail once activity stops");
    assert.ok(
      elapsed >= 10_000,
      `continuous 200ms activity must keep the request alive for the full 10s; a total cap or wall-clock shrink would abort earlier; got ${elapsed}ms`
    );
    assert.match(result.error ?? "", /无新活动/u, `expected inactivity-timeout error, got: ${result.error}`);
  } finally {
    clearInterval(interval);
    globalThis.fetch = originalFetch;
  }
});