Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/codegen/pi-ext-settings.test.ts

Raw
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, expect, it } from "vitest";
import { sandboxEnv, withProcessEnv } from "../../test/fixture/env.ts";
import {
	defineChoiceSetting,
	defineIntegerSetting,
	parseNumberSetting,
	resolveSetting,
	type SettingDeclaration,
} from "./templates/pi-ext-settings.ts";

let root: string | undefined;
afterEach(() => {
	if (root) rmSync(root, { recursive: true, force: true });
	root = undefined;
});

function resolve<T>(
	declaration: SettingDeclaration<T>,
	input: {
		user?: unknown;
		project?: unknown;
		env?: Record<string, string>;
		flags?: Record<string, string | boolean>;
		trusted?: boolean;
	},
) {
	root = mkdtempSync(join(tmpdir(), "pi-ext-settings-"));
	const env = sandboxEnv(root, input.env ? { env: input.env } : {});
	const write = (dir: string, value: unknown) => {
		mkdirSync(dir, { recursive: true });
		writeFileSync(join(dir, "settings.json"), JSON.stringify(value));
	};
	if (input.user !== undefined)
		write(join(env["HOME"] ?? "", ".pi/agent"), input.user);
	if (input.project !== undefined) write(join(root, ".pi"), input.project);
	const cwd = root;
	return withProcessEnv(env, () =>
		resolveSetting(
			{ getFlag: (name) => input.flags?.[name] },
			{ cwd, isProjectTrusted: () => input.trusted ?? true },
			declaration,
		),
	);
}

const block: SettingDeclaration<Record<string, unknown>> = {
	key: "demo",
	parse: (raw) => {
		if (typeof raw !== "object" || raw === null || Array.isArray(raw))
			return undefined;
		const value = raw as Record<string, unknown>;
		if ("bad" in value) throw new Error("demo.bad is not allowed");
		return value;
	},
	default: {},
};

it("deep-merges objects project over user, replacing arrays and scalars", async () => {
	const result = await resolve(block, {
		user: {
			demo: { a: 1, list: [1, 2], nested: { keep: true, over: "user" } },
		},
		project: { demo: { list: [3], nested: { over: "project" } } },
	});
	expect(result).toEqual({
		ok: true,
		source: "project",
		value: {
			a: 1,
			list: [3],
			nested: { keep: true, over: "project" },
		},
	});
});

it("keeps __proto__ keys as own properties when merging", async () => {
	root = mkdtempSync(join(tmpdir(), "pi-ext-settings-"));
	const env = sandboxEnv(root);
	const agent = join(env["HOME"] ?? "", ".pi/agent");
	mkdirSync(agent, { recursive: true });
	mkdirSync(join(root, ".pi"), { recursive: true });
	writeFileSync(join(agent, "settings.json"), '{"demo":{"a":1}}');
	writeFileSync(
		join(root, ".pi", "settings.json"),
		'{"demo":{"__proto__":{"polluted":true}}}',
	);
	const cwd = root;
	const result = await withProcessEnv(env, () =>
		resolveSetting(
			{ getFlag: () => undefined },
			{ cwd, isProjectTrusted: () => true },
			block,
		),
	);
	if (!result.ok) throw new Error(result.error);
	expect(Object.hasOwn(result.value, "__proto__")).toBe(true);
	expect(Object.getPrototypeOf(result.value)).toBe(Object.prototype);
	expect(({} as Record<string, unknown>)["polluted"]).toBeUndefined();
});

it("parses numbers from settings and numeric strings from env or flags only", () => {
	expect(parseNumberSetting(70, "user")).toBe(70);
	expect(parseNumberSetting("70", "env")).toBe(70);
	expect(parseNumberSetting("2.5", "flag")).toBe(2.5);
	expect(parseNumberSetting("70", "project")).toBeUndefined();
	for (const raw of ["", " ", "abc", "Infinity", Number.NaN, true, null])
		expect(parseNumberSetting(raw, "env"), String(raw)).toBeUndefined();
});

it("derives strict enum validation from the declared choices", async () => {
	const setting = defineChoiceSetting({
		key: "demo.engine",
		default: "fast",
		choices: ["fast", "quality"],
		label: "Engine",
		description: "Choose an engine.",
		env: "PI_DEMO_ENGINE",
	});
	expect(setting.choices).toEqual(["fast", "quality"]);
	expect(setting.label).toBe("Engine");
	for (const source of ["user", "project", "env", "flag"] as const) {
		expect(setting.parse("quality", source)).toBe("quality");
		for (const raw of [true, 1, null, undefined, "", "unknown", " fast"])
			expect(() => setting.parse(raw, source)).toThrow("expected one of:");
	}
	expect(await resolve(setting, {})).toEqual({
		ok: true,
		source: "default",
		value: "fast",
	});
	expect(
		await resolve(setting, {
			user: { demo: { engine: "quality" } },
			env: { PI_DEMO_ENGINE: "unknown" },
		}),
	).toMatchObject({ ok: false, source: "env" });
	expect(() =>
		defineChoiceSetting({ key: "bad", default: "missing", choices: ["fast"] }),
	).toThrow("Invalid choice declaration");
	expect(() =>
		defineChoiceSetting({ key: "bad", default: "missing", choices: [] }),
	).toThrow("Invalid choice declaration");
});

it("preserves unset enum defaults without accepting explicit unset or invalid inputs", async () => {
	const setting = defineChoiceSetting({
		key: "demo.thinking",
		choices: ["low", "high"],
		default: undefined,
	});
	expect(await resolve(setting, {})).toEqual({
		ok: true,
		source: "default",
		value: undefined,
	});
	expect(
		await resolve(setting, { user: { demo: { thinking: "high" } } }),
	).toEqual({ ok: true, source: "user", value: "high" });
	expect(
		await resolve(setting, {
			user: { demo: { thinking: "high" } },
			project: { demo: { thinking: null } },
		}),
	).toMatchObject({ ok: false, source: "project" });
	expect(setting.parse(undefined, "default")).toBeUndefined();
	for (const source of ["user", "project", "env", "flag"] as const) {
		for (const value of [undefined, null, true, "", "auto", "HIGH"])
			expect(() => setting.parse(value, source)).toThrow("expected one of:");
	}
	expect(() =>
		defineChoiceSetting({ key: "bad", choices: [], default: undefined }),
	).toThrow("Invalid choice declaration");
});

it("derives integer validation without coercing JSON strings or booleans", async () => {
	const setting = defineIntegerSetting({
		key: "demo.threads",
		default: undefined,
		range: { min: 1, max: 8 },
		env: "PI_DEMO_THREADS",
	});
	for (const source of ["user", "project", "env", "flag"] as const) {
		for (const raw of [1, 8]) expect(setting.parse(raw, source)).toBe(raw);
		for (const raw of [
			true,
			false,
			null,
			undefined,
			[],
			{},
			0,
			9,
			1.5,
			Number.NaN,
			Infinity,
			"",
		])
			expect(() => setting.parse(raw, source)).toThrow("expected an integer");
	}
	for (const source of ["user", "project"] as const)
		expect(() => setting.parse("4", source)).toThrow("expected an integer");
	for (const source of ["env", "flag"] as const)
		expect(setting.parse("4", source)).toBe(4);
	expect(setting.parse(undefined, "default")).toBeUndefined();
	expect(await resolve(setting, {})).toEqual({
		ok: true,
		source: "default",
		value: undefined,
	});
	expect(
		await resolve(setting, {
			user: { demo: { threads: 4 } },
			project: { demo: { threads: true } },
		}),
	).toMatchObject({ ok: false, source: "project" });
	expect(
		await resolve(setting, { user: { demo: { threads: "4" } } }),
	).toMatchObject({ ok: false, source: "user" });
});

it("validates integer declaration bounds, defaults, and step alignment", () => {
	const setting = defineIntegerSetting({
		key: "demo.count",
		default: 2,
		range: { min: -2, max: 8, step: 2 },
	});
	for (const value of [-2, 0, 2, 8])
		expect(setting.parse(value, "user")).toBe(value);
	expect(() => setting.parse(3, "user")).toThrow("steps of 2");
	for (const range of [
		{ min: 8, max: 1 },
		{ min: 1.5, max: 8 },
		{ min: 1, max: Infinity },
		{ min: 1, max: 8, step: 0 },
		{ min: 1, max: 8, step: 1.5 },
		{ min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
	])
		expect(() =>
			defineIntegerSetting({ key: "bad", default: undefined, range }),
		).toThrow("Invalid integer declaration");
	expect(() =>
		defineIntegerSetting({ key: "bad", default: 9, range: { min: 1, max: 8 } }),
	).toThrow("Invalid integer declaration");
});

it("ignores untrusted project objects", async () => {
	const result = await resolve(block, {
		user: { demo: { a: 1 } },
		project: { demo: { a: 2 } },
		trusted: false,
	});
	expect(result).toEqual({ ok: true, source: "user", value: { a: 1 } });
});

it("reports thrown parser messages with the merged source", async () => {
	const result = await resolve(block, {
		user: { demo: { a: 1 } },
		project: { demo: { bad: true } },
	});
	expect(result).toEqual({
		ok: false,
		source: "project",
		error:
			"Invalid demo from merged project and user settings: demo.bad is not allowed",
	});
});

it("keeps a non-object project value from falling through or merging", async () => {
	const result = await resolve(block, {
		user: { demo: { a: 1 } },
		project: { demo: "oops" },
	});
	expect(result).toEqual({
		ok: false,
		source: "project",
		error: "Invalid demo from project settings",
	});
});

it("prefers flag, then env, over settings", async () => {
	const text: SettingDeclaration<string> = {
		key: "demo.name",
		parse: (raw) => (typeof raw === "string" ? raw : undefined),
		default: "default",
		flag: { name: "demo-name", type: "string", description: "demo" },
		env: "PI_DEMO_NAME",
	};
	const settings = { user: { demo: { name: "user" } } };
	expect(
		await resolve(text, {
			...settings,
			env: { PI_DEMO_NAME: "env" },
			flags: { "demo-name": "flag" },
		}),
	).toEqual({ ok: true, source: "flag", value: "flag" });
	expect(
		await resolve(text, { ...settings, env: { PI_DEMO_NAME: "env" } }),
	).toEqual({ ok: true, source: "env", value: "env" });
	expect(await resolve(text, {})).toEqual({
		ok: true,
		source: "default",
		value: "default",
	});
});