Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

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

Raw
import { afterEach, describe, expect, it, vi } from "vitest";
import type { TerminalCallbacks, TerminalHandle } from "../types.ts";

const terminal = vi.hoisted(() => ({
	callbacks: undefined as TerminalCallbacks | undefined,
	pid: 0 as number | undefined,
	opening: undefined as Promise<void> | undefined,
	onDispose: undefined as (() => void) | undefined,
}));

vi.mock("../terminal.ts", () => ({
	openTerminal: vi.fn(
		async (
			_spec: unknown,
			_cwd: unknown,
			callbacks: TerminalCallbacks,
		): Promise<TerminalHandle> => {
			terminal.callbacks = callbacks;
			await terminal.opening;
			return {
				get pid() {
					return terminal.pid;
				},
				write() {},
				paste() {},
				view() {
					return {} as ReturnType<TerminalHandle["view"]>;
				},
				resize() {},
				screen() {
					return {
						text: "",
						cols: 100,
						rows: 28,
						cursorX: 0,
						cursorY: 0,
						truncated: false,
					};
				},
				async stop() {
					return true;
				},
				async dispose() {
					terminal.onDispose?.();
				},
			} as TerminalHandle;
		},
	),
}));

const { ActivityManager } = await import("../runtime.ts");
const managers: ActivityManager[] = [];

function manager(): ActivityManager {
	const value = new ActivityManager();
	managers.push(value);
	return value;
}

afterEach(async () => {
	await Promise.all(managers.splice(0).map((value) => value.dispose()));
	terminal.callbacks = undefined;
	terminal.pid = 0;
	terminal.opening = undefined;
	terminal.onDispose = undefined;
});

describe("terminal PID snapshots", () => {
	it("retains a PID assigned during disposal when stop races terminal opening", async () => {
		const activities = manager();
		let release!: () => void;
		terminal.opening = new Promise<void>((resolve) => {
			release = resolve;
		});
		terminal.onDispose = () => {
			terminal.pid = 6543;
		};
		const opening = activities.start(
			{ kind: "terminal", command: "node" },
			process.cwd(),
		);
		await vi.waitFor(() => expect(terminal.callbacks).toBeDefined());
		const id = activities.list()[0].id;
		await activities.stop(id);
		release();
		expect((await opening).pid).toBe(6543);
		expect(activities.read(id)).toMatchObject({ status: "stopped", pid: 6543 });
	});

	it("omits zero until public terminal PID becomes positive", async () => {
		const activities = manager();
		terminal.pid = 0;
		const started = await activities.start(
			{ kind: "terminal", command: "node" },
			process.cwd(),
		);
		expect(started).not.toHaveProperty("pid");

		terminal.pid = 4321;
		expect(activities.read(started.id).pid).toBe(4321);
		expect(activities.list()[0]?.pid).toBe(4321);
	});

	it("retains a public terminal PID observed immediately before exit", async () => {
		const activities = manager();
		terminal.pid = undefined;
		const started = await activities.start(
			{ kind: "terminal", command: "node" },
			process.cwd(),
		);
		expect(started).not.toHaveProperty("pid");

		terminal.pid = 5432;
		terminal.callbacks?.exit(0);
		const finished = activities.read(started.id);
		expect(finished.status).toBe("completed");
		expect(finished.pid).toBe(5432);
		expect(activities.list()[0]?.pid).toBe(5432);
	});
});