pi-lens 3.1.2 → 3.2.0

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

@@ -1,325 +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 { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { createLSPClient } from "../client.js";
-import { EventEmitter } from "events";
-// 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(),
-}));
-vi.mock("../../bus/events.js", () => ({
-    DiagnosticFound: {
-        publish: vi.fn(),
-    },
-}));
-import { DiagnosticFound } from "../../bus/events.js";
-import { createMessageConnection } from "vscode-jsonrpc/node.js";
-describe("createLSPClient", () => {
-    let mockProcess;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockProcess = {
-            process: { pid: 123 },
-            stdin: new EventEmitter(),
-            stdout: new EventEmitter(),
-            stderr: new EventEmitter(),
-            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: 123,
-                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) => 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) => call[0] === "textDocument/didChange");
-            expect(didChangeCalls.map((call) => 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("should publish diagnostics to bus", async () => {
-            await createLSPClient({
-                serverId: "test-server",
-                process: mockProcess,
-                root: "/test",
-            });
-            // Get the registered handler
-            const handler = mockConnection.onNotification.mock.calls.find((call) => call[0] === "textDocument/publishDiagnostics")?.[1];
-            expect(handler).toBeDefined();
-            // Simulate receiving diagnostics
-            const mockDiagnostics = [
-                {
-                    severity: 1,
-                    message: "Type error",
-                    range: {
-                        start: { line: 0, character: 0 },
-                        end: { line: 0, character: 5 },
-                    },
-                    code: "TS2345",
-                },
-            ];
-            // Call handler directly (would be debounced in real scenario)
-            handler?.({ uri: "file:///test/file.ts", diagnostics: mockDiagnostics });
-            // Advance past debounce (150ms)
-            await vi.advanceTimersByTimeAsync(200);
-            expect(DiagnosticFound.publish).toHaveBeenCalled();
-        });
-        it("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) => call[0] === "textDocument/publishDiagnostics")?.[1];
-            const mockDiagnostics = [
-                {
-                    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",
-            });
-            const startTime = Date.now();
-            await client.waitForDiagnostics("/test/file.ts", 100);
-            const elapsed = Date.now() - startTime;
-            expect(elapsed).toBeGreaterThanOrEqual(100);
-        });
-        it("should resolve waitForDiagnostics immediately if diagnostics exist", async () => {
-            const client = await createLSPClient({
-                serverId: "test-server",
-                process: mockProcess,
-                root: "/test",
-            });
-            // Pre-populate diagnostics
-            const handler = mockConnection.onNotification.mock.calls.find((call) => 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);
-            const startTime = Date.now();
-            await client.waitForDiagnostics("/test/file.ts", 5000);
-            const elapsed = Date.now() - startTime;
-            expect(elapsed).toBeLessThan(500); // Allow some time for test overhead
-        });
-    });
-    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,
-                root: "/test",
-            });
-            await client.shutdown();
-            expect(mockKill).toHaveBeenCalled();
-        });
-        it("should handle shutdown errors gracefully", async () => {
-            mockConnection.sendRequest.mockRejectedValue(new Error("Connection error"));
-            const client = await createLSPClient({
-                serverId: "test-server",
-                process: mockProcess,
-                root: "/test",
-            });
-            // 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,166 +0,0 @@
-/**
- * LSP Configuration Test Suite
- *
- * Tests for configuration including:
- * - Config file loading
- * - Custom server creation
- * - Server registry management
- * - Disabled server handling
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import * as fs from "fs/promises";
-// Mock fs/promises before importing the module under test
-vi.mock("fs/promises", async () => {
-    return {
-        readFile: vi.fn(),
-        access: vi.fn(),
-        stat: vi.fn(),
-    };
-});
-// Import after mocking
-const { loadLSPConfig, createCustomServer, initLSPConfig, getAllServers, isServerDisabled, getServersForFileWithConfig } = await import("../config.js");
-const mockReadFile = vi.mocked(fs.readFile);
-describe("loadLSPConfig", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("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("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("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("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));
-    });
-});