repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
scripts/codegen/pi-ext-settings.test.ts
Rawimport { 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",
});
});