mongodb-mcp-server 0.1.3 → 0.2.0

package/tests/integration/telemetry.test.ts

@@ -1,8 +1,9 @@
 import { createHmac } from "crypto";
 import { Telemetry } from "../../src/telemetry/telemetry.js";
-import { Session } from "../../src/session.js";
-import { config } from "../../src/config.js";
+import { Session } from "../../src/common/session.js";
+import { config } from "../../src/common/config.js";
 import nodeMachineId from "node-machine-id";
+import { describe, expect, it } from "vitest";
 
 describe("Telemetry", () => {
     it("should resolve the actual machine ID", async () => {
@@ -20,7 +21,7 @@ describe("Telemetry", () => {
         expect(telemetry.getCommonProperties().device_id).toBe(undefined);
         expect(telemetry["isBufferingEvents"]).toBe(true);
 
-        await telemetry.deviceIdPromise;
+        await telemetry.setupPromise;
 
         expect(telemetry.getCommonProperties().device_id).toBe(actualHashedId);
         expect(telemetry["isBufferingEvents"]).toBe(false);

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

@@ -1,6 +1,8 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { describeWithAtlas, withProject } from "./atlasHelpers.js";
 import { expectDefined } from "../../helpers.js";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { ensureCurrentIpInAccessList } from "../../../../src/common/atlas/accessListUtils.js";
 
 function generateRandomIp() {
     const randomIp: number[] = [192];
@@ -65,7 +67,7 @@ describeWithAtlas("ip access lists", (integration) => {
                         currentIpAddress: true,
                     },
                 })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(1);
                 expect(response.content[0]?.text).toContain("IP/CIDR ranges added to access list");
             });
@@ -87,12 +89,30 @@ describeWithAtlas("ip access lists", (integration) => {
                 const response = (await integration
                     .mcpClient()
                     .callTool({ name: "atlas-inspect-access-list", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeArray();
+                expect(response.content).toBeInstanceOf(Array);
                 expect(response.content).toHaveLength(1);
                 for (const value of values) {
                     expect(response.content[0]?.text).toContain(value);
                 }
             });
         });
+
+        describe("ensureCurrentIpInAccessList helper", () => {
+            it("should add the current IP to the access list and be idempotent", async () => {
+                const apiClient = integration.mcpServer().session.apiClient;
+                const projectId = getProjectId();
+                const ipInfo = await apiClient.getIpInfo();
+                // First call should add the IP
+                await expect(ensureCurrentIpInAccessList(apiClient, projectId)).resolves.not.toThrow();
+                // Second call should be a no-op (idempotent)
+                await expect(ensureCurrentIpInAccessList(apiClient, projectId)).resolves.not.toThrow();
+                // Check that the IP is present in the access list
+                const accessList = await apiClient.listProjectIpAccessLists({
+                    params: { path: { groupId: projectId } },
+                });
+                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
+                expect(found).toBe(true);
+            });
+        });
     });
 });

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

@@ -1,6 +1,7 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { expectDefined } from "../../helpers.js";
 import { parseTable, describeWithAtlas, withProject } from "./atlasHelpers.js";
+import { describe, expect, it } from "vitest";
 
 describeWithAtlas("alerts", (integration) => {
     describe("atlas-list-alerts", () => {
@@ -20,11 +21,11 @@ describeWithAtlas("alerts", (integration) => {
                     arguments: { projectId: getProjectId() },
                 })) 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).toBeArray();
+                expect(data).toBeInstanceOf(Array);
 
                 // Since we can't guarantee alerts will exist, we just verify the table structure
                 if (data.length > 0) {

package/tests/integration/tools/atlas/atlasHelpers.ts

@@ -2,6 +2,7 @@ import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
 import { setupIntegrationTest, IntegrationTest, defaultTestConfig } from "../../helpers.js";
+import { afterAll, beforeAll, describe } from "vitest";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
@@ -19,8 +20,10 @@ export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     };
 
     if (!process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length) {
+        // eslint-disable-next-line vitest/valid-describe-callback
         return describe.skip("atlas", testDefinition);
     }
+    // eslint-disable-next-line vitest/no-identical-title, vitest/valid-describe-callback
     return describe("atlas", testDefinition);
 }
 

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;
@@ -169,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(