gentle-pi 2.6.4 → 3.0.0

package/tests/windows-session-compile.test.ts

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import test from "node:test";
+import { FIXED_WINDOWS_POWERSHELL } from "../lib/windows-session-transport.ts";
+
+const fixture = fileURLToPath(new URL("fixtures/windows-session-compile.ps1", import.meta.url));
+const runtime = fileURLToPath(new URL("../runtime/windows-session-transport.ps1", import.meta.url));
+const execFileAsync = promisify(execFile);
+const maxOutputBytes = 4096;
+const maxErrors = 8;
+const maxLocation = 1_000_000;
+
+type CompilerEntry = Readonly<{ code: string; line: number; column: number }>;
+type CompilerOutcome = "not-compiled" | "compile-success" | "compile-errors";
+type CompilerControl = Readonly<{
+	kind: "windows-session-csharp-compile-control";
+	success: boolean;
+	sourceExtracted: boolean;
+	stage: "completed" | "source-parse" | "source-contract" | "compile" | "control-failure";
+	outcome: CompilerOutcome;
+	errorlist: readonly CompilerEntry[];
+	warnings?: readonly CompilerEntry[];
+}>;
+
+function isCompilerEntry(value: unknown): value is CompilerEntry {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const entry = value as Record<string, unknown>;
+	return Object.keys(entry).sort().join(",") === "code,column,line"
+		&& typeof entry.code === "string" && /^CS[0-9]{4}(?![\s\S])/.test(entry.code)
+		&& typeof entry.line === "number" && Number.isInteger(entry.line) && entry.line >= 0 && entry.line <= maxLocation
+		&& typeof entry.column === "number" && Number.isInteger(entry.column) && entry.column >= 0 && entry.column <= maxLocation;
+}
+function isCompilerEntries(value: unknown): value is CompilerEntry[] {
+	return Array.isArray(value) && value.length > 0 && value.length <= maxErrors && value.every(isCompilerEntry);
+}
+function compilerStage(value: unknown): CompilerControl["stage"] | undefined {
+	switch (value) {
+		case "completed": case "source-parse": case "source-contract": case "compile": case "control-failure": return value;
+		default: return undefined;
+	}
+}
+function compilerOutcome(value: unknown): CompilerOutcome | undefined {
+	switch (value) {
+		case "not-compiled": case "compile-success": case "compile-errors": return value;
+		default: return undefined;
+	}
+}
+
+export function parseCompilerControl(stdout: string): CompilerControl | undefined {
+	if (Buffer.byteLength(stdout, "utf8") > maxOutputBytes || !stdout.endsWith("\n")) return undefined;
+	const lines = stdout.slice(0, -1).split("\n");
+	if (lines.length !== 1 || lines[0].length === 0) return undefined;
+	let value: unknown;
+	try { value = JSON.parse(lines[0]); } catch { return undefined; }
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	const allowed = new Set(["kind", "success", "sourceExtracted", "stage", "outcome", "errorlist", "warnings"]);
+	if (Object.keys(record).some((key) => !allowed.has(key))
+		|| record.kind !== "windows-session-csharp-compile-control"
+		|| typeof record.success !== "boolean"
+		|| typeof record.sourceExtracted !== "boolean"
+		|| compilerStage(record.stage) === undefined
+		|| compilerOutcome(record.outcome) === undefined
+		|| !Array.isArray(record.errorlist) || record.errorlist.length > maxErrors || !record.errorlist.every(isCompilerEntry)) return undefined;
+	const warnings = record.warnings;
+	const stage = compilerStage(record.stage);
+	const outcome = compilerOutcome(record.outcome);
+	if (stage === undefined || outcome === undefined) return undefined;
+	const compileSuccess = outcome === "compile-success" && record.sourceExtracted && record.success && stage === "completed" && record.errorlist.length === 0;
+	const compileErrors = outcome === "compile-errors" && record.sourceExtracted && !record.success && stage === "compile" && record.errorlist.length > 0;
+	const notCompiledStage = (stage === "source-parse" && !record.sourceExtracted)
+		|| (stage === "source-contract" && !record.sourceExtracted)
+		|| stage === "control-failure";
+	const notCompiled = outcome === "not-compiled" && !record.success && record.errorlist.length === 0 && warnings === undefined && notCompiledStage;
+	if (!compileSuccess && !compileErrors && !notCompiled) return undefined;
+	const base: Omit<CompilerControl, "warnings"> = {
+		kind: "windows-session-csharp-compile-control",
+		success: record.success,
+		sourceExtracted: record.sourceExtracted,
+		stage,
+		outcome,
+		errorlist: Object.freeze([...record.errorlist]),
+	};
+	if (warnings === undefined) return Object.freeze(base);
+	if (!isCompilerEntries(warnings)) return undefined;
+	return Object.freeze({ ...base, warnings: Object.freeze([...warnings]) });
+}
+
+function control(value: Record<string, unknown>): string {
+	return `${JSON.stringify({ kind: "windows-session-csharp-compile-control", success: false, sourceExtracted: true, stage: "compile", outcome: "compile-errors", errorlist: [{ code: "CS1002", line: 12, column: 3 }], ...value })}\n`;
+}
+
+test("Windows bootstrap CSharp compile control parser accepts only consistent bounded records", () => {
+	const parsed = parseCompilerControl(control({}));
+	assert.ok(parsed);
+	assert.equal(parsed.outcome, "compile-errors");
+	assert.equal(parsed.success, false);
+	assert.equal(parsed.errorlist.length, 1);
+	for (const malformed of [
+		"null\n",
+		"[]\n",
+		"{}\n",
+		control({ unexpected: true }),
+		control({ outcome: "compile-success" }),
+		control({ sourceExtracted: false }),
+		control({ stage: "source-parse" }),
+		control({ stage: "source-contract", outcome: "not-compiled", errorlist: [] }),
+		control({ stage: "control-failure" }),
+		control({ errorlist: [] }),
+		control({ errorlist: Array.from({ length: maxErrors + 1 }, () => ({ code: "CS1002", line: 1, column: 1 })) }),
+		control({ errorlist: [{ code: "cs1002", line: 1, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002\n", line: 1, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002\r\n", line: 1, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002", line: 1.5, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002", line: -1, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002", line: maxLocation + 1, column: 1 }] }),
+		control({ errorlist: [{ code: "CS1002", line: 1, column: -1 }] }),
+		control({ errorlist: [{ code: "CS1002", line: 1, column: 1.5 }] }),
+		control({ errorlist: [{ code: "CS1002", line: 1, column: maxLocation + 1 }] }),
+		`${control({}).trimEnd()}\nextra\n`,
+		control({}).trimEnd(),
+		`${"x".repeat(maxOutputBytes)}\n`,
+	]) assert.equal(parseCompilerControl(malformed), undefined);
+	assert.equal(parseCompilerControl('{"kind":"windows-session-csharp-compile-control","success":false,"sourceExtracted":false,"stage":"source-contract","outcome":"not-compiled","errorlist":[]}\n')?.outcome, "not-compiled");
+});
+
+test("Windows bootstrap pinned enumeration has no unreachable post-loop return", async () => {
+	const source = await readFile(runtime, "utf8");
+	const start = source.indexOf("static string[] EnumeratePinned(IntPtr directory)");
+	const end = source.indexOf("public static int EnumeratePresence()", start);
+	assert.ok(start >= 0 && end > start, "source guard: pinned enumeration bounds were not found");
+	const enumeration = source.slice(start, end);
+	assert.equal((enumeration.match(/return names\.ToArray\(\);/g) ?? []).length, 1, "source guard: the infinite enumeration loop must not have a post-loop return");
+});
+
+test("Windows bootstrap CSharp compile control source guard uses an owned created temp root", async () => {
+	const source = await readFile(fixture, "utf8");
+	assert.match(source, /\[System\.Management\.Automation\.Language\.Parser\]::ParseFile\(/);
+	assert.match(source, /\[Microsoft\.CSharp\.CSharpCodeProvider\]::new\(\)/);
+	assert.match(source, /CompileAssemblyFromSource\(/);
+	assert.match(source, /GenerateInMemory\s*=\s*\$true/);
+	assert.match(source, /ReferencedAssemblies\.Add\("System\.dll"\)/);
+	assert.match(source, /ReferencedAssemblies\.Add\("System\.Core\.dll"\)/);
+	const createRoot = source.indexOf("CreateDirectory($tempRoot)");
+	const createCollection = source.indexOf("TempFileCollection]::new($tempRoot, $false)");
+	assert.ok(createRoot >= 0 && createRoot < createCollection, "source guard: fixture creates its owned temp root before CodeDom receives it");
+	assert.match(source, /\$provider\.Dispose\(\)/);
+	assert.match(source, /\$tempFiles\.Dispose\(\)/);
+	assert.doesNotMatch(source, /Invoke-Expression|\bInvoke-Command\b|\.\s+\$\w+|\[WindowsSessionBootstrap\]::/);
+});
+
+test("Windows bootstrap CSharp compile control reports comparison outcome", { skip: process.platform !== "win32", timeout: 40_000 }, async (t) => {
+	let result: { stdout: string; stderr: string };
+	try {
+		// execFile resolves only after its owned child has exited and its stdio is closed.
+		result = await execFileAsync(FIXED_WINDOWS_POWERSHELL, ["-NoLogo", "-NoProfile", "-NonInteractive", "-File", fixture, "-SourcePath", runtime], { shell: false, windowsHide: true, timeout: 30_000, maxBuffer: maxOutputBytes });
+	} catch (error: unknown) {
+		const captured = error as Readonly<{ stdout?: string; stderr?: string }>;
+		result = { stdout: captured.stdout ?? "", stderr: captured.stderr ?? "" };
+	}
+	assert.equal(result.stderr, "", "compile control emitted non-JSON diagnostics");
+	const parsed = parseCompilerControl(result.stdout);
+	assert.ok(parsed, "compile control did not return a valid bounded result");
+	t.diagnostic(JSON.stringify({ outcome: parsed.outcome, success: parsed.success, errorlist: parsed.errorlist, warnings: parsed.warnings }));
+	assert.equal(parsed.sourceExtracted, true, "compile control did not extract the Add-Type literal");
+	assert.ok(parsed.outcome === "compile-success" || parsed.outcome === "compile-errors", "compile control did not complete compilation");
+});