mongodb-mcp-server 0.1.0 → 0.1.2

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

@@ -67,7 +67,7 @@ describeWithAtlas("ip access lists", (integration) => {
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain("IP/CIDR ranges added to access list");
+                expect(response.content[0]?.text).toContain("IP/CIDR ranges added to access list");
             });
         });
 
@@ -90,7 +90,7 @@ describeWithAtlas("ip access lists", (integration) => {
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(1);
                 for (const value of values) {
-                    expect(response.content[0].text).toContain(value);
+                    expect(response.content[0]?.text).toContain(value);
                 }
             });
         });

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

@@ -0,0 +1,42 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { expectDefined } from "../../helpers.js";
+import { parseTable, describeWithAtlas, withProject } from "./atlasHelpers.js";
+
+describeWithAtlas("alerts", (integration) => {
+    describe("atlas-list-alerts", () => {
+        it("should have correct metadata", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const listAlerts = tools.find((tool) => tool.name === "atlas-list-alerts");
+            expectDefined(listAlerts);
+            expect(listAlerts.inputSchema.type).toBe("object");
+            expectDefined(listAlerts.inputSchema.properties);
+            expect(listAlerts.inputSchema.properties).toHaveProperty("projectId");
+        });
+
+        withProject(integration, ({ getProjectId }) => {
+            it("returns alerts in table format", async () => {
+                const response = (await integration.mcpClient().callTool({
+                    name: "atlas-list-alerts",
+                    arguments: { projectId: getProjectId() },
+                })) as CallToolResult;
+
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+
+                const data = parseTable(response.content[0]?.text as string);
+                expect(data).toBeArray();
+
+                // Since we can't guarantee alerts will exist, we just verify the table structure
+                if (data.length > 0) {
+                    const alert = data[0];
+                    expect(alert).toHaveProperty("Alert ID");
+                    expect(alert).toHaveProperty("Status");
+                    expect(alert).toHaveProperty("Created");
+                    expect(alert).toHaveProperty("Updated");
+                    expect(alert).toHaveProperty("Type");
+                    expect(alert).toHaveProperty("Comment");
+                }
+            });
+        });
+    });
+});

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

@@ -75,7 +75,9 @@ export function parseTable(text: string): Record<string, string>[] {
         .map((cells) => {
             const row: Record<string, string> = {};
             cells.forEach((cell, index) => {
-                row[headers[index]] = cell;
+                if (headers) {
+                    row[headers[index] ?? ""] = cell;
+                }
             });
             return row;
         });
@@ -87,14 +89,14 @@ async function createProject(apiClient: ApiClient): Promise<Group> {
     const projectName: string = `testProj-` + randomId;
 
     const orgs = await apiClient.listOrganizations();
-    if (!orgs?.results?.length || !orgs.results[0].id) {
+    if (!orgs?.results?.length || !orgs.results[0]?.id) {
         throw new Error("No orgs found");
     }
 
     const group = await apiClient.createProject({
         body: {
             name: projectName,
-            orgId: orgs.results[0].id,
+            orgId: orgs.results[0]?.id ?? "",
         } as Group,
     });
 

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

@@ -88,7 +88,7 @@ describeWithAtlas("clusters", (integration) => {
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(2);
-                expect(response.content[0].text).toContain("has been created");
+                expect(response.content[0]?.text).toContain("has been created");
             });
         });
 
@@ -113,7 +113,7 @@ describeWithAtlas("clusters", (integration) => {
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain(`${clusterName} | `);
+                expect(response.content[0]?.text).toContain(`${clusterName} | `);
             });
         });
 
@@ -135,7 +135,7 @@ describeWithAtlas("clusters", (integration) => {
                     .callTool({ name: "atlas-list-clusters", arguments: { projectId } })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(2);
-                expect(response.content[1].text).toContain(`${clusterName} | `);
+                expect(response.content[1]?.text).toContain(`${clusterName} | `);
             });
         });
 
@@ -178,7 +178,7 @@ describeWithAtlas("clusters", (integration) => {
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain(`Connected to cluster "${clusterName}"`);
+                expect(response.content[0]?.text).toContain(`Connected to cluster "${clusterName}"`);
             });
         });
     });

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

@@ -1,24 +1,49 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { Session } from "../../../../src/session.js";
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { expectDefined } from "../../helpers.js";
+import { expectDefined, getResponseElements } from "../../helpers.js";
+import { ApiClientError } from "../../../../src/common/atlas/apiClientError.js";
 
 describeWithAtlas("db users", (integration) => {
-    const userName = "testuser-" + randomId;
     withProject(integration, ({ getProjectId }) => {
-        afterAll(async () => {
-            const projectId = getProjectId();
+        let userName: string;
+        beforeEach(() => {
+            userName = "testuser-" + randomId;
+        });
 
-            const session: Session = integration.mcpServer().session;
-            await session.apiClient.deleteDatabaseUser({
-                params: {
-                    path: {
-                        groupId: projectId,
-                        username: userName,
-                        databaseName: "admin",
-                    },
+        const createUserWithMCP = async (password?: string): Promise<unknown> => {
+            return await integration.mcpClient().callTool({
+                name: "atlas-create-db-user",
+                arguments: {
+                    projectId: getProjectId(),
+                    username: userName,
+                    password,
+                    roles: [
+                        {
+                            roleName: "readWrite",
+                            databaseName: "admin",
+                        },
+                    ],
                 },
             });
+        };
+
+        afterEach(async () => {
+            try {
+                await integration.mcpServer().session.apiClient.deleteDatabaseUser({
+                    params: {
+                        path: {
+                            groupId: getProjectId(),
+                            username: userName,
+                            databaseName: "admin",
+                        },
+                    },
+                });
+            } catch (error) {
+                // Ignore 404 errors when deleting the user
+                if (!(error instanceof ApiClientError) || error.response?.status !== 404) {
+                    throw error;
+                }
+            }
         });
 
         describe("atlas-create-db-user", () => {
@@ -34,26 +59,24 @@ describeWithAtlas("db users", (integration) => {
                 expect(createDbUser.inputSchema.properties).toHaveProperty("roles");
                 expect(createDbUser.inputSchema.properties).toHaveProperty("clusters");
             });
-            it("should create a database user", async () => {
-                const projectId = getProjectId();
 
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-create-db-user",
-                    arguments: {
-                        projectId,
-                        username: userName,
-                        password: "testpassword",
-                        roles: [
-                            {
-                                roleName: "readWrite",
-                                databaseName: "admin",
-                            },
-                        ],
-                    },
-                })) as CallToolResult;
-                expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain("created sucessfully");
+            it("should create a database user with supplied password", async () => {
+                const response = await createUserWithMCP("testpassword");
+
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(1);
+                expect(elements[0]?.text).toContain("created successfully");
+                expect(elements[0]?.text).toContain(userName);
+                expect(elements[0]?.text).not.toContain("testpassword");
+            });
+
+            it("should create a database user with generated password", async () => {
+                const response = await createUserWithMCP();
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(1);
+                expect(elements[0]?.text).toContain("created successfully");
+                expect(elements[0]?.text).toContain(userName);
+                expect(elements[0]?.text).toContain("with password: `");
             });
         });
         describe("atlas-list-db-users", () => {
@@ -68,12 +91,14 @@ describeWithAtlas("db users", (integration) => {
             it("returns database users by project", async () => {
                 const projectId = getProjectId();
 
+                await createUserWithMCP();
+
                 const response = (await integration
                     .mcpClient()
                     .callTool({ name: "atlas-list-db-users", arguments: { projectId } })) as CallToolResult;
                 expect(response.content).toBeArray();
                 expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain(userName);
+                expect(response.content[0]?.text).toContain(userName);
             });
         });
     });

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

@@ -16,9 +16,9 @@ describeWithAtlas("orgs", (integration) => {
                 .callTool({ name: "atlas-list-orgs", arguments: {} })) as CallToolResult;
             expect(response.content).toBeArray();
             expect(response.content).toHaveLength(1);
-            const data = parseTable(response.content[0].text as string);
+            const data = parseTable(response.content[0]?.text as string);
             expect(data).toHaveLength(1);
-            expect(data[0]["Organization Name"]).toEqual("MongoDB MCP Test");
+            expect(data[0]?.["Organization Name"]).toEqual("MongoDB MCP Test");
         });
     });
 });

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

@@ -43,7 +43,7 @@ describeWithAtlas("projects", (integration) => {
             })) as CallToolResult;
             expect(response.content).toBeArray();
             expect(response.content).toHaveLength(1);
-            expect(response.content[0].text).toContain(projName);
+            expect(response.content[0]?.text).toContain(projName);
         });
     });
     describe("atlas-list-projects", () => {
@@ -62,8 +62,8 @@ describeWithAtlas("projects", (integration) => {
                 .callTool({ name: "atlas-list-projects", arguments: {} })) as CallToolResult;
             expect(response.content).toBeArray();
             expect(response.content).toHaveLength(1);
-            expect(response.content[0].text).toContain(projName);
-            const data = parseTable(response.content[0].text as string);
+            expect(response.content[0]?.text).toContain(projName);
+            const data = parseTable(response.content[0]?.text as string);
             expect(data).toBeArray();
             expect(data.length).toBeGreaterThan(0);
             let found = false;

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

@@ -34,7 +34,7 @@ describeWithMongoDB("createCollection tool", (integration) => {
 
             collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
             expect(collections).toHaveLength(1);
-            expect(collections[0].name).toEqual("bar");
+            expect(collections[0]?.name).toEqual("bar");
         });
     });
 
@@ -78,7 +78,7 @@ describeWithMongoDB("createCollection tool", (integration) => {
             expect(content).toEqual(`Collection "collection1" created in database "${integration.randomDbName()}".`);
             collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
             expect(collections).toHaveLength(1);
-            expect(collections[0].name).toEqual("collection1");
+            expect(collections[0]?.name).toEqual("collection1");
 
             // Make sure we didn't drop the existing collection
             documents = await mongoClient.db(integration.randomDbName()).collection("collection1").find({}).toArray();

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

@@ -38,10 +38,10 @@ describeWithMongoDB("createIndex tool", (integration) => {
         const mongoClient = integration.mongoClient();
         const collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
         expect(collections).toHaveLength(1);
-        expect(collections[0].name).toEqual("coll1");
+        expect(collections[0]?.name).toEqual("coll1");
         const indexes = await mongoClient.db(integration.randomDbName()).collection(collection).indexes();
         expect(indexes).toHaveLength(expected.length + 1);
-        expect(indexes[0].name).toEqual("_id_");
+        expect(indexes[0]?.name).toEqual("_id_");
         for (const index of expected) {
             const foundIndex = indexes.find((i) => i.name === index.name);
             expectDefined(foundIndex);

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

@@ -82,7 +82,7 @@ describeWithMongoDB("insertMany tool", (integration) => {
         const content = getResponseContent(response.content);
         expect(content).toContain("Error running insert-many");
         expect(content).toContain("duplicate key error");
-        expect(content).toContain(insertedIds[0].toString());
+        expect(content).toContain(insertedIds[0]?.toString());
     });
 
     validateAutoConnectBehavior(integration, "insert-many", () => {

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

@@ -54,7 +54,7 @@ describeWithMongoDB("dropCollection tool", (integration) => {
         );
         const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
         expect(collections).toHaveLength(1);
-        expect(collections[0].name).toBe("coll2");
+        expect(collections[0]?.name).toBe("coll2");
     });
 
     validateAutoConnectBehavior(integration, "drop-collection", () => {

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

@@ -132,11 +132,11 @@ describeWithMongoDB("collectionSchema tool", (integration) => {
                 expect(items).toHaveLength(2);
 
                 // Expect to find _id, name, age
-                expect(items[0].text).toEqual(
+                expect(items[0]?.text).toEqual(
                     `Found ${Object.entries(testCase.expectedSchema).length} fields in the schema for "${integration.randomDbName()}.foo"`
                 );
 
-                const schema = JSON.parse(items[1].text) as SimplifiedSchema;
+                const schema = JSON.parse(items[1]?.text ?? "{}") as SimplifiedSchema;
                 expect(schema).toEqual(testCase.expectedSchema);
             });
         }

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

@@ -2,8 +2,6 @@ import { describeWithMongoDB } from "../mongodbHelpers.js";
 import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
 import { config } from "../../../../../src/config.js";
 
-// These tests are temporarily skipped because the connect tool is disabled for the initial release.
-// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
 describeWithMongoDB(
     "switchConnection tool",
     (integration) => {
@@ -77,8 +75,7 @@ describeWithMongoDB(
     (mdbIntegration) => ({
         ...config,
         connectionString: mdbIntegration.connectionString(),
-    }),
-    describe.skip
+    })
 );
 describeWithMongoDB(
     "Connect tool",
@@ -127,6 +124,5 @@ describeWithMongoDB(
             });
         });
     },
-    () => config,
-    describe.skip
+    () => config
 );

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

@@ -28,9 +28,9 @@ describeWithMongoDB("dbStats tool", (integration) => {
             });
             const elements = getResponseElements(response.content);
             expect(elements).toHaveLength(2);
-            expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+            expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
 
-            const stats = JSON.parse(elements[1].text) as {
+            const stats = JSON.parse(elements[1]?.text ?? "{}") as {
                 db: string;
                 collections: number;
                 storageSize: number;
@@ -75,9 +75,9 @@ describeWithMongoDB("dbStats tool", (integration) => {
                 });
                 const elements = getResponseElements(response.content);
                 expect(elements).toHaveLength(2);
-                expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+                expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
 
-                const stats = JSON.parse(elements[1].text) as {
+                const stats = JSON.parse(elements[1]?.text ?? "{}") as {
                     db: string;
                     collections: unknown;
                     storageSize: unknown;

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

@@ -89,12 +89,12 @@ describeWithMongoDB("explain tool", (integration) => {
 
                     const content = getResponseElements(response.content);
                     expect(content).toHaveLength(2);
-                    expect(content[0].text).toEqual(
+                    expect(content[0]?.text).toEqual(
                         `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.coll1". This information can be used to understand how the query was executed and to optimize the query performance.`
                     );
 
-                    expect(content[1].text).toContain("queryPlanner");
-                    expect(content[1].text).toContain("winningPlan");
+                    expect(content[1]?.text).toContain("queryPlanner");
+                    expect(content[1]?.text).toContain("winningPlan");
                 });
             }
         });
@@ -139,22 +139,22 @@ describeWithMongoDB("explain tool", (integration) => {
 
                         const content = getResponseElements(response.content);
                         expect(content).toHaveLength(2);
-                        expect(content[0].text).toEqual(
+                        expect(content[0]?.text).toEqual(
                             `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.people". This information can be used to understand how the query was executed and to optimize the query performance.`
                         );
 
-                        expect(content[1].text).toContain("queryPlanner");
-                        expect(content[1].text).toContain("winningPlan");
+                        expect(content[1]?.text).toContain("queryPlanner");
+                        expect(content[1]?.text).toContain("winningPlan");
 
                         if (indexed) {
                             if (testCase.method === "count") {
-                                expect(content[1].text).toContain("COUNT_SCAN");
+                                expect(content[1]?.text).toContain("COUNT_SCAN");
                             } else {
-                                expect(content[1].text).toContain("IXSCAN");
+                                expect(content[1]?.text).toContain("IXSCAN");
                             }
-                            expect(content[1].text).toContain("name_1");
+                            expect(content[1]?.text).toContain("name_1");
                         } else {
-                            expect(content[1].text).toContain("COLLSCAN");
+                            expect(content[1]?.text).toContain("COLLSCAN");
                         }
                     });
                 }

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

@@ -45,7 +45,7 @@ describeWithMongoDB("listCollections tool", (integration) => {
             });
             const items = getResponseElements(response.content);
             expect(items).toHaveLength(1);
-            expect(items[0].text).toContain('Name: "collection-1"');
+            expect(items[0]?.text).toContain('Name: "collection-1"');
 
             await mongoClient.db(integration.randomDbName()).createCollection("collection-2");
 

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

@@ -65,9 +65,13 @@ describeWithMongoDB("listDatabases tool", (integration) => {
 
 function getDbNames(content: unknown): (string | null)[] {
     const responseItems = getResponseElements(content);
-
-    return responseItems.map((item) => {
-        const match = item.text.match(/Name: (.*), Size: \d+ bytes/);
-        return match ? match[1] : null;
-    });
+    return responseItems
+        .map((item) => {
+            if (item && typeof item.text === "string") {
+                const match = item.text.match(/Name: ([^,]+), Size: \d+ bytes/);
+                return match ? match[1] : null;
+            }
+            return null;
+        })
+        .filter((item): item is string | null => item !== undefined);
 }

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

@@ -37,11 +37,11 @@ describeWithMongoDB("logs tool", (integration) => {
 
         // Default limit is 50
         expect(elements.length).toBeLessThanOrEqual(51);
-        expect(elements[0].text).toMatch(/Found: \d+ messages/);
+        expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
 
         for (let i = 1; i < elements.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const log = JSON.parse(elements[i].text);
+            const log = JSON.parse(elements[i]?.text ?? "{}");
             expect(log).toHaveProperty("t");
             expect(log).toHaveProperty("msg");
         }
@@ -59,7 +59,7 @@ describeWithMongoDB("logs tool", (integration) => {
         const elements = getResponseElements(response);
         expect(elements.length).toBeLessThanOrEqual(51);
         for (let i = 1; i < elements.length; i++) {
-            const log = JSON.parse(elements[i].text) as { tags: string[] };
+            const log = JSON.parse(elements[i]?.text ?? "{}") as { tags: string[] };
             expect(log).toHaveProperty("t");
             expect(log).toHaveProperty("msg");
             expect(log).toHaveProperty("tags");
@@ -76,7 +76,7 @@ describeWithMongoDB("logs tool", (integration) => {
             validate: (content) => {
                 const elements = getResponseElements(content);
                 expect(elements.length).toBeLessThanOrEqual(51);
-                expect(elements[0].text).toMatch(/Found: \d+ messages/);
+                expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
             },
         };
     });

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

@@ -17,42 +17,32 @@ interface MongoDBIntegrationTest {
 export function describeWithMongoDB(
     name: string,
     fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
-    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig,
-    describeFn = describe
+    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig
 ) {
-    describeFn(name, () => {
+    describe(name, () => {
         const mdbIntegration = setupMongoDBIntegrationTest();
         const integration = setupIntegrationTest(() => ({
             ...getUserConfig(mdbIntegration),
-            connectionString: mdbIntegration.connectionString(),
         }));
 
-        beforeEach(() => {
-            integration.mcpServer().userConfig.connectionString = mdbIntegration.connectionString();
-        });
-
         fn({
             ...integration,
             ...mdbIntegration,
             connectMcpClient: async () => {
-                // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when
-                // the connect tool is reenabled
-                // await integration.mcpClient().callTool({
-                //     name: "connect",
-                //     arguments: { connectionString: mdbIntegration.connectionString() },
-                // });
+                const { tools } = await integration.mcpClient().listTools();
+                if (tools.find((tool) => tool.name === "connect")) {
+                    await integration.mcpClient().callTool({
+                        name: "connect",
+                        arguments: { connectionString: mdbIntegration.connectionString() },
+                    });
+                }
             },
         });
     });
 }
 
 export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
-    let mongoCluster: // TODO: Fix this type once mongodb-runner is updated.
-    | {
-              connectionString: string;
-              close: () => Promise<void>;
-          }
-        | undefined;
+    let mongoCluster: MongoCluster | undefined;
     let mongoClient: MongoClient | undefined;
     let randomDbName: string;
 
@@ -76,8 +66,6 @@ export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
         let dbsDir = path.join(tmpDir, "mongodb-runner", "dbs");
         for (let i = 0; i < 10; i++) {
             try {
-                // TODO: Fix this type once mongodb-runner is updated.
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
                 mongoCluster = await MongoCluster.start({
                     tmpDir: dbsDir,
                     logDir: path.join(tmpDir, "mongodb-runner", "logs"),
@@ -141,12 +129,15 @@ export function validateAutoConnectBehavior(
     },
     beforeEachImpl?: () => Promise<void>
 ): void {
-    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-    describe.skip("when not connected", () => {
+    describe("when not connected", () => {
         if (beforeEachImpl) {
             beforeEach(() => beforeEachImpl());
         }
 
+        afterEach(() => {
+            integration.mcpServer().userConfig.connectionString = undefined;
+        });
+
         it("connects automatically if connection string is configured", async () => {
             integration.mcpServer().userConfig.connectionString = integration.connectionString();