import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, expect, it, vi } from "vitest"; import { Client } from "../src/client.ts"; import { normalize } from "../src/result.ts"; import { bounded, LspFailure } from "../src/source.ts"; import { peer } from "./peer.ts"; const owned: Client[] = []; const directories: string[] = []; afterEach(async () => { await Promise.all(owned.splice(0).map((client) => client.close())); await Promise.all( directories .splice(0) .map((directory) => rm(directory, { recursive: true, force: true })), ); }); async function setup(mode = "normal") { const root = await mkdtemp(join(tmpdir(), "pi-lsp-peer-")); directories.push(root); const file = join(root, "main.go"); await writeFile(file, "package fixture\nvar Value = 1\n"); const client = new Client(root, await peer(root, mode), process.execPath); owned.push(client); return { root, file, client }; } function signal(ms = 3000) { return AbortSignal.timeout(ms); } it("honors configuration, denies edits, syncs external managed/unopened changes and versions", async () => { const { root, file, client } = await setup(); const dependency = join(root, "dep.go"); await writeFile(dependency, "package fixture\nvar Dependency = 1\n"); const first = (await client.query("hover", file, 2, 5, signal())) as { contents: string; }; const state = JSON.parse(first.contents); expect(state.configuration).toEqual([{ marker: "normal" }]); expect(state.denied).toMatchObject({ applied: false }); expect(state.commandDenied).toBe(true); expect(state.registered).toBe(false); expect(await readFile(file, "utf8")).toBe("package fixture\nvar Value = 1\n"); expect(state.documents[0][1]).toMatchObject({ version: 1, text: "package fixture\nvar Value = 1\n", }); await writeFile(file, "package fixture\nvar Other = 2\n"); await writeFile(dependency, "package fixture\nvar Dependency = 2\n"); const second = JSON.parse( ( (await client.query("hover", file, 2, 5, signal())) as { contents: string; } ).contents, ); expect(second.documents[0][1]).toMatchObject({ version: 2, text: "package fixture\nvar Other = 2\n", }); expect(second.changes).toContainEqual({ uri: new URL(`file://${dependency}`).href, type: 2, }); await rm(dependency); const third = JSON.parse( ( (await client.query("hover", file, 2, 5, signal())) as { contents: string; } ).contents, ); expect(third.changes).toContainEqual({ uri: new URL(`file://${dependency}`).href, type: 3, }); }); it("isolates process state by root/config and rejects unsupported capability", async () => { const a = await setup(); const b = await setup("unsupported"); const first = JSON.parse( ( (await a.client.query("hover", a.file, 2, 5, signal())) as { contents: string; } ).contents, ); const other = JSON.parse( ( (await b.client.query("hover", b.file, 2, 5, signal())) as { contents: string; } ).contents, ); expect(first.pid).not.toBe(other.pid); expect(other.configuration).toEqual([{ marker: "unsupported" }]); for (const operation of [ "definition", "type_definition", "implementations", ] as const) { await expect( b.client.query(operation, b.file, 2, 5, signal()), ).rejects.toMatchObject({ status: "unsupported" }); } }); it("preserves application error code zero and malformed-result failure boundaries", async () => { const failing = await setup("error"); await expect( failing.client.query("definition", failing.file, 2, 5, signal()), ).rejects.toMatchObject({ code: 0, message: "application failure" }); const malformed = await setup("malformed"); const raw = await malformed.client.query( "definition", malformed.file, 2, 5, signal(), ); await expect( normalize( malformed.client, "definition", malformed.file, raw, 10, 2048, signal(), ), ).rejects.toMatchObject({ status: "server_failure" }); }); it("rejects a cross-file selection when query source changes after directory observation", async () => { const { root, file, client } = await setup("ambiguous-cross"); await mkdir(join(root, "nested")); await writeFile( join(root, "nested/other.go"), "package fixture\nvar Other = 1\n", ); const ready = (await client.query( "incoming_calls", file, 2, 5, signal(), )) as { candidates: { selection: string }[] }; const selection = ready.candidates[1]?.selection; if (!selection) throw new Error("Missing cross-file candidate"); // Control the filesystem race; assert the public query outcome, not internal call counts. const observing = client as unknown as { observe(file: string, signal: AbortSignal): Promise; }; const observe = observing.observe.bind(client); const barrier = vi .spyOn(observing, "observe") .mockImplementationOnce(async (path, abort) => { await observe(path, abort); await writeFile(file, "package fixture\nvar Value = 2\n"); }); try { await expect( client.query( "incoming_calls", file, 2, 5, signal(), undefined, selection, ), ).rejects.toMatchObject({ status: "stale_selection" }); } finally { barrier.mockRestore(); } }); it("settles cancellation locally and ignores a late successful reply", async () => { const { client, file } = await setup("delay"); await client.query("hover", file, 2, 5, signal()); const controller = new AbortController(); const reason = new LspFailure("cancelled", "cancelled"); const started = performance.now(); const work = client.query("definition", file, 2, 5, controller.signal); setTimeout(() => controller.abort(reason), 25); await expect(work).rejects.toBe(reason); expect(performance.now() - started).toBeLessThan(500); await new Promise((resolve) => setTimeout(resolve, 250)); const later = await client.query("references", file, 2, 5, signal()); expect(later).toEqual([]); }); it("bounds initialize wait and escalates stubborn cleanup with actual process exit", async () => { const { client, file } = await setup("init-hang"); await expect( client.query("definition", file, 2, 5, signal(50)), ).rejects.toBeDefined(); await client.close(); await client.exited; expect( client.child.exitCode !== null || client.child.signalCode !== null, ).toBe(true); const stubborn = await setup("stubborn"); await stubborn.client.query("hover", stubborn.file, 2, 5, signal()); const start = performance.now(); await stubborn.client.close(); expect(performance.now() - start).toBeLessThan(1500); await stubborn.client.exited; expect( stubborn.client.child.exitCode !== null || stubborn.client.child.signalCode !== null, ).toBe(true); if (process.platform !== "win32") expect(stubborn.client.child.signalCode).toBe("SIGKILL"); }); it("reaps a stubborn peer even when the protocol connection is already disposed", async () => { const { client, file } = await setup("stubborn"); await client.query("hover", file, 2, 5, signal()); client.connection.dispose(); const start = performance.now(); await client.close(); await client.exited; expect(performance.now() - start).toBeLessThan(1500); expect( client.child.exitCode !== null || client.child.signalCode !== null, ).toBe(true); if (process.platform !== "win32") expect(client.child.signalCode).toBe("SIGKILL"); }); it.each(["flood", "partial"])( "terminates %s transport without implementing protocol framing", async (mode) => { const { client, file } = await setup(mode); await expect( bounded(client.query("definition", file, 2, 5, signal()), signal()), ).rejects.toBeDefined(); await client.close(); expect( client.child.exitCode !== null || client.child.signalCode !== null, ).toBe(true); }, );