pi-lens 3.6.2 → 3.6.4

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

@@ -1,412 +0,0 @@
-/**
- * LSP Client Test Suite
- *
- * Tests for the LSP Client including:
- * - Connection lifecycle (initialize, shutdown)
- * - Document synchronization (didOpen, didChange)
- * - Diagnostics handling with debouncing
- * - JSON-RPC communication
- */
-
-import { EventEmitter } from "node:events";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createLSPClient, type LSPDiagnostic } from "../client.js";
-import type { LSPProcess } from "../launch.js";
-
-// Mock vscode-jsonrpc
-const mockConnection = {
-	listen: vi.fn(),
-	onNotification: vi.fn(),
-	onRequest: vi.fn(),
-	sendRequest: vi.fn().mockResolvedValue({}),
-	sendNotification: vi.fn().mockResolvedValue(undefined),
-	dispose: vi.fn(),
-};
-
-vi.mock("vscode-jsonrpc/node.js", () => ({
-	createMessageConnection: vi.fn(() => mockConnection),
-	StreamMessageReader: vi.fn(),
-	StreamMessageWriter: vi.fn(),
-}));
-
-import { createMessageConnection } from "vscode-jsonrpc/node.js";
-
-describe("createLSPClient", () => {
-	let mockProcess: LSPProcess;
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-
-		mockProcess = {
-			process: { pid: 123, kill: vi.fn() } as any,
-			stdin: new EventEmitter() as any,
-			stdout: new EventEmitter() as any,
-			stderr: new EventEmitter() as any,
-			pid: 123,
-		};
-
-		// Reset mock connection behavior
-		mockConnection.sendRequest.mockResolvedValue({});
-		mockConnection.sendNotification.mockResolvedValue(undefined);
-	});
-
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe("initialization", () => {
-		it("should create JSON-RPC connection", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			expect(createMessageConnection).toHaveBeenCalled();
-			expect(mockConnection.listen).toHaveBeenCalled();
-		});
-
-		it("should send initialize request with correct parameters", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test/project",
-			});
-
-			expect(mockConnection.sendRequest).toHaveBeenCalledWith(
-				"initialize",
-				expect.objectContaining({
-					processId: expect.any(Number),
-					rootUri: expect.stringContaining("test/project"),
-					capabilities: expect.objectContaining({
-						textDocument: expect.objectContaining({
-							synchronization: expect.any(Object),
-							publishDiagnostics: expect.any(Object),
-						}),
-						workspace: expect.any(Object),
-					}),
-				}),
-			);
-		});
-
-		it("should send initialized notification after initialize", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			expect(mockConnection.sendNotification).toHaveBeenCalledWith(
-				"initialized",
-				{},
-			);
-		});
-
-		it.skip("should handle initialization timeout", async () => {
-			// This test is timing-sensitive and flaky in test environment
-			// The timeout logic works correctly in production
-		});
-
-		it("should register workspace folder handler", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test/project",
-			});
-
-			expect(mockConnection.onRequest).toHaveBeenCalledWith(
-				"workspace/workspaceFolders",
-				expect.any(Function),
-			);
-		});
-
-		it("should register capability handlers", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			expect(mockConnection.onRequest).toHaveBeenCalledWith(
-				"client/registerCapability",
-				expect.any(Function),
-			);
-			expect(mockConnection.onRequest).toHaveBeenCalledWith(
-				"client/unregisterCapability",
-				expect.any(Function),
-			);
-		});
-	});
-
-	describe("document notifications", () => {
-		it("should send didOpen notification", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			await client.notify.open("/test/file.ts", "const x = 1;", "typescript");
-
-			expect(mockConnection.sendNotification).toHaveBeenCalledWith(
-				"textDocument/didOpen",
-				{
-					textDocument: {
-						uri: expect.stringContaining("file.ts"),
-						languageId: "typescript",
-						version: 0,
-						text: "const x = 1;",
-					},
-				},
-			);
-		});
-
-		it("should send didChange notification with version increment", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// First open the file
-			await client.notify.open("/test/file.ts", "const x = 1;", "typescript");
-
-			// Then change it
-			await client.notify.change("/test/file.ts", "const x = 2;");
-
-			const didChangeCalls = mockConnection.sendNotification.mock.calls.filter(
-				(call: any) => call[0] === "textDocument/didChange",
-			);
-			expect(didChangeCalls).toHaveLength(1);
-			expect(didChangeCalls[0][1]).toMatchObject({
-				textDocument: { version: 1 },
-				contentChanges: [{ text: "const x = 2;" }],
-			});
-		});
-
-		it("should handle multiple document versions", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			await client.notify.open("/test/file.ts", "v0", "typescript");
-			await client.notify.change("/test/file.ts", "v1");
-			await client.notify.change("/test/file.ts", "v2");
-			await client.notify.change("/test/file.ts", "v3");
-
-			const didChangeCalls = mockConnection.sendNotification.mock.calls.filter(
-				(call: any) => call[0] === "textDocument/didChange",
-			);
-
-			expect(
-				didChangeCalls.map((call: any) => call[1].textDocument.version),
-			).toEqual([1, 2, 3]);
-		});
-	});
-
-	describe("diagnostics handling", () => {
-		beforeEach(() => {
-			vi.useFakeTimers({ shouldAdvanceTime: true });
-		});
-
-		afterEach(() => {
-			vi.useRealTimers();
-		});
-
-		it("should set up diagnostics notification handler", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			expect(mockConnection.onNotification).toHaveBeenCalledWith(
-				"textDocument/publishDiagnostics",
-				expect.any(Function),
-			);
-		});
-
-		it.skip("should store diagnostics for retrieval", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// Get the registered handler and call it directly with diagnostics
-			const handler = mockConnection.onNotification.mock.calls.find(
-				(call: any) => call[0] === "textDocument/publishDiagnostics",
-			)?.[1];
-
-			const mockDiagnostics: LSPDiagnostic[] = [
-				{
-					severity: 1,
-					message: "Error",
-					range: {
-						start: { line: 0, character: 0 },
-						end: { line: 0, character: 1 },
-					},
-				},
-			];
-
-			handler?.({ uri: "file:///test/file.ts", diagnostics: mockDiagnostics });
-			await vi.advanceTimersByTimeAsync(200);
-
-			const stored = client.getDiagnostics("/test/file.ts");
-			expect(stored).toEqual(mockDiagnostics);
-		});
-
-		it("should return empty array for unknown files", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			const diags = client.getDiagnostics("/unknown/file.ts");
-			expect(diags).toEqual([]);
-		});
-
-		it("should wait for diagnostics with timeout", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// waitForDiagnostics resolves via timeout when no notification arrives
-			const promise = client.waitForDiagnostics("/test/file.ts", 100);
-			await vi.advanceTimersByTimeAsync(150);
-			await promise;
-			// If we got here, the timeout resolved — test passes
-		});
-
-		it.skip("should resolve waitForDiagnostics immediately if diagnostics exist", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// Pre-populate diagnostics via the publishDiagnostics handler
-			const handler = mockConnection.onNotification.mock.calls.find(
-				(call: any) => call[0] === "textDocument/publishDiagnostics",
-			)?.[1];
-
-			handler?.({
-				uri: "file:///test/file.ts",
-				diagnostics: [
-					{
-						severity: 1,
-						message: "Error",
-						range: {
-							start: { line: 0, character: 0 },
-							end: { line: 0, character: 1 },
-						},
-					},
-				],
-			});
-			await vi.advanceTimersByTimeAsync(200);
-
-			// getDiagnostics should have data now
-			const stored = client.getDiagnostics("/test/file.ts");
-			expect(stored.length).toBeGreaterThan(0);
-
-			// waitForDiagnostics should return immediately (diagnostics.has() check)
-			// No need to advance timers — it short-circuits
-			await client.waitForDiagnostics("/test/file.ts", 5000);
-		});
-	});
-
-	describe("shutdown", () => {
-		beforeEach(() => {
-			// Use real timers for shutdown tests
-			vi.useRealTimers();
-		});
-
-		it("should send shutdown request", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			await client.shutdown();
-
-			expect(mockConnection.sendRequest).toHaveBeenCalledWith("shutdown");
-		});
-
-		it("should send exit notification", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			await client.shutdown();
-
-			expect(mockConnection.sendNotification).toHaveBeenCalledWith("exit");
-		});
-
-		it("should dispose connection", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			await client.shutdown();
-
-			expect(mockConnection.dispose).toHaveBeenCalled();
-		});
-
-		it("should kill process", async () => {
-			const mockKill = vi.fn();
-			const processWithKill = {
-				...mockProcess,
-				process: { ...mockProcess.process, kill: mockKill },
-			};
-
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: processWithKill as any,
-				root: "/test",
-			});
-
-			await client.shutdown();
-
-			expect(mockKill).toHaveBeenCalled();
-		});
-
-		it("should handle shutdown errors gracefully", async () => {
-			const client = await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// Make shutdown request fail (after successful initialize)
-			mockConnection.sendRequest.mockRejectedValue(
-				new Error("Connection error"),
-			);
-
-			// Should not throw
-			await expect(client.shutdown()).resolves.not.toThrow();
-		});
-	});
-
-	describe("client info", () => {
-		it("should return serverId and root", async () => {
-			const client = await createLSPClient({
-				serverId: "my-lsp-server",
-				process: mockProcess,
-				root: "/my/project",
-			});
-
-			expect(client.serverId).toBe("my-lsp-server");
-			expect(client.root).toBe("/my/project");
-		});
-	});
-});

package/clients/lsp/__tests__/config.test.js

@@ -1,167 +0,0 @@
-/**
- * LSP Configuration Test Suite
- *
- * Tests for configuration including:
- * - Config file loading
- * - Custom server creation
- * - Server registry management
- * - Disabled server handling
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Mock fs/promises before any imports that use it
-const mockReadFile = vi.fn();
-const mockAccess = vi.fn();
-const mockStat = vi.fn();
-vi.mock("node:fs/promises", async () => {
-    return {
-        readFile: mockReadFile,
-        access: mockAccess,
-        stat: mockStat,
-    };
-});
-// Import after mocking - mocks are already defined above
-const { loadLSPConfig, createCustomServer, initLSPConfig, getAllServers, isServerDisabled, getServersForFileWithConfig, } = await import("../config.js");
-describe("loadLSPConfig", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it.skip("should load config from .pi-lens/lsp.json", async () => {
-        const config = {
-            servers: {
-                "my-server": {
-                    name: "My Custom Server",
-                    extensions: [".myext"],
-                    command: "my-lsp",
-                    args: ["--stdio"],
-                },
-            },
-        };
-        mockReadFile.mockResolvedValue(JSON.stringify(config));
-        const result = await loadLSPConfig("/project");
-        expect(result).toEqual(config);
-        expect(mockReadFile).toHaveBeenCalled();
-    });
-    it("should return empty config when file not found", async () => {
-        mockReadFile.mockRejectedValue(new Error("ENOENT"));
-        const result = await loadLSPConfig("/project");
-        expect(result).toEqual({});
-    });
-    it("should handle invalid JSON gracefully", async () => {
-        mockReadFile.mockResolvedValue("not valid json");
-        const result = await loadLSPConfig("/project");
-        expect(result).toEqual({});
-    });
-    it.skip("should try multiple config paths", async () => {
-        mockReadFile
-            .mockRejectedValueOnce(new Error("ENOENT"))
-            .mockRejectedValueOnce(new Error("ENOENT"))
-            .mockResolvedValueOnce(JSON.stringify({ servers: {} }));
-        const result = await loadLSPConfig("/project");
-        expect(mockReadFile).toHaveBeenCalledTimes(3);
-        expect(result).toEqual({ servers: {} });
-    });
-});
-describe("createCustomServer", () => {
-    it("should create server from config", () => {
-        const config = {
-            name: "Custom LSP",
-            extensions: [".custom"],
-            command: "custom-lsp",
-            args: ["--stdio", "--verbose"],
-            rootMarkers: [".customrc"],
-        };
-        const server = createCustomServer(config, "custom-server");
-        expect(server.id).toBe("custom-server");
-        expect(server.name).toBe("Custom LSP");
-        expect(server.extensions).toEqual([".custom"]);
-        expect(typeof server.spawn).toBe("function");
-        expect(typeof server.root).toBe("function");
-    });
-    it("should use process.cwd() as root when no markers specified", async () => {
-        const config = {
-            name: "Simple LSP",
-            extensions: [".simple"],
-            command: "simple-lsp",
-        };
-        const server = createCustomServer(config, "simple");
-        const root = await server.root("/any/path/file.simple");
-        expect(root).toBe(process.cwd());
-    });
-});
-describe("initLSPConfig", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Reset by calling init with empty config
-        mockReadFile.mockRejectedValue(new Error("ENOENT"));
-        return initLSPConfig("/test-reset");
-    });
-    it("should initialize with empty config", async () => {
-        mockReadFile.mockRejectedValue(new Error("ENOENT"));
-        await initLSPConfig("/project");
-        const servers = getAllServers();
-        // Should have built-in servers
-        expect(servers.some((s) => s.id === "typescript")).toBe(true);
-    });
-    it.skip("should register custom servers from config", async () => {
-        const config = {
-            servers: {
-                "custom-test-server": {
-                    name: "Custom Test Server",
-                    extensions: [".ctest"],
-                    command: "ctest-lsp",
-                },
-            },
-        };
-        mockReadFile.mockResolvedValue(JSON.stringify(config));
-        await initLSPConfig("/project");
-        const servers = getAllServers();
-        expect(servers.some((s) => s.id === "custom-test-server")).toBe(true);
-    });
-    it.skip("should handle disabled servers", async () => {
-        const config = {
-            disabledServers: ["python"],
-        };
-        mockReadFile.mockResolvedValue(JSON.stringify(config));
-        await initLSPConfig("/project");
-        expect(isServerDisabled("python")).toBe(true);
-        expect(isServerDisabled("typescript")).toBe(false);
-    });
-});
-describe("getAllServers", () => {
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        mockReadFile.mockRejectedValue(new Error("ENOENT"));
-        await initLSPConfig("/test");
-    });
-    it("should include built-in servers", () => {
-        const servers = getAllServers();
-        expect(servers.some((s) => s.id === "typescript")).toBe(true);
-        expect(servers.some((s) => s.id === "python")).toBe(true);
-        expect(servers.some((s) => s.id === "go")).toBe(true);
-        expect(servers.some((s) => s.id === "rust")).toBe(true);
-    });
-});
-describe("getServersForFileWithConfig", () => {
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        mockReadFile.mockRejectedValue(new Error("ENOENT"));
-        await initLSPConfig("/test");
-    });
-    it("should find TypeScript server for .ts files", () => {
-        const servers = getServersForFileWithConfig("/project/file.ts");
-        expect(servers.some((s) => s.id === "typescript")).toBe(true);
-    });
-    it("should find Python server for .py files", () => {
-        const servers = getServersForFileWithConfig("/project/file.py");
-        expect(servers.some((s) => s.id === "python")).toBe(true);
-    });
-    it("should return empty array for unknown file type", () => {
-        const servers = getServersForFileWithConfig("/project/file.unknown");
-        expect(servers).toEqual([]);
-    });
-    it("should be case insensitive for extensions", () => {
-        const servers1 = getServersForFileWithConfig("/project/file.TS");
-        const servers2 = getServersForFileWithConfig("/project/file.ts");
-        expect(servers1.map((s) => s.id)).toEqual(servers2.map((s) => s.id));
-    });
-});