mongodb-mcp-server 0.1.2 → 0.2.0

package/tests/integration/tools/atlas/clusters.test.ts

@@ -1,7 +1,9 @@
-import { Session } from "../../../../src/session.js";
-import { expectDefined } from "../../helpers.js";
+import { Session } from "../../../../src/common/session.js";
+import { expectDefined, getResponseElements } from "../../helpers.js";
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
+import { ClusterDescription20240805 } from "../../../../src/common/atlas/openapi.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 function sleep(ms: number) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -33,7 +35,12 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
     }
 }
 
-async function waitClusterState(session: Session, projectId: string, clusterName: string, state: string) {
+async function waitCluster(
+    session: Session,
+    projectId: string,
+    clusterName: string,
+    check: (cluster: ClusterDescription20240805) => boolean | Promise<boolean>
+) {
     while (true) {
         const cluster = await session.apiClient.getCluster({
             params: {
@@ -43,7 +50,7 @@ async function waitClusterState(session: Session, projectId: string, clusterName
                 },
             },
         });
-        if (cluster?.stateName === state) {
+        if (await check(cluster)) {
             return;
         }
         await sleep(1000);
@@ -75,8 +82,10 @@ describeWithAtlas("clusters", (integration) => {
                 expect(createFreeCluster.inputSchema.properties).toHaveProperty("region");
             });
 
-            it("should create a free cluster", async () => {
+            it("should create a free cluster and add current IP to access list", async () => {
                 const projectId = getProjectId();
+                const session = integration.mcpServer().session;
+                const ipInfo = await session.apiClient.getIpInfo();
 
                 const response = (await integration.mcpClient().callTool({
                     name: "atlas-create-free-cluster",
@@ -86,9 +95,16 @@ describeWithAtlas("clusters", (integration) => {
                         region: "US_EAST_1",
                     },
                 })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(2);
                 expect(response.content[0]?.text).toContain("has been created");
+
+                // Check that the current IP is present in the access list
+                const accessList = await session.apiClient.listProjectIpAccessLists({
+                    params: { path: { groupId: projectId } },
+                });
+                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
+                expect(found).toBe(true);
             });
         });
 
@@ -111,7 +127,7 @@ describeWithAtlas("clusters", (integration) => {
                     name: "atlas-inspect-cluster",
                     arguments: { projectId, clusterName: clusterName },
                 })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(1);
                 expect(response.content[0]?.text).toContain(`${clusterName} | `);
             });
@@ -133,7 +149,7 @@ describeWithAtlas("clusters", (integration) => {
                 const response = (await integration
                     .mcpClient()
                     .callTool({ name: "atlas-list-clusters", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(2);
                 expect(response.content[1]?.text).toContain(`${clusterName} | `);
             });
@@ -142,7 +158,12 @@ describeWithAtlas("clusters", (integration) => {
         describe("atlas-connect-cluster", () => {
             beforeAll(async () => {
                 const projectId = getProjectId();
-                await waitClusterState(integration.mcpServer().session, projectId, clusterName, "IDLE");
+                await waitCluster(integration.mcpServer().session, projectId, clusterName, (cluster) => {
+                    return (
+                        cluster.stateName === "IDLE" &&
+                        (cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard) !== undefined
+                    );
+                });
                 await integration.mcpServer().session.apiClient.createProjectIpAccessList({
                     params: {
                         path: {
@@ -172,13 +193,44 @@ describeWithAtlas("clusters", (integration) => {
             it("connects to cluster", async () => {
                 const projectId = getProjectId();
 
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-connect-cluster",
-                    arguments: { projectId, clusterName },
-                })) as CallToolResult;
-                expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0]?.text).toContain(`Connected to cluster "${clusterName}"`);
+                for (let i = 0; i < 10; i++) {
+                    const response = (await integration.mcpClient().callTool({
+                        name: "atlas-connect-cluster",
+                        arguments: { projectId, clusterName },
+                    })) as CallToolResult;
+                    expect(response.content).toBeInstanceOf(Array);
+                    expect(response.content.length).toBeGreaterThanOrEqual(1);
+                    expect(response.content[0]?.type).toEqual("text");
+                    const c = response.content[0] as { text: string };
+                    if (
+                        c.text.includes("Cluster is already connected.") ||
+                        c.text.includes(`Connected to cluster "${clusterName}"`)
+                    ) {
+                        break; // success
+                    } else {
+                        expect(response.content[0]?.text).toContain(
+                            `Attempting to connect to cluster "${clusterName}"...`
+                        );
+                    }
+                    await sleep(500);
+                }
+            });
+
+            describe("when not connected", () => {
+                it("prompts for atlas-connect-cluster when querying mongodb", async () => {
+                    const response = await integration.mcpClient().callTool({
+                        name: "find",
+                        arguments: { database: "some-db", collection: "some-collection" },
+                    });
+                    const elements = getResponseElements(response.content);
+                    expect(elements).toHaveLength(2);
+                    expect(elements[0]?.text).toContain(
+                        "You need to connect to a MongoDB instance before you can access its data."
+                    );
+                    expect(elements[1]?.text).toContain(
+                        'Please use one of the following tools: "atlas-connect-cluster", "connect" to connect to a MongoDB instance'
+                    );
+                });
             });
         });
     });

package/tests/integration/tools/atlas/dbUsers.test.ts

@@ -2,6 +2,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
 import { expectDefined, getResponseElements } from "../../helpers.js";
 import { ApiClientError } from "../../../../src/common/atlas/apiClientError.js";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 describeWithAtlas("db users", (integration) => {
     withProject(integration, ({ getProjectId }) => {
@@ -78,6 +79,18 @@ describeWithAtlas("db users", (integration) => {
                 expect(elements[0]?.text).toContain(userName);
                 expect(elements[0]?.text).toContain("with password: `");
             });
+
+            it("should add current IP to access list when creating a database user", async () => {
+                const projectId = getProjectId();
+                const session = integration.mcpServer().session;
+                const ipInfo = await session.apiClient.getIpInfo();
+                await createUserWithMCP();
+                const accessList = await session.apiClient.listProjectIpAccessLists({
+                    params: { path: { groupId: projectId } },
+                });
+                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
+                expect(found).toBe(true);
+            });
         });
         describe("atlas-list-db-users", () => {
             it("should have correct metadata", async () => {
@@ -96,7 +109,7 @@ describeWithAtlas("db users", (integration) => {
                 const response = (await integration
                     .mcpClient()
                     .callTool({ name: "atlas-list-db-users", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(1);
                 expect(response.content[0]?.text).toContain(userName);
             });

package/tests/integration/tools/atlas/orgs.test.ts

@@ -1,6 +1,7 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { expectDefined } from "../../helpers.js";
 import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithAtlas("orgs", (integration) => {
     describe("atlas-list-orgs", () => {
@@ -14,7 +15,7 @@ describeWithAtlas("orgs", (integration) => {
             const response = (await integration
                 .mcpClient()
                 .callTool({ name: "atlas-list-orgs", arguments: {} })) as CallToolResult;
-            expect(response.content).toBeArray();
+            expect(response.content).toBeInstanceOf(Array);
             expect(response.content).toHaveLength(1);
             const data = parseTable(response.content[0]?.text as string);
             expect(data).toHaveLength(1);

package/tests/integration/tools/atlas/projects.test.ts

@@ -2,6 +2,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ObjectId } from "mongodb";
 import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
 import { expectDefined } from "../../helpers.js";
+import { afterAll, describe, expect, it } from "vitest";
 
 const randomId = new ObjectId().toString();
 
@@ -41,7 +42,7 @@ describeWithAtlas("projects", (integration) => {
                 name: "atlas-create-project",
                 arguments: { projectName: projName },
             })) as CallToolResult;
-            expect(response.content).toBeArray();
+            expect(response.content).toBeInstanceOf(Array);
             expect(response.content).toHaveLength(1);
             expect(response.content[0]?.text).toContain(projName);
         });
@@ -60,11 +61,11 @@ describeWithAtlas("projects", (integration) => {
             const response = (await integration
                 .mcpClient()
                 .callTool({ name: "atlas-list-projects", arguments: {} })) as CallToolResult;
-            expect(response.content).toBeArray();
+            expect(response.content).toBeInstanceOf(Array);
             expect(response.content).toHaveLength(1);
             expect(response.content[0]?.text).toContain(projName);
             const data = parseTable(response.content[0]?.text as string);
-            expect(data).toBeArray();
+            expect(data).toBeInstanceOf(Array);
             expect(data.length).toBeGreaterThan(0);
             let found = false;
             for (const project of data) {

package/tests/integration/tools/mongodb/{metadata → connect}/connect.test.ts

@@ -1,9 +1,16 @@
 import { describeWithMongoDB } from "../mongodbHelpers.js";
-import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
-import { config } from "../../../../../src/config.js";
+import {
+    getResponseContent,
+    getResponseElements,
+    validateThrowsForInvalidArguments,
+    validateToolMetadata,
+} from "../../../helpers.js";
+import { config } from "../../../../../src/common/config.js";
+import { defaultTestConfig, setupIntegrationTest } from "../../../helpers.js";
+import { beforeEach, describe, expect, it } from "vitest";
 
 describeWithMongoDB(
-    "switchConnection tool",
+    "SwitchConnection tool",
     (integration) => {
         beforeEach(() => {
             integration.mcpServer().userConfig.connectionString = integration.connectionString();
@@ -77,6 +84,7 @@ describeWithMongoDB(
         connectionString: mdbIntegration.connectionString(),
     })
 );
+
 describeWithMongoDB(
     "Connect tool",
     (integration) => {
@@ -126,3 +134,26 @@ describeWithMongoDB(
     },
     () => config
 );
+
+describe("Connect tool when disabled", () => {
+    const integration = setupIntegrationTest(() => ({
+        ...defaultTestConfig,
+        disabledTools: ["connect"],
+    }));
+
+    it("is not suggested when querying MongoDB disconnected", async () => {
+        const response = await integration.mcpClient().callTool({
+            name: "find",
+            arguments: { database: "some-db", collection: "some-collection" },
+        });
+
+        const elements = getResponseElements(response);
+        expect(elements).toHaveLength(2);
+        expect(elements[0]?.text).toContain(
+            "You need to connect to a MongoDB instance before you can access its data."
+        );
+        expect(elements[1]?.text).toContain(
+            "There are no tools available to connect. Please update the configuration to include a connection string and restart the server."
+        );
+    });
+});

package/tests/integration/tools/mongodb/create/createCollection.test.ts

@@ -7,6 +7,7 @@ import {
     validateThrowsForInvalidArguments,
     databaseCollectionInvalidArgs,
 } from "../../../helpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("createCollection tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/create/createIndex.test.ts

@@ -8,6 +8,7 @@ import {
     expectDefined,
 } from "../../../helpers.js";
 import { IndexDirection } from "mongodb";
+import { expect, it } from "vitest";
 
 describeWithMongoDB("createIndex tool", (integration) => {
     validateToolMetadata(integration, "create-index", "Create an index for a collection", [

package/tests/integration/tools/mongodb/create/insertMany.test.ts

@@ -7,6 +7,7 @@ import {
     validateThrowsForInvalidArguments,
     expectDefined,
 } from "../../../helpers.js";
+import { expect, it } from "vitest";
 
 describeWithMongoDB("insertMany tool", (integration) => {
     validateToolMetadata(integration, "insert-many", "Insert an array of documents into a MongoDB collection", [

package/tests/integration/tools/mongodb/delete/deleteMany.test.ts

@@ -6,6 +6,7 @@ import {
     validateToolMetadata,
     validateThrowsForInvalidArguments,
 } from "../../../helpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("deleteMany tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/delete/dropCollection.test.ts

@@ -1,5 +1,5 @@
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
+import { expect, it } from "vitest";
 import {
     getResponseContent,
     databaseCollectionParameters,

package/tests/integration/tools/mongodb/delete/dropDatabase.test.ts

@@ -1,4 +1,5 @@
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+import { expect, it } from "vitest";
 
 import {
     getResponseContent,

package/tests/integration/tools/mongodb/metadata/collectionSchema.test.ts

@@ -11,6 +11,7 @@ import {
 import { Document } from "bson";
 import { OptionalId } from "mongodb";
 import { SimplifiedSchema } from "mongodb-schema";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("collectionSchema tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/metadata/collectionStorageSize.test.ts

@@ -9,6 +9,7 @@ import {
     expectDefined,
 } from "../../../helpers.js";
 import * as crypto from "crypto";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("collectionStorageSize tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/metadata/dbStats.test.ts

@@ -8,6 +8,7 @@ import {
 } from "../../../helpers.js";
 import * as crypto from "crypto";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("dbStats tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/metadata/explain.test.ts

@@ -5,6 +5,7 @@ import {
     getResponseElements,
 } from "../../../helpers.js";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+import { beforeEach, describe, expect, it } from "vitest";
 
 describeWithMongoDB("explain tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/metadata/listCollections.test.ts

@@ -8,6 +8,7 @@ import {
     databaseInvalidArgs,
     databaseParameters,
 } from "../../../helpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("listCollections tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/metadata/listDatabases.test.ts

@@ -1,5 +1,6 @@
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 import { getResponseElements, getParameters, expectDefined } from "../../../helpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithMongoDB("listDatabases tool", (integration) => {
     const defaultDatabases = ["admin", "config", "local"];
@@ -20,7 +21,7 @@ describeWithMongoDB("listDatabases tool", (integration) => {
             const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
             const dbNames = getDbNames(response.content);
 
-            expect(defaultDatabases).toIncludeAllMembers(dbNames);
+            expect(defaultDatabases).toStrictEqual(dbNames);
         });
     });
 
@@ -47,7 +48,7 @@ describeWithMongoDB("listDatabases tool", (integration) => {
                 validate: (content) => {
                     const dbNames = getDbNames(content);
 
-                    expect(defaultDatabases).toIncludeAllMembers(dbNames);
+                    expect(defaultDatabases).toStrictEqual(dbNames);
                 },
             };
         },

package/tests/integration/tools/mongodb/metadata/logs.test.ts

@@ -1,3 +1,4 @@
+import { expect, it } from "vitest";
 import { validateToolMetadata, validateThrowsForInvalidArguments, getResponseElements } from "../../../helpers.js";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 

package/tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -2,12 +2,38 @@ import { MongoCluster } from "mongodb-runner";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs/promises";
-import { MongoClient, ObjectId } from "mongodb";
+import { Document, MongoClient, ObjectId } from "mongodb";
 import { getResponseContent, IntegrationTest, setupIntegrationTest, defaultTestConfig } from "../../helpers.js";
-import { UserConfig } from "../../../../src/config.js";
+import { UserConfig } from "../../../../src/common/config.js";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+const testDataDumpPath = path.join(__dirname, "..", "..", "..", "accuracy", "test-data-dumps");
+
+const testDataPaths = [
+    {
+        db: "comics",
+        collection: "books",
+        path: path.join(testDataDumpPath, "comics.books.json"),
+    },
+    {
+        db: "comics",
+        collection: "characters",
+        path: path.join(testDataDumpPath, "comics.characters.json"),
+    },
+    {
+        db: "mflix",
+        collection: "movies",
+        path: path.join(testDataDumpPath, "mflix.movies.json"),
+    },
+    {
+        db: "mflix",
+        collection: "shows",
+        path: path.join(testDataDumpPath, "mflix.shows.json"),
+    },
+];
+
 interface MongoDBIntegrationTest {
     mongoClient: () => MongoClient;
     connectionString: () => string;
@@ -70,6 +96,7 @@ export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
                     tmpDir: dbsDir,
                     logDir: path.join(tmpDir, "mongodb-runner", "logs"),
                     topology: "standalone",
+                    version: "8.0.10",
                 });
 
                 return;
@@ -168,3 +195,41 @@ export function validateAutoConnectBehavior(
         });
     });
 }
+
+export function prepareTestData(integration: MongoDBIntegrationTest) {
+    const NON_TEST_DBS = ["admin", "config", "local"];
+    const testData: {
+        db: string;
+        collection: string;
+        data: Document[];
+    }[] = [];
+
+    beforeAll(async () => {
+        for (const { db, collection, path } of testDataPaths) {
+            testData.push({
+                db,
+                collection,
+                data: JSON.parse(await fs.readFile(path, "utf8")) as Document[],
+            });
+        }
+    });
+
+    return {
+        async populateTestData(this: void) {
+            const client = integration.mongoClient();
+            for (const { db, collection, data } of testData) {
+                await client.db(db).collection(collection).insertMany(data);
+            }
+        },
+        async cleanupTestDatabases(this: void, integration: MongoDBIntegrationTest) {
+            const client = integration.mongoClient();
+            const admin = client.db().admin();
+            const databases = await admin.listDatabases();
+            await Promise.all(
+                databases.databases
+                    .filter(({ name }) => !NON_TEST_DBS.includes(name))
+                    .map(({ name }) => client.db(name).dropDatabase())
+            );
+        },
+    };
+}

package/tests/integration/tools/mongodb/read/aggregate.test.ts

@@ -4,6 +4,7 @@ import {
     validateThrowsForInvalidArguments,
     getResponseElements,
 } from "../../../helpers.js";
+import { expect, it } from "vitest";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 
 describeWithMongoDB("aggregate tool", (integration) => {
@@ -20,7 +21,7 @@ describeWithMongoDB("aggregate tool", (integration) => {
     validateThrowsForInvalidArguments(integration, "aggregate", [
         {},
         { database: "test", collection: "foo" },
-        { database: test, pipeline: [] },
+        { database: "test", pipeline: [] },
         { database: "test", collection: "foo", pipeline: {} },
         { database: "test", collection: [], pipeline: [] },
         { database: 123, collection: "foo", pipeline: [] },

package/tests/integration/tools/mongodb/read/collectionIndexes.test.ts

@@ -8,6 +8,7 @@ import {
     expectDefined,
 } from "../../../helpers.js";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+import { expect, it } from "vitest";
 
 describeWithMongoDB("collectionIndexes tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/read/count.test.ts

@@ -6,6 +6,7 @@ import {
     validateToolMetadata,
     validateThrowsForInvalidArguments,
 } from "../../../helpers.js";
+import { beforeEach, describe, expect, it } from "vitest";
 
 describeWithMongoDB("count tool", (integration) => {
     validateToolMetadata(

package/tests/integration/tools/mongodb/read/find.test.ts

@@ -1,3 +1,4 @@
+import { beforeEach, describe, expect, it } from "vitest";
 import {
     getResponseContent,
     databaseCollectionParameters,
@@ -33,7 +34,7 @@ describeWithMongoDB("find tool", (integration) => {
         {
             name: "sort",
             description:
-                "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort()",
+                "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort(). The keys of the object are the fields to sort on, while the values are the sort directions (1 for ascending, -1 for descending).",
             type: "object",
             required: false,
         },

package/tests/integration/tools/mongodb/update/renameCollection.test.ts

@@ -4,6 +4,7 @@ import {
     validateToolMetadata,
     validateThrowsForInvalidArguments,
 } from "../../../helpers.js";
+import { describe, expect, it } from "vitest";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 
 describeWithMongoDB("renameCollection tool", (integration) => {

package/tests/integration/tools/mongodb/update/updateMany.test.ts

@@ -4,6 +4,7 @@ import {
     validateThrowsForInvalidArguments,
     getResponseContent,
 } from "../../../helpers.js";
+import { beforeEach, describe, expect, it } from "vitest";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 
 describeWithMongoDB("updateMany tool", (integration) => {

package/tests/integration/transports/stdio.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+describe("StdioRunner", () => {
+    describe("client connects successfully", () => {
+        let client: Client;
+        let transport: StdioClientTransport;
+        beforeAll(async () => {
+            transport = new StdioClientTransport({
+                command: "node",
+                args: ["dist/index.js"],
+                env: {
+                    MDB_MCP_TRANSPORT: "stdio",
+                },
+            });
+            client = new Client({
+                name: "test",
+                version: "0.0.0",
+            });
+            await client.connect(transport);
+        });
+
+        afterAll(async () => {
+            await client.close();
+            await transport.close();
+        });
+
+        it("handles requests and sends responses", async () => {
+            const response = await client.listTools();
+            expect(response).toBeDefined();
+            expect(response.tools).toBeDefined();
+            expect(response.tools).toHaveLength(20);
+
+            const sortedTools = response.tools.sort((a, b) => a.name.localeCompare(b.name));
+            expect(sortedTools[0]?.name).toBe("aggregate");
+            expect(sortedTools[0]?.description).toBe("Run an aggregation against a MongoDB collection");
+        });
+    });
+});