repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/memory/__tests__/settings.test.ts
Rawimport { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { homedir, tmpdir } from "node:os";
import { join } 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 {
DATABASE_SETTING,
defaultDatabasePath,
parseDatabasePath,
} 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(), "memory-settings-"));
await mkdir(join(root, ".pi"));
await writeFile(
join(root, ".pi", "settings.json"),
JSON.stringify({ memory: { databasePath: options.project } }),
);
box = await createPiSession({
cwd: root,
projectTrusted: options.trusted ?? false,
userSettings: { memory: { databasePath: options.user } },
env: { PI_MEMORY_DATABASE_PATH: options.env },
});
return {
ctx: box.session.extensionRunner.createContext(),
pi: { getFlag: () => undefined },
};
}
describe("memory settings", () => {
it.each([
[
"default",
{},
"default",
"OS user-data directory/pi-ext/memory/memory.sqlite",
],
["user", { user: "/user.sqlite" }, "user", "/user.sqlite"],
[
"env beats user",
{ user: "/user.sqlite", env: "/env.sqlite" },
"env",
"/env.sqlite",
],
[
"trusted project beats user",
{ user: "/user.sqlite", project: "/project.sqlite", trusted: true },
"project",
"/project.sqlite",
],
[
"env beats trusted project",
{
user: "/user.sqlite",
project: "/project.sqlite",
trusted: true,
env: "/env.sqlite",
},
"env",
"/env.sqlite",
],
])("resolves %s", async (_name, options, source, value) => {
const { ctx, pi } = await settings(options);
const resolved = resolveSetting(pi, ctx, DATABASE_SETTING);
expect(resolved.source).toBe(source);
expect(resolved.ok ? resolved.value : undefined).toBe(value);
});
it("never reads untrusted project settings", async () => {
const { ctx, pi } = await settings({
user: "/user.sqlite",
project: "/project.sqlite",
trusted: false,
});
const resolved = resolveSetting(pi, ctx, DATABASE_SETTING);
expect(resolved.ok ? resolved.value : undefined).toBe("/user.sqlite");
});
it("reports invalid winning values instead of falling through", async () => {
const { ctx, pi } = await settings({ env: "relative/path" });
const resolved = resolveSetting(pi, ctx, DATABASE_SETTING);
expect(resolved.ok).toBe(false);
if (!resolved.ok) expect(resolved.error).toMatch(/absolute/u);
});
it("expands ~ and rejects empty and relative paths", () => {
expect(parseDatabasePath("~/Notes/memory.sqlite")).toBe(
join(homedir(), "Notes", "memory.sqlite"),
);
expect(parseDatabasePath("/abs/memory.sqlite")).toBe("/abs/memory.sqlite");
for (const bad of ["", " ", "relative.sqlite", "\x01/bad", null, 42]) {
expect(() => parseDatabasePath(bad)).toThrow();
}
});
it("defaults to the OS user-data directory", () => {
const fallback = defaultDatabasePath();
expect(fallback).toContain("pi-ext");
expect(fallback.endsWith("memory.sqlite")).toBe(true);
});
});