repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/activity/__serial__/widget-wiring.test.ts
Rawimport type {
ExtensionUIContext,
Theme,
} from "@earendil-works/pi-coding-agent";
import { afterEach, expect, it, vi } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import activityExtension from "../index.ts";
import type { ActivitySnapshot } from "../types.ts";
// Controlled manager events isolate extension wiring, not OS process termination.
const state = vi.hoisted(() => ({
items: [] as ActivitySnapshot[],
acknowledged: new Set<string>(),
listeners: new Set<() => void>(),
disposed: 0,
}));
vi.mock("../runtime.ts", () => ({
ActivityManager: class {
list() {
return state.items.map((item) => ({ ...item }));
}
attention() {
return this.list().filter(
(item) =>
item.status === "running" ||
item.status === "stopping" ||
(item.status === "failed" && !state.acknowledged.has(item.id)),
);
}
subscribe(listener: () => void) {
state.listeners.add(listener);
return () => state.listeners.delete(listener);
}
async dispose() {
state.disposed++;
}
},
}));
let fixture: PiSession | undefined;
afterEach(async () => {
vi.useRealTimers();
await fixture?.dispose();
fixture = undefined;
state.items = [];
state.acknowledged.clear();
state.listeners.clear();
state.disposed = 0;
});
async function bind(mode: "tui" | "rpc") {
fixture = await createPiSession({ extensionFactories: [activityExtension] });
expect(fixture.errors).toEqual([]);
const runner = fixture.session.extensionRunner;
const setWidget = vi.fn<ExtensionUIContext["setWidget"]>();
const setStatus = vi.fn<ExtensionUIContext["setStatus"]>();
runner.setUIContext({ ...runner.getUIContext(), setWidget, setStatus }, mode);
await runner.emit({ type: "session_start" });
const definition = fixture.extensions
.flatMap((extension) => [...extension.tools.values()])
.find((entry) => entry.definition.name === "activity")?.definition;
if (!definition) throw new Error("Missing activity definition");
await definition.execute(
"fixture-list",
{ action: "list" },
undefined,
undefined,
runner.createContext(),
);
setWidget.mockClear();
setStatus.mockClear();
vi.useFakeTimers();
return { runner, setWidget, setStatus };
}
function publish(status: ActivitySnapshot["status"]) {
state.items = [
{
id: "fixture-process",
kind: "process",
title: "Build fixture",
status,
createdAt: 0,
sequence: 1,
notify: false,
},
];
for (const listener of state.listeners) listener();
}
it("debounces native above-editor status, updates unchanged counts, suppresses output-only updates and clears on shutdown", async () => {
const { runner, setWidget, setStatus } = await bind("tui");
const theme = { fg: (_color: unknown, text: string) => text } as Theme;
const latest = () => {
const [key, factory, options] = setWidget.mock.calls.at(-1) ?? [];
expect(key).toBe("activity");
expect(options).toEqual({ placement: "aboveEditor" });
if (typeof factory !== "function")
throw new Error("Missing widget factory");
return factory({} as Parameters<typeof factory>[0], theme)
.render(100)
.join("\n");
};
publish("running");
publish("running");
expect(setWidget).not.toHaveBeenCalled();
await vi.advanceTimersByTimeAsync(100);
expect(setWidget).toHaveBeenCalledTimes(1);
expect(latest()).toContain("Running · Build fixture");
publish("running");
await vi.advanceTimersByTimeAsync(100);
expect(setWidget).toHaveBeenCalledTimes(1);
publish("stopping");
await vi.advanceTimersByTimeAsync(100);
expect(setWidget).toHaveBeenCalledTimes(2);
expect(latest()).toContain("Stopping… · Build fixture");
expect(setStatus).not.toHaveBeenCalled();
publish("stopped");
await runner.emit({ type: "session_shutdown", reason: "quit" });
expect(setWidget).toHaveBeenLastCalledWith("activity", undefined);
expect(state.listeners.size).toBe(0);
expect(state.disposed).toBe(1);
const calls = setWidget.mock.calls.length;
await vi.advanceTimersByTimeAsync(100);
expect(setWidget).toHaveBeenCalledTimes(calls);
expect(setStatus).toHaveBeenCalledWith("activity", undefined);
});
it("hides finished successes immediately and failures once acknowledged", async () => {
const { runner, setWidget } = await bind("tui");
publish("completed");
await vi.advanceTimersByTimeAsync(100);
expect(setWidget.mock.calls.every(([, factory]) => !factory)).toBe(true);
publish("failed");
await vi.advanceTimersByTimeAsync(100);
expect(typeof setWidget.mock.calls.at(-1)?.[1]).toBe("function");
state.acknowledged.add("fixture-process");
for (const listener of state.listeners) listener();
await vi.advanceTimersByTimeAsync(100);
expect(setWidget).toHaveBeenLastCalledWith("activity", undefined, {
placement: "aboveEditor",
});
await runner.emit({ type: "session_shutdown", reason: "quit" });
});
it("does not register terminal widgets in RPC mode", async () => {
const { runner, setWidget, setStatus } = await bind("rpc");
publish("running");
await vi.advanceTimersByTimeAsync(100);
await runner.emit({ type: "session_shutdown", reason: "quit" });
expect(setWidget).not.toHaveBeenCalled();
expect(setStatus).not.toHaveBeenCalled();
});