pi-ext

import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import { findNu } from "../runtime.ts";

const extensionPath = path.resolve(import.meta.dirname, "../index.ts");

type Case = {
	user?: unknown;
	project?: unknown;
	env?: string;
	flag?: boolean;
	untrusted?: boolean;
};

describe.runIf(Boolean(findNu()))("nushell.enable resolution", () => {
	let session: PiSession | undefined;
	let root: string | undefined;
	afterEach(async () => {
		await session?.dispose();
		session = undefined;
		if (root) rmSync(root, { recursive: true, force: true });
		root = undefined;
		vi.restoreAllMocks();
	});

	async function start(input: Case) {
		root = mkdtempSync(path.join(tmpdir(), "pi-ext-nushell-settings-"));
		const userSettings =
			"user" in input ? { nushell: { enable: input.user } } : undefined;
		if ("project" in input) {
			const dir = path.join(root, ".pi");
			mkdirSync(dir, { recursive: true });
			writeFileSync(
				path.join(dir, "settings.json"),
				JSON.stringify({ nushell: { enable: input.project } }),
			);
		}
		session = await createPiSession({
			cwd: root,
			extensionPaths: [extensionPath],
			env: { PI_NUSHELL_ENABLE: input.env },
			...(userSettings ? { userSettings } : {}),
		});
		if (input.untrusted)
			session.session.settingsManager.setProjectTrusted(false);
		const runner = session.session.extensionRunner;
		const notify = vi.spyOn(runner.createCommandContext().ui, "notify");
		if (input.flag !== undefined) runner.setFlagValue("nushell", input.flag);
		await runner.emit({ type: "session_start", reason: "startup" });
		const warnings = notify.mock.calls
			.filter((call) => call[1] === "warning")
			.map((call) => call[0]);
		return {
			active: session.session.getActiveToolNames().includes("nu"),
			warnings,
		};
	}

	it("registers --nushell without a default so omission stays distinct", async () => {
		const { active, warnings } = await start({});
		expect(active).toBe(false);
		expect(warnings).toEqual([]);
		expect(
			session?.session.extensionRunner.getFlags().get("nushell")?.default,
		).toBe(undefined);
		expect(
			session?.session.extensionRunner.getFlagValues().has("nushell"),
		).toBe(false);
	});

	it.each([
		["user true", { user: true }, true],
		["project false over user true", { user: true, project: false }, false],
		["project true over user false", { user: false, project: true }, true],
		["env false over project true", { project: true, env: "false" }, false],
		["env 1 over user false", { user: false, env: "1" }, true],
		["env 0 over user true", { user: true, env: "0" }, false],
		["flag over env false", { env: "false", flag: true }, true],
		["flag over project false", { project: false, flag: true }, true],
		[
			"untrusted project ignored",
			{ user: true, project: false, untrusted: true },
			true,
		],
		[
			"untrusted project true ignored",
			{ project: true, untrusted: true },
			false,
		],
	] satisfies [string, Case, boolean][])(
		"%s",
		async (_name, input, expected) => {
			const { active, warnings } = await start(input);
			expect(active).toBe(expected);
			// Discovery warnings wait until the first prompt, after all extensions load.
			expect(warnings).toEqual([]);
		},
	);

	it.each([
		[
			"empty env",
			{ user: true, env: "" },
			"environment variable PI_NUSHELL_ENABLE",
		],
		[
			"string env",
			{ user: true, env: "yes" },
			"environment variable PI_NUSHELL_ENABLE",
		],
		["string project", { user: true, project: "true" }, "project settings"],
		["null project", { user: true, project: null }, "project settings"],
		["numeric user", { user: 1 }, "user settings"],
	] satisfies [string, Case, string][])(
		"rejects %s without falling through",
		async (_name, input, source) => {
			const { active, warnings } = await start(input);
			expect(active).toBe(false);
			// Session start emits once, so dedupe guards against repeated notices.
			expect([...new Set(warnings)]).toEqual([
				`Invalid nushell.enable from ${source}; tools unchanged`,
			]);
		},
	);
});