Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/loop/__tests__/settings.test.ts

Raw
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { afterEach, describe, expect, it } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import { resolveSetting } from "../src/pi-ext-settings.ts";
import {
	DEFAULT_STATE_PATH,
	parseStatePath,
	STATE_PATH_SETTING,
	statePathFor,
} from "../src/settings.ts";

let box: PiSession | undefined;
let root: string | undefined;
afterEach(async () => {
	await box?.dispose();
	box = undefined;
	if (root) await rm(root, { recursive: true, force: true });
	root = undefined;
});

async function settings(options: {
	user?: unknown;
	project?: unknown;
	trusted?: boolean;
	env?: string;
}) {
	root = await mkdtemp(join(tmpdir(), "loop-settings-"));
	await mkdir(join(root, ".pi"));
	await writeFile(
		join(root, ".pi", "settings.json"),
		JSON.stringify({ loop: { statePath: options.project } }),
	);
	box = await createPiSession({
		cwd: root,
		projectTrusted: options.trusted ?? false,
		userSettings: { loop: { statePath: options.user } },
		env: { PI_LOOP_STATE_PATH: options.env },
	});
	return resolveSetting(
		{ getFlag: () => undefined },
		box.session.extensionRunner.createContext(),
		STATE_PATH_SETTING,
	);
}

describe("loop.statePath", () => {
	it.each([
		["default", {}, "default", DEFAULT_STATE_PATH],
		["user", { user: "/user.db" }, "user", "/user.db"],
		["env beats user", { user: "/user.db", env: "/env.db" }, "env", "/env.db"],
		[
			"trusted project beats user",
			{ user: "/user.db", project: "state/project.db", trusted: true },
			"project",
			"state/project.db",
		],
	])("resolves %s", async (_name, options, source, value) => {
		const resolved = await settings(options);
		expect(resolved).toEqual({ ok: true, source, value });
	});

	it("never reads untrusted project settings", async () => {
		const resolved = await settings({
			user: "/user.db",
			project: "/project.db",
			trusted: false,
		});
		expect(resolved.ok ? resolved.value : undefined).toBe("/user.db");
	});

	it("reports invalid winning values instead of falling through", async () => {
		const resolved = await settings({ user: "/user.db", env: " " });
		expect(resolved).toMatchObject({ ok: false, source: "env" });
	});

	it("resolves relative paths against the project and expands ~", () => {
		const cwd = resolve("/work/app");
		const absolute = resolve("/abs/state.db");
		expect(statePathFor(cwd, DEFAULT_STATE_PATH)).toBe(
			join(cwd, ".pi", "loop", "state.db"),
		);
		expect(statePathFor(cwd, absolute)).toBe(absolute);
		expect(parseStatePath("~/loop.db")).toMatch(/loop\.db$/u);
		for (const bad of ["", "  ", "\x01bad", null, 42])
			expect(() => parseStatePath(bad)).toThrow();
	});
});