repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/keysmash/__tests__/contract.test.ts
Rawimport { readdirSync, readFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import {
type EditorComponent,
type EditorTheme,
KeybindingsManager,
type TUI,
TUI_KEYBINDINGS,
} from "@earendil-works/pi-tui";
import { afterEach, describe, expect, it } from "vitest";
import {
createPiSession,
type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
type Factory = (
tui: TUI,
theme: EditorTheme,
keybindings: never,
) => EditorComponent;
const extensionPath = fileURLToPath(new URL("../index.ts", import.meta.url));
const theme = {
borderColor: (text: string) => text,
selectList: {
selectedPrefix: (text: string) => text,
selectedText: (text: string) => text,
description: (text: string) => text,
scrollInfo: (text: string) => text,
noMatch: (text: string) => text,
},
} as EditorTheme;
describe("keysmash contract", () => {
let session: PiSession | undefined;
afterEach(async () => {
await session?.dispose();
session = undefined;
});
async function start(
options: { current?: unknown; env?: Record<string, string> } = {},
) {
session = await createPiSession({
extensionPaths: [extensionPath],
...(options.env ? { env: options.env } : {}),
});
const runner = session.session.extensionRunner;
const installed: Array<Factory | undefined> = [];
const notices: Array<{ message: string; type?: string }> = [];
const ui = Object.create(runner.getUIContext());
ui.getEditorComponent = () => options.current;
ui.setEditorComponent = (factory: Factory | undefined) => {
installed.push(factory);
};
ui.notify = (message: string, type?: string) => {
notices.push({ message, ...(type ? { type } : {}) });
};
runner.setUIContext(ui, "tui");
await runner.emit({ type: "session_start", reason: "startup" });
return { runner, installed, notices };
}
function build(factory: Factory | undefined): EditorComponent {
if (!factory) throw new Error("no editor installed");
const tui = {
terminal: { rows: 40, columns: 80 },
requestRender() {},
} as unknown as TUI;
const keybindings = new KeybindingsManager(TUI_KEYBINDINGS);
return factory(tui, theme, keybindings as never);
}
it("loads in real Pi extension runtime", async () => {
session = await createPiSession({ extensionPaths: [extensionPath] });
expect(session.errors).toEqual([]);
expect(session.extensions).toHaveLength(1);
expect(session.extensions[0]!.path).toBe(extensionPath);
});
it("installs a prompt editor that continues bullets", async () => {
const { installed, notices } = await start();
expect(installed).toHaveLength(1);
const editor = build(installed[0]);
editor.setText("- first");
editor.handleInput("\n");
editor.handleInput("s");
expect(editor.getText()).toBe("- first\n- s");
expect(notices).toEqual([]);
expect(session!.errors).toEqual([]);
});
it("replaces its own editor after a reload", async () => {
const first = await start();
const own = first.installed[0]!;
await session!.dispose();
const second = await start({ current: own });
expect(second.installed).toHaveLength(1);
expect(second.notices).toEqual([]);
});
it("leaves another extension's editor alone and says so", async () => {
const { installed, notices } = await start({
current: () => ({}) as EditorComponent,
});
expect(installed).toEqual([]);
expect(notices).toEqual([
expect.objectContaining({ type: "warning", message: expect.any(String) }),
]);
});
it("does nothing without a terminal UI", async () => {
session = await createPiSession({ extensionPaths: [extensionPath] });
const runner = session.session.extensionRunner;
const installed: unknown[] = [];
const ui = Object.create(runner.getUIContext());
ui.setEditorComponent = (factory: unknown) => installed.push(factory);
runner.setUIContext(ui, "print");
await runner.emit({ type: "session_start", reason: "startup" });
expect(installed).toEqual([]);
});
it("writes debug records without text content when enabled", async () => {
const { installed, runner } = await start({
env: { PI_KEYSMASH_DEBUG: "1" },
});
const editor = build(installed[0]);
editor.setText("- secret");
editor.handleInput("\n");
await runner.emit({ type: "session_shutdown", reason: "quit" });
const directory = path.join(
session!.cwd,
".test-state",
"pi-ext",
"debug",
"keysmash",
);
const raw = readFileSync(
path.join(directory, readdirSync(directory)[0]!),
"utf8",
);
const records = raw
.trim()
.split("\n")
.map((line) => JSON.parse(line));
expect(records).toEqual(
expect.arrayContaining([
expect.objectContaining({ event: "session.start" }),
expect.objectContaining({ event: "edit.apply", action: "continue" }),
expect.objectContaining({ event: "session.shutdown" }),
]),
);
expect(raw).not.toContain("secret");
});
});