repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/activity/__serial__/runtime-win32.test.ts
Rawimport 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");
});
});