chore: add additional tests for tools interface on server

Author: himanshusinghs

tests/integration/server.test.ts

@@ -1,6 +1,64 @@
+import { MCPConnectionManager } from "../../src/common/connectionManager.js";
+import { ExportsManager } from "../../src/common/exportsManager.js";
+import { CompositeLogger } from "../../src/common/logger.js";
+import { DeviceId } from "../../src/helpers/deviceId.js";
+import { Session } from "../../src/common/session.js";
 import { defaultTestConfig, expectDefined } from "./helpers.js";
 import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it } from "vitest";
+import { Elicitation, Keychain, Telemetry } from "../../src/lib.js";
+import { VectorSearchEmbeddingsManager } from "../../src/common/search/vectorSearchEmbeddingsManager.js";
+import { defaultCreateAtlasLocalClient } from "../../src/common/atlasLocal.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "../../src/server.js";
+import { connectionErrorHandler } from "../../src/common/connectionErrorHandler.js";
+import { type OperationType, ToolBase, type ToolCategory, type ToolClass } from "../../src/tools/tool.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { TelemetryToolMetadata } from "../../src/telemetry/types.js";
+import { InMemoryTransport } from "../../src/transports/inMemoryTransport.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+class TestToolOne extends ToolBase {
+    public name = "test-tool-one";
+    protected description = "A test tool one for verification tests";
+    static category: ToolCategory = "mongodb";
+    static operationType: OperationType = "delete";
+    protected argsShape = {};
+    protected async execute(): Promise<CallToolResult> {
+        return Promise.resolve({
+            content: [
+                {
+                    type: "text",
+                    text: "Test tool one executed successfully",
+                },
+            ],
+        });
+    }
+    protected resolveTelemetryMetadata(): TelemetryToolMetadata {
+        return {};
+    }
+}
+
+class TestToolTwo extends ToolBase {
+    public name = "test-tool-two";
+    protected description = "A test tool two for verification tests";
+    static category: ToolCategory = "mongodb";
+    static operationType: OperationType = "delete";
+    protected argsShape = {};
+    protected async execute(): Promise<CallToolResult> {
+        return Promise.resolve({
+            content: [
+                {
+                    type: "text",
+                    text: "Test tool two executed successfully",
+                },
+            ],
+        });
+    }
+    protected resolveTelemetryMetadata(): TelemetryToolMetadata {
+        return {};
+    }
+}
 
 describe("Server integration test", () => {
     describeWithMongoDB(
@@ -84,7 +142,7 @@ describe("Server integration test", () => {
                 // Check that non-read tools are NOT available
                 expect(tools.tools.some((tool) => tool.name === "insert-many")).toBe(false);
                 expect(tools.tools.some((tool) => tool.name === "update-many")).toBe(false);
-                expect(tools.tools.some((tool) => tool.name === "delete-one")).toBe(false);
+                expect(tools.tools.some((tool) => tool.name === "delete-many")).toBe(false);
                 expect(tools.tools.some((tool) => tool.name === "drop-collection")).toBe(false);
             });
         },
@@ -97,4 +155,64 @@ describe("Server integration test", () => {
             }),
         }
     );
+
+    describe("with additional tools", () => {
+        const initServerWithTools = async (tools: ToolClass[]): Promise<{ server: Server; transport: Transport }> => {
+            const logger = new CompositeLogger();
+            const deviceId = DeviceId.create(logger);
+            const connectionManager = new MCPConnectionManager(defaultTestConfig, logger, deviceId);
+            const exportsManager = ExportsManager.init(defaultTestConfig, logger);
+
+            const session = new Session({
+                userConfig: defaultTestConfig,
+                logger,
+                exportsManager,
+                connectionManager,
+                keychain: Keychain.root,
+                vectorSearchEmbeddingsManager: new VectorSearchEmbeddingsManager(defaultTestConfig, connectionManager),
+                atlasLocalClient: await defaultCreateAtlasLocalClient(),
+            });
+
+            const telemetry = Telemetry.create(session, defaultTestConfig, deviceId);
+            const mcpServerInstance = new McpServer({ name: "test", version: "1.0" });
+            const elicitation = new Elicitation({ server: mcpServerInstance.server });
+
+            const server = new Server({
+                session,
+                userConfig: defaultTestConfig,
+                telemetry,
+                mcpServer: mcpServerInstance,
+                elicitation,
+                connectionErrorHandler,
+                tools: [...tools],
+            });
+
+            const transport = new InMemoryTransport();
+
+            return { transport, server };
+        };
+
+        let server: Server | undefined;
+        let transport: Transport | undefined;
+
+        afterEach(async () => {
+            await transport?.close();
+        });
+
+        it("should start server with only the tools provided", async () => {
+            ({ server, transport } = await initServerWithTools([TestToolOne]));
+            await server.connect(transport);
+            expect(server.tools).toHaveLength(1);
+        });
+
+        it("should throw error before starting when provided tools have name conflict", async () => {
+            ({ server, transport } = await initServerWithTools([
+                TestToolOne,
+                class TestToolTwoButOne extends TestToolTwo {
+                    public name = "test-tool-one";
+                },
+            ]));
+            await expect(server.connect(transport)).rejects.toThrow(/Tool test-tool-one is already registered/);
+        });
+    });
 });