Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/memory/__tests__/settings.test.ts

Raw
import { 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);
	});
});