mongodb-mcp-server 0.2.0 → 0.3.0

package/tests/unit/accuracyScorer.test.ts

@@ -1,390 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { calculateToolCallingAccuracy } from "../accuracy/sdk/accuracyScorer.js";
-import { ExpectedToolCall, LLMToolCall } from "../accuracy/sdk/accuracyResultStorage/resultStorage.js";
-import { Matcher } from "../accuracy/sdk/matcher.js";
-
-describe("calculateToolCallingAccuracy", () => {
-    describe("edge cases", () => {
-        it("should return 1 when both expected and actual are empty", () => {
-            const result = calculateToolCallingAccuracy([], []);
-            expect(result).toBe(1);
-        });
-
-        it("should return 0.75 when expected is empty but actual has tool calls", () => {
-            const actualToolCalls: LLMToolCall[] = [{ toolCallId: "1", toolName: "find", parameters: { db: "test" } }];
-            const result = calculateToolCallingAccuracy([], actualToolCalls);
-            expect(result).toBe(0.75);
-        });
-
-        it("should return 0 when expected has tool calls but actual is empty", () => {
-            const expectedToolCalls: ExpectedToolCall[] = [{ toolName: "find", parameters: { db: "test" } }];
-            const result = calculateToolCallingAccuracy(expectedToolCalls, []);
-            expect(result).toBe(0);
-        });
-    });
-
-    describe("perfect matches", () => {
-        it("should return 1 for exact match with nested parameters", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { age: { $gte: 18 }, status: "active" } },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { age: { $gte: 18 }, status: "active" } },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-
-        it("should return 1 for exact match with multiple diverse tool calls", () => {
-            const expected: ExpectedToolCall[] = [
-                { toolName: "find", parameters: { db: "test", collection: "users", filter: { status: "active" } } },
-                {
-                    toolName: "aggregate",
-                    parameters: { db: "test", collection: "orders", pipeline: [{ $match: { total: { $gt: 100 } } }] },
-                },
-                { toolName: "count", parameters: { db: "test", collection: "products" } },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active" } },
-                },
-                {
-                    toolCallId: "2",
-                    toolName: "aggregate",
-                    parameters: { db: "test", collection: "orders", pipeline: [{ $match: { total: { $gt: 100 } } }] },
-                },
-                { toolCallId: "3", toolName: "count", parameters: { db: "test", collection: "products" } },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-    });
-
-    describe("additional parameters", () => {
-        it("should return 0 when tool call has additional nested parameters (default behavior)", () => {
-            const expected: ExpectedToolCall[] = [
-                { toolName: "find", parameters: { db: "test", collection: "users", filter: { status: "active" } } },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        db: "test",
-                        collection: "users",
-                        filter: { status: "active", age: { $gte: 18 } },
-                        limit: 10,
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0);
-        });
-
-        it("should return 1 when expected has no filter but actual has empty filter", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: Matcher.emptyObjectOrUndefined,
-                    },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: {},
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-
-        it("should return 1 when expected has no filter and actual has no filter", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: Matcher.emptyObjectOrUndefined,
-                    },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-
-        it("should return 0 when expected has no filter but actual has non-empty filter", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: Matcher.emptyObjectOrUndefined,
-                    },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: { genre: "Horror" },
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0);
-        });
-
-        it("should return 0 when there are additional nested fields", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: { runtime: { $lt: 100 } },
-                    },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: { runtime: { $lt: 100 }, genre: "Horror" },
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0);
-        });
-
-        it("should return 1 when ignored additional fields are provided", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: { runtime: { $lt: 100 } },
-                        limit: Matcher.number(),
-                        sort: Matcher.anyValue,
-                    },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        filter: { runtime: { $lt: 100 } },
-                        limit: 10,
-                        sort: { title: 1 },
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-
-        it("should return 1 for array where additional elements are allowed", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "aggregate",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        pipeline: [{ $match: { genre: "Horror" } }, Matcher.anyOf(Matcher.undefined, Matcher.anyValue)],
-                    },
-                },
-            ];
-
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "aggregate",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        pipeline: [{ $match: { genre: "Horror" } }, { $sort: { title: 1 } }],
-                    },
-                },
-            ];
-
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-
-        it("should return 1 for array where additional elements are allowed but not provided", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "aggregate",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        pipeline: [{ $match: { genre: "Horror" } }, Matcher.anyOf(Matcher.undefined, Matcher.anyValue)],
-                    },
-                },
-            ];
-
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "aggregate",
-                    parameters: {
-                        database: "mflix",
-                        collection: "movies",
-                        pipeline: [{ $match: { genre: "Horror" } }],
-                    },
-                },
-            ];
-
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(1);
-        });
-    });
-
-    describe("missing or incorrect parameters", () => {
-        it("should return 0 when tool call has missing nested parameters", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active", age: { $gte: 18 } } },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active" } },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0);
-        });
-
-        it("should return 0 when aggregate tool call has incorrect pipeline", () => {
-            const expected: ExpectedToolCall[] = [
-                {
-                    toolName: "aggregate",
-                    parameters: { db: "test", collection: "orders", pipeline: [{ $match: { total: { $gt: 100 } } }] },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "aggregate",
-                    parameters: { db: "test", collection: "orders", pipeline: [{ $match: { total: { $lt: 50 } } }] },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0);
-        });
-    });
-
-    describe("additional tool calls", () => {
-        it("should cap accuracy at 0.75 when LLM calls extra tools", () => {
-            const expected: ExpectedToolCall[] = [
-                { toolName: "find", parameters: { db: "test", collection: "users", filter: { status: "active" } } },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active" } },
-                },
-                { toolCallId: "2", toolName: "count", parameters: { db: "test", collection: "orders" } },
-                {
-                    toolCallId: "3",
-                    toolName: "aggregate",
-                    parameters: {
-                        db: "test",
-                        collection: "products",
-                        pipeline: [{ $group: { _id: "$category", total: { $sum: 1 } } }],
-                    },
-                },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0.75);
-        });
-
-        it("should cap accuracy at 0.75 when LLM calls same tool multiple times with variations", () => {
-            const expected: ExpectedToolCall[] = [
-                { toolName: "find", parameters: { db: "test", collection: "users", filter: { status: "active" } } },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active" } },
-                },
-                {
-                    toolCallId: "2",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active", age: { $gte: 18 } } },
-                },
-                { toolCallId: "3", toolName: "find", parameters: { db: "test", collection: "users", limit: 10 } },
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0.75);
-        });
-    });
-
-    describe("missing tool calls", () => {
-        it("should return 0 if any expected tool call was not called", () => {
-            const expected: ExpectedToolCall[] = [
-                { toolName: "find", parameters: { db: "test", collection: "users", filter: { status: "active" } } },
-                {
-                    toolName: "aggregate",
-                    parameters: { db: "test", collection: "orders", pipeline: [{ $match: { total: { $gt: 100 } } }] },
-                },
-            ];
-            const actual: LLMToolCall[] = [
-                {
-                    toolCallId: "1",
-                    toolName: "find",
-                    parameters: { db: "test", collection: "users", filter: { status: "active" } },
-                },
-                // Missing the aggregate tool call
-            ];
-            const result = calculateToolCallingAccuracy(expected, actual);
-            expect(result).toBe(0); // One expected tool call was not called
-        });
-    });
-});

package/tests/unit/common/apiClient.test.ts

@@ -1,193 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ApiClient } from "../../../src/common/atlas/apiClient.js";
-import { CommonProperties, TelemetryEvent, TelemetryResult } from "../../../src/telemetry/types.js";
-
-describe("ApiClient", () => {
-    let apiClient: ApiClient;
-
-    const mockEvents: TelemetryEvent<CommonProperties>[] = [
-        {
-            timestamp: new Date().toISOString(),
-            source: "mdbmcp",
-            properties: {
-                mcp_client_version: "1.0.0",
-                mcp_client_name: "test-client",
-                mcp_server_version: "1.0.0",
-                mcp_server_name: "test-server",
-                platform: "test-platform",
-                arch: "test-arch",
-                os_type: "test-os",
-                component: "test-component",
-                duration_ms: 100,
-                result: "success" as TelemetryResult,
-                category: "test-category",
-            },
-        },
-    ];
-
-    beforeEach(() => {
-        apiClient = new ApiClient({
-            baseUrl: "https://api.test.com",
-            credentials: {
-                clientId: "test-client-id",
-                clientSecret: "test-client-secret",
-            },
-            userAgent: "test-user-agent",
-        });
-
-        // @ts-expect-error accessing private property for testing
-        apiClient.getAccessToken = vi.fn().mockResolvedValue("mockToken");
-    });
-
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-
-    describe("constructor", () => {
-        it("should create a client with the correct configuration", () => {
-            expect(apiClient).toBeDefined();
-            expect(apiClient.hasCredentials()).toBeDefined();
-        });
-    });
-
-    describe("listProjects", () => {
-        it("should return a list of projects", async () => {
-            const mockProjects = {
-                results: [
-                    { id: "1", name: "Project 1" },
-                    { id: "2", name: "Project 2" },
-                ],
-                totalCount: 2,
-            };
-
-            const mockGet = vi.fn().mockImplementation(() => ({
-                data: mockProjects,
-                error: null,
-                response: new Response(),
-            }));
-
-            // @ts-expect-error accessing private property for testing
-            apiClient.client.GET = mockGet;
-
-            const result = await apiClient.listProjects();
-
-            expect(mockGet).toHaveBeenCalledWith("/api/atlas/v2/groups", undefined);
-            expect(result).toEqual(mockProjects);
-        });
-
-        it("should throw an error when the API call fails", async () => {
-            const mockError = {
-                reason: "Test error",
-                detail: "Something went wrong",
-            };
-
-            const mockGet = vi.fn().mockImplementation(() => ({
-                data: null,
-                error: mockError,
-                response: new Response(),
-            }));
-
-            // @ts-expect-error accessing private property for testing
-            apiClient.client.GET = mockGet;
-
-            await expect(apiClient.listProjects()).rejects.toThrow();
-        });
-    });
-
-    describe("sendEvents", () => {
-        it("should send events to authenticated endpoint when token is available and valid", async () => {
-            const mockFetch = vi.spyOn(global, "fetch");
-            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
-
-            await apiClient.sendEvents(mockEvents);
-
-            const url = new URL("api/private/v1.0/telemetry/events", "https://api.test.com");
-            expect(mockFetch).toHaveBeenCalledWith(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: "Bearer mockToken",
-                    Accept: "application/json",
-                    "User-Agent": "test-user-agent",
-                },
-                body: JSON.stringify(mockEvents),
-            });
-        });
-
-        it("should fall back to unauthenticated endpoint when token is not available via exception", async () => {
-            const mockFetch = vi.spyOn(global, "fetch");
-            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
-
-            // @ts-expect-error accessing private property for testing
-            apiClient.getAccessToken = vi.fn().mockRejectedValue(new Error("No access token available"));
-
-            await apiClient.sendEvents(mockEvents);
-
-            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
-            expect(mockFetch).toHaveBeenCalledWith(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    "User-Agent": "test-user-agent",
-                },
-                body: JSON.stringify(mockEvents),
-            });
-        });
-
-        it("should fall back to unauthenticated endpoint when token is undefined", async () => {
-            const mockFetch = vi.spyOn(global, "fetch");
-            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
-
-            // @ts-expect-error accessing private property for testing
-            apiClient.getAccessToken = vi.fn().mockReturnValueOnce(undefined);
-
-            await apiClient.sendEvents(mockEvents);
-
-            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
-            expect(mockFetch).toHaveBeenCalledWith(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    "User-Agent": "test-user-agent",
-                },
-                body: JSON.stringify(mockEvents),
-            });
-        });
-
-        it("should fall back to unauthenticated endpoint on 401 error", async () => {
-            const mockFetch = vi.spyOn(global, "fetch");
-            mockFetch
-                .mockResolvedValueOnce(new Response(null, { status: 401 }))
-                .mockResolvedValueOnce(new Response(null, { status: 200 }));
-
-            await apiClient.sendEvents(mockEvents);
-
-            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-            expect(mockFetch).toHaveBeenLastCalledWith(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    "User-Agent": "test-user-agent",
-                },
-                body: JSON.stringify(mockEvents),
-            });
-        });
-
-        it("should throw error when both authenticated and unauthenticated requests fail", async () => {
-            const mockFetch = vi.spyOn(global, "fetch");
-            mockFetch
-                .mockResolvedValueOnce(new Response(null, { status: 401 }))
-                .mockResolvedValueOnce(new Response(null, { status: 500 }));
-
-            const mockToken = "test-token";
-            // @ts-expect-error accessing private property for testing
-            apiClient.getAccessToken = vi.fn().mockResolvedValue(mockToken);
-
-            await expect(apiClient.sendEvents(mockEvents)).rejects.toThrow();
-        });
-    });
-});

package/tests/unit/common/managedTimeout.test.ts

@@ -1,67 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { setManagedTimeout } from "../../../src/common/managedTimeout.js";
-
-describe("setManagedTimeout", () => {
-    beforeAll(() => {
-        vi.useFakeTimers();
-    });
-
-    afterAll(() => {
-        vi.useRealTimers();
-    });
-
-    it("calls the timeout callback", () => {
-        const callback = vi.fn();
-
-        setManagedTimeout(callback, 1000);
-
-        vi.advanceTimersByTime(1000);
-        expect(callback).toHaveBeenCalled();
-    });
-
-    it("does not call the timeout callback if the timeout is cleared", () => {
-        const callback = vi.fn();
-
-        const timeout = setManagedTimeout(callback, 1000);
-
-        vi.advanceTimersByTime(500);
-        timeout.cancel();
-        vi.advanceTimersByTime(500);
-
-        expect(callback).not.toHaveBeenCalled();
-    });
-
-    it("does not call the timeout callback if the timeout is reset", () => {
-        const callback = vi.fn();
-
-        const timeout = setManagedTimeout(callback, 1000);
-
-        vi.advanceTimersByTime(500);
-        timeout.restart();
-        vi.advanceTimersByTime(500);
-        expect(callback).not.toHaveBeenCalled();
-    });
-
-    describe("if timeout is reset", () => {
-        it("does not call the timeout callback within the timeout period", () => {
-            const callback = vi.fn();
-
-            const timeout = setManagedTimeout(callback, 1000);
-
-            vi.advanceTimersByTime(500);
-            timeout.restart();
-            vi.advanceTimersByTime(500);
-            expect(callback).not.toHaveBeenCalled();
-        });
-        it("calls the timeout callback after the timeout period", () => {
-            const callback = vi.fn();
-
-            const timeout = setManagedTimeout(callback, 1000);
-
-            vi.advanceTimersByTime(500);
-            timeout.restart();
-            vi.advanceTimersByTime(1000);
-            expect(callback).toHaveBeenCalled();
-        });
-    });
-});