import type { ChildProcess } from "node:child_process"; import { EventEmitter } from "node:events"; import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; const childProcess = vi.hoisted(() => ({ spawn: vi.fn() })); vi.mock("node:child_process", () => childProcess); const { ActivityManager } = await import("../runtime.ts"); class FakeChild extends EventEmitter { pid = 1234; exitCode: number | null = null; signalCode: NodeJS.Signals | null = null; stdout = new EventEmitter(); stderr = new EventEmitter(); kill = vi.fn(() => true); unref = vi.fn(); } const managers: ActivityManager[] = []; const platform = Object.getOwnPropertyDescriptor(process, "platform"); function manager(): ActivityManager { const value = new ActivityManager(); managers.push(value); return value; } function processChild(): FakeChild { return new FakeChild(); } function asChild(child: FakeChild): ChildProcess { return child as unknown as ChildProcess; } async function start(leader: FakeChild) { childProcess.spawn.mockImplementationOnce(() => asChild(leader)); const activities = manager(); const started = await activities.start( { kind: "process", command: "node" }, process.cwd(), ); return { activities, started }; } beforeEach(() => { childProcess.spawn.mockReset(); Object.defineProperty(process, "platform", { value: "win32" }); }); afterEach(async () => { await Promise.all(managers.splice(0).map((value) => value.dispose())); if (platform) Object.defineProperty(process, "platform", platform); vi.useRealTimers(); }); describe("Win32 process termination", () => { it("falls back to leader-only termination after taskkill spawn error", async () => { const leader = processChild(); const killer = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => asChild(killer)); await activities.stop(started.id); killer.emit("error", new Error("taskkill unavailable")); expect(leader.kill).toHaveBeenCalledTimes(1); leader.emit("close", null); const finished = activities.read(started.id); expect(finished.status).toBe("stopped"); expect(finished.error).toContain("leader only"); }); it("falls back to leader-only termination after nonzero taskkill exit", async () => { const leader = processChild(); const killer = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => asChild(killer)); await activities.stop(started.id); killer.emit("close", 1); expect(leader.kill).toHaveBeenCalledTimes(1); leader.emit("close", null); expect(activities.read(started.id).error).toContain("leader only"); }); it("reports synchronous taskkill launch failure", async () => { const leader = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => { throw new Error("spawn failed"); }); await activities.stop(started.id); expect(leader.kill).toHaveBeenCalledTimes(1); leader.emit("close", null); expect(activities.read(started.id).error).toContain("leader only"); }); it("bounds taskkill and allows retry after an unconfirmed attempt", async () => { vi.useFakeTimers(); const leader = processChild(); const killer = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => asChild(killer)); await activities.stop(started.id); expect(childProcess.spawn.mock.calls[1]?.[2]).toMatchObject({ timeout: 1000, }); await vi.advanceTimersByTimeAsync(1000); expect(leader.kill).toHaveBeenCalledTimes(1); expect(activities.read(started.id).error).toContain("leader only"); await activities.stop(started.id); expect(childProcess.spawn).toHaveBeenCalledTimes(2); killer.emit("close", null); const retryKiller = processChild(); childProcess.spawn.mockImplementationOnce(() => asChild(retryKiller)); await activities.stop(started.id); expect(childProcess.spawn).toHaveBeenCalledTimes(3); retryKiller.emit("close", 0); leader.emit("close", null); expect(activities.read(started.id).error).toBeUndefined(); }); it("does not start overlapping taskkill attempts", async () => { const leader = processChild(); const killer = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => asChild(killer)); await Promise.all([ activities.stop(started.id), activities.stop(started.id), ]); expect(childProcess.spawn).toHaveBeenCalledTimes(2); leader.emit("close", null); }); it("does not fall back or repeat taskkill after helper success while leader close is delayed", async () => { vi.useFakeTimers(); const leader = processChild(); const killer = processChild(); const { activities, started } = await start(leader); childProcess.spawn.mockImplementationOnce(() => asChild(killer)); await activities.stop(started.id); killer.emit("close", 0); await vi.advanceTimersByTimeAsync(1500); await activities.stop(started.id); expect(childProcess.spawn).toHaveBeenCalledTimes(2); expect(leader.kill).not.toHaveBeenCalled(); expect(activities.read(started.id).error).toBeUndefined(); expect(activities.read(started.id).status).toBe("stopping"); leader.emit("close", null); expect(activities.read(started.id).status).toBe("stopped"); }); it("does not taskkill a known-exited leader", async () => { const leader = processChild(); leader.exitCode = 0; const { activities, started } = await start(leader); const stopping = await activities.stop(started.id); expect(childProcess.spawn).toHaveBeenCalledTimes(1); expect(leader.kill).not.toHaveBeenCalled(); expect(stopping.error).toContain("Skipped taskkill"); leader.emit("close", 0); expect(activities.read(started.id).error).toContain("Skipped taskkill"); }); });