Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/nushell/__serial__/diagnostic-help.test.ts

Raw
import type { ExecFileOptions } from "node:child_process";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const { execute } = vi.hoisted(() => ({ execute: vi.fn() }));
vi.mock("node:child_process", async () => {
	const actual =
		await vi.importActual<typeof import("node:child_process")>(
			"node:child_process",
		);
	const { promisify } = await import("node:util");
	return {
		...actual,
		execFile: Object.defineProperty(vi.fn(), promisify.custom, {
			value: execute,
		}),
	};
});

import { diagnosticHelp } from "../diagnostic-help.ts";

const source = "version --bogus";
const flagSpan = { start: 1008, end: 1015 };
let block: { span: { start: number; end: number }; pipelines: unknown[] };
let error: unknown;
let declarations: unknown[];
let help: string;
let serialized: string | undefined;

beforeEach(() => {
	block = {
		span: { start: 1000, end: 1015 },
		pipelines: [
			{
				elements: [
					{
						expr: {
							expr: {
								Call: {
									decl_id: 52,
									head: { start: 1000, end: 1007 },
									arguments: [],
								},
							},
							span: { start: 1000, end: 1015 },
						},
					},
				],
			},
		],
	};
	error = { UnknownFlag: ["version", "bogus", flagSpan, "help"] };
	declarations = [{ decl_id: 52, name: "version", type: "built-in" }];
	help = "Usage:\n  > version {flags}\n";
	serialized = undefined;
	execute.mockImplementation(
		async (_binary: string, args: string[], options: ExecFileOptions) => {
			if (options.signal?.aborted) throw new Error("aborted");
			return {
				stdout:
					args.at(-1) === "help $env.PI_NU_HELP_TARGET"
						? help
						: (serialized ??
							JSON.stringify({
								block: JSON.stringify(block),
								error: JSON.stringify(error),
								commands: declarations,
							})),
			};
		},
	);
});
afterEach(() => {
	vi.clearAllMocks();
});

function requestedHelp(): boolean {
	return execute.mock.calls.some(
		([, args]) => args.at(-1) === "help $env.PI_NU_HELP_TARGET",
	);
}

describe("Nu-native help analysis boundaries", () => {
	it.each(["not-json", "{}", '{"block":"not-json","error":"{}"}'])(
		"ignores malformed analysis: %s",
		async (data) => {
			serialized = data;
			await expect(
				diagnosticHelp("nu", source, process.cwd()),
			).resolves.toBeUndefined();
			expect(requestedHelp()).toBe(false);
		},
	);

	it.each([
		{ UnknownFlag: ["version", "bogus", { start: -1, end: 1015 }] },
		{ UnknownFlag: ["version", "bogus", { start: 1008, end: 5000 }] },
		{ UnknownFlag: ["version", "bogus", { start: 10, end: 17 }] },
		{ ExtraPositional: ["version", { start: 10, end: 17 }] },
		{ CantConvert: ["int", "string", flagSpan] },
		{ UnknownFlag: ["other command", "bogus", flagSpan] },
		null,
	])(
		"does not attach help for unrelated or invalid errors: %j",
		async (data) => {
			error = data;
			await expect(
				diagnosticHelp("nu", source, process.cwd()),
			).resolves.toBeUndefined();
			expect(requestedHelp()).toBe(false);
		},
	);

	it("rejects source/AST size mismatches and ambiguous owning calls", async () => {
		block.span.end++;
		await expect(
			diagnosticHelp("nu", source, process.cwd()),
		).resolves.toBeUndefined();
		block.span.end--;
		block.pipelines.push(block.pipelines[0]);
		await expect(
			diagnosticHelp("nu", source, process.cwd()),
		).resolves.toBeUndefined();
		expect(requestedHelp()).toBe(false);
	});

	it("does not describe a local shadowing declaration using built-in help", async () => {
		declarations = [{ decl_id: 1, name: "version", type: "built-in" }];
		await expect(
			diagnosticHelp("nu", source, process.cwd()),
		).resolves.toBeUndefined();
		expect(requestedHelp()).toBe(false);
	});

	it("bounds help without ANSI while preserving command identity", async () => {
		help = `\x1b[31m${"🙂 documentation\n".repeat(2000)}\x1b[0m`;
		const result = await diagnosticHelp("nu", source, process.cwd());
		expect(result).toMatchObject({ command: "version", truncated: true });
		expect(Buffer.byteLength(result?.text ?? "")).toBeLessThanOrEqual(8192);
		expect(result?.text).not.toContain("\x1b");
	});

	it("passes source as data, never executable code", async () => {
		await diagnosticHelp("nu", source, process.cwd());
		expect(execute.mock.calls[0]?.[1]).not.toContain(source);
		expect(execute.mock.calls[0]?.[2].env).toMatchObject({
			PI_NU_HELP_SOURCE: source,
		});
	});

	it("quietly preserves failures when native analysis fails", async () => {
		execute.mockRejectedValue(new Error("output limit / executable failure"));
		await expect(
			diagnosticHelp("nu", source, process.cwd()),
		).resolves.toBeUndefined();
	});

	it("cancels after native analysis without starting a help lookup", async () => {
		const controller = new AbortController();
		const normal = execute.getMockImplementation()!;
		execute.mockImplementation(
			async (binary: string, args: string[], options: ExecFileOptions) => {
				const result = await normal(binary, args, options);
				controller.abort();
				return result;
			},
		);
		await expect(
			diagnosticHelp("nu", source, process.cwd(), controller.signal),
		).resolves.toBeUndefined();
	});

	it("uses one deadline for native analysis and help", async () => {
		execute.mockImplementation(
			(_binary: string, _args: string[], options: ExecFileOptions) =>
				new Promise((_resolve, reject) => {
					options.signal?.addEventListener(
						"abort",
						() => reject(new Error("aborted")),
						{ once: true },
					);
				}),
		);
		await expect(
			diagnosticHelp("nu", source, process.cwd(), undefined, 10),
		).resolves.toBeUndefined();
	});
});