Files
rea/src/process/ProviderDeadline.test.ts
T
d4f0c5e664 fix(cli): start on Windows when USERPROFILE is empty (#2345)
* fix(cli): start on Windows when USERPROFILE is empty

Node's Windows home lookup throws ERR_SYSTEM_ERROR (uv_os_homedir ENOENT)
for an empty USERPROFILE instead of consulting the account profile. Incur
resolves the home while it is imported, so every command, including
`rea --version`, stopped with a raw stack trace before REA ran.

Treat the empty selection as unset in the launcher, before any runtime
import, and cover startup with a compiled-CLI regression.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(process): report no remaining time after a provider deadline fires

Node timers can fire while performance.now() is still a fraction of a
millisecond short of the monotonic deadline. ProviderStartupDeadline then
reported interruption "timeout" and an aborted signal while remainingMs()
returned ceil(0.x) = 1, so polling loops guarded by remainingMs() > 0
(Hopper and Ghidra startup) could run past an elapsed deadline, and the
real-timer test "aborts a bounded wait when its real monotonic deadline
expires" failed intermittently in CI (expected 1 to be 0).

Once the deadline's own timer has classified a timeout, report zero
remaining time. A deterministic regression test fires the timer with the
monotonic clock 0.4 ms short of the deadline.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>
2026-10-13 23:53:35 +08:00

204 lines
7.3 KiB
TypeScript

import { afterEach, expect, it, vi } from "vitest";
import { ProviderStartupDeadline } from "./ProviderDeadline.js";
afterEach(() => {
vi.restoreAllMocks();
});
it("keeps remaining time and cancellation classification stable across wall-clock jumps", () => {
const dateNow = vi.spyOn(Date, "now").mockReturnValue(10_000);
const caller = new AbortController();
const deadline = new ProviderStartupDeadline(10_000, caller.signal);
try {
dateNow.mockReturnValue(9_000_000_000_000);
const remaining = deadline.remainingMs();
expect(remaining).toBeGreaterThan(0);
expect(remaining).toBeLessThanOrEqual(10_000);
expect(Number.isInteger(remaining)).toBe(true);
expect(deadline.interruption).toBeUndefined();
caller.abort(new Error("caller stopped startup"));
expect(deadline.interruption).toBe("cancelled");
} finally {
deadline.dispose();
}
});
it("aborts a bounded wait when its real monotonic deadline expires", async () => {
const deadline = new ProviderStartupDeadline(40);
try {
await expect(deadline.wait(500)).resolves.toBe("aborted");
expect(deadline.interruption).toBe("timeout");
expect(deadline.remainingMs()).toBe(0);
} finally {
deadline.dispose();
}
});
it("does not expire a future monotonic deadline on an early timer callback", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const deadline = new ProviderStartupDeadline(40);
try {
monotonic = 39;
await vi.advanceTimersByTimeAsync(40);
expect(deadline.remainingMs()).toBe(1);
expect(deadline.signal.aborted).toBe(false);
expect(deadline.interruption).toBeUndefined();
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
it("aborts when the re-armed timer reaches the absolute deadline", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const deadline = new ProviderStartupDeadline(40);
try {
monotonic = 39;
await vi.advanceTimersByTimeAsync(40);
expect(deadline.signal.aborted).toBe(false);
monotonic = 40;
await vi.advanceTimersByTimeAsync(1);
expect(deadline.signal.aborted).toBe(true);
expect(deadline.interruption).toBe("timeout");
expect(deadline.remainingMs()).toBe(0);
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
it("reports a wait that resolves at the deadline as aborted, not elapsed", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const deadline = new ProviderStartupDeadline(40);
try {
const pending = deadline.wait(500);
monotonic = 40;
await vi.advanceTimersByTimeAsync(40);
await expect(pending).resolves.toBe("aborted");
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
it("resolves a polling interval shorter than the budget as elapsed", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const deadline = new ProviderStartupDeadline(40);
try {
const pending = deadline.wait(10);
monotonic = 10;
await vi.advanceTimersByTimeAsync(10);
await expect(pending).resolves.toBe("elapsed");
expect(deadline.signal.aborted).toBe(false);
expect(deadline.remainingMs()).toBe(30);
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
it("keeps caller cancellation classified without reporting an exhausted budget", () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const caller = new AbortController();
const deadline = new ProviderStartupDeadline(40, caller.signal);
try {
monotonic = 20;
caller.abort(new Error("caller stopped startup"));
expect(deadline.signal.aborted).toBe(true);
expect(deadline.interruption).toBe("cancelled");
expect(deadline.remainingMs()).toBe(20);
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
// Probe from issue #2760 review: both the abort timer and the clamped polling
// timer can fire early at the same monotonic instant. The full-budget wait must
// stay pending until the absolute deadline expires.
it("keeps a full-budget wait pending when both timers fire early", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const caller = new AbortController();
const deadline = new ProviderStartupDeadline(40, caller.signal);
let outcome: string | undefined;
const pending = deadline.wait(500).then((result) => {
outcome = result;
return result;
});
try {
monotonic = 39;
await vi.advanceTimersByTimeAsync(40);
expect(deadline.signal.aborted).toBe(false);
expect(deadline.remainingMs()).toBe(1);
expect(outcome).toBeUndefined();
monotonic = 40;
await vi.advanceTimersByTimeAsync(1);
await expect(pending).resolves.toBe("aborted");
expect(deadline.remainingMs()).toBe(0);
} finally {
caller.abort();
deadline.dispose();
vi.useRealTimers();
}
});
it("releases the timer and listener on dispose with a pending wait", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
let monotonic = 0;
vi.spyOn(performance, "now").mockImplementation(() => monotonic);
const caller = new AbortController();
const deadline = new ProviderStartupDeadline(40, caller.signal);
try {
const pending = deadline.wait(500);
deadline.dispose();
// The external abort listener is removed: caller cancellation after
// dispose must not abort the deadline or classify it as cancelled.
caller.abort(new Error("caller stopped startup"));
expect(deadline.signal.aborted).toBe(false);
expect(deadline.interruption).toBeUndefined();
monotonic = 100;
await vi.advanceTimersByTimeAsync(100);
expect(deadline.signal.aborted).toBe(false);
// The deadline expired while disposed, so the clamped wait resolves
// "aborted" from the monotonic clock instead of polling past expiry.
await expect(pending).resolves.toBe("aborted");
} finally {
deadline.dispose();
vi.useRealTimers();
}
});
// Preserve the authored fractional-clock control while following the current
// owning deadline's re-arm contract for an early native timer callback.
it("reports zero after the re-armed deadline reaches a fractional early callback", async () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
const now = vi.spyOn(performance, "now").mockReturnValue(1_000);
const deadline = new ProviderStartupDeadline(40);
try {
now.mockReturnValue(1_039.6);
await vi.advanceTimersByTimeAsync(40);
expect(deadline.signal.aborted).toBe(false);
expect(deadline.remainingMs()).toBe(1);
now.mockReturnValue(1_040);
await vi.advanceTimersByTimeAsync(1);
expect(deadline.signal.aborted).toBe(true);
expect(deadline.interruption).toBe("timeout");
expect(deadline.remainingMs()).toBe(0);
} finally {
deadline.dispose();
vi.useRealTimers();
}
});