root/fusion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test(core): force deterministic fs.watch failure with NUL-byte path

Browse Source 
Prior attempt accepted either fs.watch failure path (sync throw vs async
error event) — but on Linux Node, fs.watch with `recursive: true` on a
missing directory silently succeeds (returns a no-op watcher, never
throws, never emits an error). Neither catch arm fires, so the warning
the test wants to assert never appears.

Switch to a NUL-byte-embedded path. Node validates the path argument up
front and throws ERR_INVALID_ARG_VALUE synchronously on every platform,
guaranteeing the `watch:fs-watch-setup` catch arm runs. Restore the
strict assertions on phase + message.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
gsxdsm
2026-05-28 10:46:21 -07:00
parent 2a3535893b
commit 2b66825fc1
3 changed files with 21 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
packages/core/src/__tests__/store-activity.test.ts
View File

@@ -812,37 +812,28 @@ describe("TaskStore", () => {
const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
const storeAny = store as any;
const originalTasksDir = storeAny.tasksDir;
storeAny.tasksDir = join(rootDir, ".fusion", "missing-tasks-dir");
// Force fs.watch to throw synchronously on every platform. A non-
// existent directory only fails reliably on macOS — Linux Node with
// `recursive: true` silently returns a no-op watcher (no sync throw,
// no async error event), so the catch arm we want to exercise never
// fires. Embedding a NUL byte makes Node reject the path argument
// up front with ERR_INVALID_ARG_VALUE, which is platform-agnostic.
const invalidTasksDir = join(rootDir, ".fusion", "missing-tasks-dir") + "bad";
storeAny.tasksDir = invalidTasksDir;
try {
await store.watch();
// fs.watch on a missing path is platform-sensitive: macOS Node throws
// ENOENT synchronously (routed to the `watch:fs-watch-setup` warning),
// whereas Linux Node returns a watcher that emits an async `error`
// event (routed to the `watch:fs-watch-error` warning). Either path
// is correct — the contract this test guards is "log the failure and
// keep polling alive," not which catch arm caught it. Use vi.waitFor
// so we observe the async path on Linux without racing the spy.
const findWarning = () =>
warnSpy.mock.calls.find((call) => {
if (typeof call[0] !== "string") return false;
return (
call[0].includes("[task-store] fs.watch unavailable; falling back to polling-only updates")
|| call[0].includes("[task-store] fs.watch emitted an error; polling will continue")
);
});
const warningCall = warnSpy.mock.calls.find(
(call) => typeof call[0] === "string" && call[0].includes("[task-store] fs.watch unavailable; falling back to polling-only updates"),
);
expect(warningCall).toBeDefined();
await vi.waitFor(() => {
expect(findWarning()).toBeDefined();
});
const warningCall = findWarning()!;
const [, context] = warningCall as [string, Record<string, unknown>];
expect(context).toMatchObject({
tasksDir: join(rootDir, ".fusion", "missing-tasks-dir"),
phase: "watch:fs-watch-setup",
tasksDir: invalidTasksDir,
});
expect(context.phase).toMatch(/^watch:fs-watch-(setup|error)$/);
expect(typeof context.error).toBe("string");
expect(storeAny.pollInterval).not.toBeNull();
await expect(storeAny.checkForChanges()).resolves.toBeUndefined();