pi-lens 3.6.3 → 3.6.4

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

@@ -1,310 +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 } from "../client.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;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockProcess = {
-            process: { pid: 123, kill: vi.fn() },
-            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: 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) => 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.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) => 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",
-            });
-            // 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) => 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,
-                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");
-        });
-    });
-});