Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/activity/__serial__/runtime-win32.test.ts

Raw
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");
	});
});