pi-lens 3.1.2 → 3.2.0

package/clients/lsp/__tests__/launch.test.ts

@@ -1,6 +1,6 @@
 /**
  * LSP Launch Utilities Test Suite
- * 
+ *
  * Tests for launching LSP servers including:
  * - Direct binary execution
  * - Package manager execution (npx/bun)
@@ -9,12 +9,12 @@
  * - Process cleanup
  */
 
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { spawn, type SpawnOptions, type ChildProcess } from "child_process";
+import { type ChildProcess, spawn } from "node:child_process";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
 	launchLSP,
-	launchViaPackageManager,
 	launchViaNode,
+	launchViaPackageManager,
 	launchViaPython,
 	stopLSP,
 } from "../launch.js";
@@ -27,16 +27,30 @@ vi.mock("child_process", () => ({
 const mockSpawn = vi.mocked(spawn);
 
 // Helper to create mock child process
-function createMockChildProcess(pid: number = 123): Partial<ChildProcess> {
-	return {
+function createMockChildProcess(
+	pid: number = 123,
+): Partial<ChildProcess> & { _emit: (event: string, ...args: any[]) => void } {
+	const handlers = new Map<string, Array<(...args: any[]) => void>>();
+	const mockObj: any = {
 		pid,
 		stdin: { write: vi.fn() } as any,
 		stdout: { on: vi.fn(), pipe: vi.fn() } as any,
 		stderr: { on: vi.fn(), pipe: vi.fn() } as any,
 		kill: vi.fn(),
-		on: vi.fn(),
-		connected: true,
+		exitCode: null,
+		killed: false,
+		on(event: string, handler: (...args: any[]) => void) {
+			if (!handlers.has(event)) {
+				handlers.set(event, []);
+			}
+			handlers.get(event)?.push(handler);
+			return mockObj;
+		},
+		_emit(event: string, ...args: any[]) {
+			handlers.get(event)?.forEach((h) => h(...args));
+		},
 	};
+	return mockObj;
 }
 
 describe("launchLSP", () => {
@@ -48,11 +62,20 @@ describe("launchLSP", () => {
 		const mockProcess = createMockChildProcess();
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		launchLSP("typescript-language-server", ["--stdio"], { cwd: "/test" });
+		// Start the async operation
+		const launchPromise = launchLSP("typescript-language-server", ["--stdio"], {
+			cwd: "/test",
+		});
+
+		// Let the 50ms timeout pass
+		await new Promise((r) => setTimeout(r, 60));
+
+		// Now complete by resolving
+		const _result = await launchPromise;
 
 		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd, args, options] = mockSpawn.mock.calls[0];
-		
+		const [cmd, _args, options] = mockSpawn.mock.calls[0];
+
 		// Command should be provided (format depends on platform)
 		expect(cmd).toBeTruthy();
 		expect(options).toMatchObject({
@@ -68,7 +91,10 @@ describe("launchLSP", () => {
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
 		const customEnv = { CUSTOM_VAR: "value" };
-		launchLSP("server", [], { env: customEnv });
+		const launchPromise = launchLSP("server", [], { env: customEnv });
+
+		await new Promise((r) => setTimeout(r, 60));
+		await launchPromise;
 
 		const [, , options] = mockSpawn.mock.calls[0];
 		expect(options?.env).toMatchObject({
@@ -80,7 +106,9 @@ describe("launchLSP", () => {
 		const mockProcess = createMockChildProcess(456);
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		const result = launchLSP("server", [], {});
+		const launchPromise = launchLSP("server", [], {});
+		await new Promise((r) => setTimeout(r, 60));
+		const result = await launchPromise;
 
 		expect(result.pid).toBe(456);
 		expect(result.stdin).toBeDefined();
@@ -89,31 +117,55 @@ describe("launchLSP", () => {
 	});
 
 	it("should throw if stdin is not available", async () => {
-		const mockProcess = { ...createMockChildProcess(), stdin: null };
+		const baseMock = createMockChildProcess();
+		const mockProcess = {
+			...baseMock,
+			stdin: null,
+			on: baseMock.on,
+			_emit: baseMock._emit,
+		};
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
+		// Use wrapper function for proper async error catching
+		const launchFn = async () => launchLSP("server", [], {});
+		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
 	});
 
 	it("should throw if stdout is not available", async () => {
-		const mockProcess = { ...createMockChildProcess(), stdout: null };
+		const baseMock = createMockChildProcess();
+		const mockProcess = {
+			...baseMock,
+			stdout: null,
+			on: baseMock.on,
+			_emit: baseMock._emit,
+		};
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
+		const launchFn = async () => launchLSP("server", [], {});
+		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
 	});
 
 	it("should throw if stderr is not available", async () => {
-		const mockProcess = { ...createMockChildProcess(), stderr: null };
+		const baseMock = createMockChildProcess();
+		const mockProcess = {
+			...baseMock,
+			stderr: null,
+			on: baseMock.on,
+			_emit: baseMock._emit,
+		};
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
+		const launchFn = async () => launchLSP("server", [], {});
+		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
 	});
 
 	it("should default to process.cwd() when cwd not provided", async () => {
 		const mockProcess = createMockChildProcess();
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		launchLSP("server", [], {});
+		const launchPromise = launchLSP("server", [], {});
+		await new Promise((r) => setTimeout(r, 60));
+		await launchPromise;
 
 		const [, , options] = mockSpawn.mock.calls[0];
 		expect(options?.cwd).toBe(process.cwd());
@@ -124,11 +176,16 @@ describe("launchLSP", () => {
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
 		// Save original platform
-		const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+		const originalPlatform = Object.getOwnPropertyDescriptor(
+			process,
+			"platform",
+		);
 		Object.defineProperty(process, "platform", { value: "win32" });
 
 		try {
-			launchLSP("server.cmd", ["--arg"], {});
+			const launchPromise = launchLSP("server.cmd", ["--arg"], {});
+			await new Promise((r) => setTimeout(r, 60));
+			await launchPromise;
 
 			const [, , options] = mockSpawn.mock.calls[0];
 			expect(options?.shell).toBe(true);
@@ -171,8 +228,9 @@ describe("launchViaPackageManager", () => {
 		const [cmd, args] = mockSpawn.mock.calls[0];
 		// On Windows with shell mode, args may be concatenated into cmd
 		const cmdStr = String(cmd);
-		const hasBun = cmdStr.includes("bun") || (args && args.some((a: string) => a && a.includes("bun")));
-		const hasX = cmdStr.includes(" x ") || (args && args.includes("x"));
+		const hasBun =
+			cmdStr.includes("bun") || args?.some((a: string) => a?.includes("bun"));
+		const _hasX = cmdStr.includes(" x ") || args?.includes("x");
 		expect(hasBun).toBe(true);
 		// Note: 'x' arg may be in command string on Windows
 	});
@@ -200,8 +258,8 @@ describe("launchViaNode", () => {
 		launchViaNode("/path/to/script.js", ["--arg"], { cwd: "/test" });
 
 		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd, args, options] = mockSpawn.mock.calls[0];
-		
+		const [cmd, _args, options] = mockSpawn.mock.calls[0];
+
 		// On Windows, command is combined; on Unix, it's separate
 		expect(String(cmd)).toContain("node");
 		expect(options?.cwd).toBe("/test");
@@ -228,14 +286,19 @@ describe("launchViaPython", () => {
 		const mockProcess = createMockChildProcess();
 		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
 
-		launchViaPython("pylsp", ["--verbose", "--log-file", "/tmp/log"], {});
+		await launchViaPython("pylsp", ["--verbose", "--log-file", "/tmp/log"], {});
 
 		expect(mockSpawn).toHaveBeenCalled();
 		const [cmd, args] = mockSpawn.mock.calls[0];
-		// Args should include the module and the passed args
-		expect(args).toContain("-m");
-		expect(args).toContain("pylsp");
-		expect(args).toContain("--verbose");
+		// On Windows with shell mode, args may be combined into cmd string
+		// Check that the command contains all expected parts
+		const fullCommand =
+			typeof cmd === "string" && Array.isArray(args) && args.length === 0
+				? cmd // shell mode: everything in cmd
+				: `${cmd} ${args.join(" ")}`; // normal mode
+		expect(fullCommand).toContain("-m");
+		expect(fullCommand).toContain("pylsp");
+		expect(fullCommand).toContain("--verbose");
 	});
 });
 
@@ -252,7 +315,7 @@ describe("stopLSP", () => {
 	it("should send SIGTERM first", async () => {
 		const mockKill = vi.fn();
 		const exitHandlers: Array<() => void> = [];
-		
+
 		const mockProcess = {
 			...createMockChildProcess(),
 			kill: mockKill,
@@ -265,7 +328,7 @@ describe("stopLSP", () => {
 			}),
 		};
 
-		const stopPromise = stopLSP({
+		const _stopPromise = stopLSP({
 			process: mockProcess as any,
 			stdin: {} as any,
 			stdout: {} as any,
@@ -274,8 +337,8 @@ describe("stopLSP", () => {
 		});
 
 		// Let the exit handler fire
-		await new Promise(r => setTimeout(r, 20));
-		
+		await new Promise((r) => setTimeout(r, 20));
+
 		expect(mockKill).toHaveBeenCalledWith("SIGTERM");
 	});
 
@@ -295,13 +358,15 @@ describe("stopLSP", () => {
 			}),
 		};
 
-		await expect(stopLSP({
-			process: mockProcess as any,
-			stdin: {} as any,
-			stdout: {} as any,
-			stderr: {} as any,
-			pid: 123,
-		})).resolves.toBeUndefined();
+		await expect(
+			stopLSP({
+				process: mockProcess as any,
+				stdin: {} as any,
+				stdout: {} as any,
+				stderr: {} as any,
+				pid: 123,
+			}),
+		).resolves.toBeUndefined();
 	});
 
 	it("should resolve on error event", async () => {
@@ -323,7 +388,7 @@ describe("stopLSP", () => {
 		});
 
 		// Let the error handler fire
-		await new Promise(r => setTimeout(r, 20));
+		await new Promise((r) => setTimeout(r, 20));
 		await expect(stopPromise).resolves.toBeUndefined();
 	});
 });

package/clients/lsp/__tests__/service.test.ts

@@ -1,6 +1,6 @@
 /**
  * LSP Service Test Suite
- * 
+ *
  * Tests for the LSP Service layer including:
  * - Client lifecycle management
  * - Effect-TS integration
@@ -9,15 +9,21 @@
  * - Cleanup and shutdown
  */
 
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { Effect } from "effect";
-import { LSPService, lspEffect, getLSPService, resetLSPService } from "../index.js";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { LSPClientInfo } from "../client.js";
+import {
+	getLSPService,
+	LSPService,
+	lspEffect,
+	resetLSPService,
+} from "../index.js";
 import type { LSPServerInfo } from "../server.js";
 
 // Mock the dependencies
 vi.mock("../server.js", async () => {
-	const actual = await vi.importActual<typeof import("../server.js")>("../server.js");
+	const actual =
+		await vi.importActual<typeof import("../server.js")>("../server.js");
 	return {
 		...actual,
 		getServersForFileWithConfig: vi.fn(),
@@ -41,8 +47,8 @@ vi.mock("../client.js", () => ({
 	createLSPClient: vi.fn(),
 }));
 
-import { getServersForFileWithConfig as mockGetServersForFile } from "../config.js";
 import { createLSPClient as mockCreateLSPClient } from "../client.js";
+import { getServersForFileWithConfig as mockGetServersForFile } from "../config.js";
 
 describe("LSPService", () => {
 	let service: LSPService;
@@ -74,7 +80,7 @@ describe("LSPService", () => {
 	describe("hasLSP", () => {
 		it("should return false when no servers match file extension", async () => {
 			vi.mocked(mockGetServersForFile).mockReturnValue([]);
-			
+
 			const result = await service.hasLSP("/test/file.unknown");
 			expect(result).toBe(false);
 		});
@@ -88,7 +94,7 @@ describe("LSPService", () => {
 				spawn: vi.fn(),
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
-			
+
 			const result = await service.hasLSP("/project/test.ts");
 			expect(result).toBe(true);
 		});
@@ -102,7 +108,7 @@ describe("LSPService", () => {
 				spawn: vi.fn(),
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
-			
+
 			const result = await service.hasLSP("/project/test.ts");
 			expect(result).toBe(false);
 		});
@@ -123,7 +129,7 @@ describe("LSPService", () => {
 				spawn: vi.fn(),
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([server1, server2]);
-			
+
 			const result = await service.hasLSP("/project/test.ts");
 			expect(result).toBe(true);
 			expect(server1.root).toHaveBeenCalled();
@@ -134,7 +140,7 @@ describe("LSPService", () => {
 	describe("getClientForFile", () => {
 		it("should return undefined when no servers match", async () => {
 			vi.mocked(mockGetServersForFile).mockReturnValue([]);
-			
+
 			const result = await service.getClientForFile("/test/file.unknown");
 			expect(result).toBeUndefined();
 		});
@@ -152,12 +158,12 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			// First call creates client
 			const result1 = await service.getClientForFile("/project/test.ts");
 			expect(result1).toBeDefined();
 			expect(mockCreateLSPClient).toHaveBeenCalledTimes(1);
-			
+
 			// Second call returns cached client
 			const result2 = await service.getClientForFile("/project/other.ts");
 			expect(result2?.client).toBe(result1?.client);
@@ -174,7 +180,7 @@ describe("LSPService", () => {
 				spawn: mockSpawn as any,
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
-			
+
 			const result = await service.getClientForFile("/project/test.ts");
 			expect(result).toBeUndefined();
 		});
@@ -197,9 +203,12 @@ describe("LSPService", () => {
 					process: { pid: 456 } as any,
 				}),
 			};
-			vi.mocked(mockGetServersForFile).mockReturnValue([failingServer, workingServer]);
+			vi.mocked(mockGetServersForFile).mockReturnValue([
+				failingServer,
+				workingServer,
+			]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			const result = await service.getClientForFile("/project/test.ts");
 			expect(result).toBeDefined();
 			expect(result?.info.id).toBe("server2");
@@ -220,22 +229,23 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			await service.openFile("/project/test.ts", "const x = 1;");
-			
+
 			expect(mockClient.notify.open).toHaveBeenCalledWith(
 				"/project/test.ts",
 				"const x = 1;",
-				"typescript"
+				"typescript",
 			);
 		});
 
 		it("should do nothing when no LSP available", async () => {
 			vi.mocked(mockGetServersForFile).mockReturnValue([]);
-			
+
 			// Should not throw
-			await expect(service.openFile("/test.unknown", "content"))
-				.resolves.not.toThrow();
+			await expect(
+				service.openFile("/test.unknown", "content"),
+			).resolves.not.toThrow();
 		});
 	});
 
@@ -253,12 +263,12 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			await service.updateFile("/project/test.ts", "const x = 2;");
-			
+
 			expect(mockClient.notify.change).toHaveBeenCalledWith(
 				"/project/test.ts",
-				"const x = 2;"
+				"const x = 2;",
 			);
 		});
 	});
@@ -287,16 +297,16 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			const result = await service.getDiagnostics("/project/test.ts");
-			
+
 			expect(result).toEqual(mockDiagnostics);
 			expect(mockClient.waitForDiagnostics).toHaveBeenCalled();
 		});
 
 		it("should return empty array when no LSP available", async () => {
 			vi.mocked(mockGetServersForFile).mockReturnValue([]);
-			
+
 			const result = await service.getDiagnostics("/test.unknown");
 			expect(result).toEqual([]);
 		});
@@ -306,7 +316,7 @@ describe("LSPService", () => {
 		it("should shutdown all clients", async () => {
 			const mockClient1 = createMockClient();
 			const mockClient2 = createMockClient();
-			
+
 			// Add clients to service
 			const mockServer1: LSPServerInfo = {
 				id: "typescript",
@@ -322,29 +332,31 @@ describe("LSPService", () => {
 				root: vi.fn().mockResolvedValue("/project2"),
 				spawn: vi.fn().mockResolvedValue({ process: { pid: 2 } as any }),
 			};
-			
+
 			vi.mocked(mockGetServersForFile)
 				.mockReturnValueOnce([mockServer1])
 				.mockReturnValueOnce([mockServer2]);
-			
+
 			vi.mocked(mockCreateLSPClient)
 				.mockResolvedValueOnce(mockClient1)
 				.mockResolvedValueOnce(mockClient2);
-			
+
 			// Create clients
 			await service.getClientForFile("/project1/test.ts");
 			await service.getClientForFile("/project2/test.py");
-			
+
 			await service.shutdown();
-			
+
 			expect(mockClient1.shutdown).toHaveBeenCalled();
 			expect(mockClient2.shutdown).toHaveBeenCalled();
 		});
 
 		it("should handle shutdown errors gracefully", async () => {
 			const mockClient = createMockClient();
-			(mockClient.shutdown as any).mockRejectedValue(new Error("Shutdown failed"));
-			
+			(mockClient.shutdown as any).mockRejectedValue(
+				new Error("Shutdown failed"),
+			);
+
 			const mockServer: LSPServerInfo = {
 				id: "typescript",
 				name: "TypeScript Server",
@@ -354,9 +366,9 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			await service.getClientForFile("/project/test.ts");
-			
+
 			// Should not throw even when client shutdown fails
 			await expect(service.shutdown()).resolves.not.toThrow();
 		});
@@ -374,9 +386,9 @@ describe("LSPService", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			await service.getClientForFile("/project/test.ts");
-			
+
 			const status = service.getStatus();
 			expect(status).toHaveLength(1);
 			expect(status[0]).toEqual({
@@ -416,17 +428,17 @@ describe("lspEffect", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			const program = effect.openFile("/project/test.ts", "content");
 			const result = await Effect.runPromise(program);
-			
+
 			expect(result).toBeUndefined();
 			expect(mockClient.notify.open).toHaveBeenCalled();
 		});
 
 		it("should handle errors in Effect", async () => {
 			vi.mocked(mockGetServersForFile).mockReturnValue([]);
-			
+
 			const program = effect.openFile("/test.unknown", "content");
 			// Should complete successfully (no-op for unknown files)
 			await expect(Effect.runPromise(program)).resolves.not.toThrow();
@@ -435,7 +447,16 @@ describe("lspEffect", () => {
 
 	describe("getDiagnostics Effect", () => {
 		it("should wrap getDiagnostics in Effect", async () => {
-			const mockDiagnostics = [{ severity: 1, message: "Error", range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }];
+			const mockDiagnostics = [
+				{
+					severity: 1,
+					message: "Error",
+					range: {
+						start: { line: 0, character: 0 },
+						end: { line: 0, character: 1 },
+					},
+				},
+			];
 			const mockClient = createMockClient(mockDiagnostics);
 			const mockServer: LSPServerInfo = {
 				id: "typescript",
@@ -446,10 +467,10 @@ describe("lspEffect", () => {
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
 			vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient as any);
-			
+
 			const program = effect.getDiagnostics("/project/test.ts");
 			const result = await Effect.runPromise(program);
-			
+
 			expect(result).toEqual(mockDiagnostics);
 		});
 	});
@@ -464,10 +485,10 @@ describe("lspEffect", () => {
 				spawn: vi.fn(),
 			};
 			vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
-			
+
 			const program = effect.hasLSP("/project/test.ts");
 			const result = await Effect.runPromise(program);
-			
+
 			expect(result).toBe(true);
 		});
 	});
@@ -476,7 +497,7 @@ describe("lspEffect", () => {
 		it("should wrap shutdown in Effect", async () => {
 			const program = effect.shutdown();
 			const result = await Effect.runPromise(program);
-			
+
 			expect(result).toBeUndefined();
 		});
 	});
@@ -493,7 +514,14 @@ function createMockClient(diagnostics: any[] = []): LSPClientInfo {
 			change: vi.fn().mockResolvedValue(undefined),
 		},
 		getDiagnostics: vi.fn().mockReturnValue(diagnostics),
+		getAllDiagnostics: vi.fn().mockReturnValue(new Map()),
 		waitForDiagnostics: vi.fn().mockResolvedValue(undefined),
+		definition: vi.fn().mockResolvedValue([]),
+		references: vi.fn().mockResolvedValue([]),
+		hover: vi.fn().mockResolvedValue(null),
+		documentSymbol: vi.fn().mockResolvedValue([]),
+		workspaceSymbol: vi.fn().mockResolvedValue([]),
+		implementation: vi.fn().mockResolvedValue([]),
 		shutdown: vi.fn().mockResolvedValue(undefined),
 	};
 }