mongodb-mcp-server 0.0.4 → 0.0.5

package/tests/integration/helpers.ts

@@ -1,14 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "./inMemoryTransport.js";
 import { Server } from "../../src/server.js";
-import runner, { MongoCluster } from "mongodb-runner";
-import path from "path";
-import fs from "fs/promises";
-import { Session } from "../../src/session.js";
+import { config, UserConfig } from "../../src/config.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { MongoClient, ObjectId } from "mongodb";
-import { toIncludeAllMembers } from "jest-extended";
-import config from "../../src/config.js";
+import { Session } from "../../src/session.js";
 
 interface ParameterInfo {
     name: string;
@@ -22,21 +18,12 @@ type ToolInfo = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export interface IntegrationTest {
     mcpClient: () => Client;
     mcpServer: () => Server;
-    mongoClient: () => MongoClient;
-    connectionString: () => string;
-    connectMcpClient: () => Promise<void>;
-    randomDbName: () => string;
 }
 
-export function setupIntegrationTest(): IntegrationTest {
-    let mongoCluster: runner.MongoCluster | undefined;
-    let mongoClient: MongoClient | undefined;
-
+export function setupIntegrationTest(userConfig: UserConfig = config): IntegrationTest {
     let mcpClient: Client | undefined;
     let mcpServer: Server | undefined;
 
-    let randomDbName: string;
-
     beforeAll(async () => {
         const clientTransport = new InMemoryTransport();
         const serverTransport = new InMemoryTransport();
@@ -44,8 +31,8 @@ export function setupIntegrationTest(): IntegrationTest {
         await serverTransport.start();
         await clientTransport.start();
 
-        clientTransport.output.pipeTo(serverTransport.input);
-        serverTransport.output.pipeTo(clientTransport.input);
+        void clientTransport.output.pipeTo(serverTransport.input);
+        void serverTransport.output.pipeTo(clientTransport.input);
 
         mcpClient = new Client(
             {
@@ -57,19 +44,26 @@ export function setupIntegrationTest(): IntegrationTest {
             }
         );
 
+        const session = new Session({
+            apiBaseUrl: userConfig.apiBaseUrl,
+            apiClientId: userConfig.apiClientId,
+            apiClientSecret: userConfig.apiClientSecret,
+        });
+
         mcpServer = new Server({
+            session,
+            userConfig,
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "1.2.3",
             }),
-            session: new Session(),
         });
         await mcpServer.connect(serverTransport);
         await mcpClient.connect(clientTransport);
     });
 
-    beforeEach(async () => {
-        randomDbName = new ObjectId().toString();
+    beforeEach(() => {
+        config.telemetry = "disabled";
     });
 
     afterAll(async () => {
@@ -80,52 +74,6 @@ export function setupIntegrationTest(): IntegrationTest {
         mcpServer = undefined;
     });
 
-    afterEach(async () => {
-        await mcpServer?.session.close();
-        config.connectionString = undefined;
-    });
-
-    beforeAll(async function () {
-        // Downloading Windows executables in CI takes a long time because
-        // they include debug symbols...
-        const tmpDir = path.join(__dirname, "..", "tmp");
-        await fs.mkdir(tmpDir, { recursive: true });
-
-        // On Windows, we may have a situation where mongod.exe is not fully released by the OS
-        // before we attempt to run it again, so we add a retry.
-        let dbsDir = path.join(tmpDir, "mongodb-runner", "dbs");
-        for (let i = 0; i < 10; i++) {
-            try {
-                mongoCluster = await MongoCluster.start({
-                    tmpDir: dbsDir,
-                    logDir: path.join(tmpDir, "mongodb-runner", "logs"),
-                    topology: "standalone",
-                });
-
-                return;
-            } catch (err) {
-                if (i < 5) {
-                    // Just wait a little bit and retry
-                    console.error(`Failed to start cluster in ${dbsDir}, attempt ${i}: ${err}`);
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                } else {
-                    // If we still fail after 5 seconds, try another db dir
-                    console.error(
-                        `Failed to start cluster in ${dbsDir}, attempt ${i}: ${err}. Retrying with a new db dir.`
-                    );
-                    dbsDir = path.join(tmpDir, "mongodb-runner", `dbs${i - 5}`);
-                }
-            }
-        }
-
-        throw new Error("Failed to start cluster after 10 attempts");
-    }, 120_000);
-
-    afterAll(async function () {
-        await mongoCluster?.close();
-        mongoCluster = undefined;
-    });
-
     const getMcpClient = () => {
         if (!mcpClient) {
             throw new Error("beforeEach() hook not ran yet");
@@ -142,41 +90,25 @@ export function setupIntegrationTest(): IntegrationTest {
         return mcpServer;
     };
 
-    const getConnectionString = () => {
-        if (!mongoCluster) {
-            throw new Error("beforeAll() hook not ran yet");
-        }
-
-        return mongoCluster.connectionString;
-    };
-
     return {
         mcpClient: getMcpClient,
         mcpServer: getMcpServer,
-        mongoClient: () => {
-            if (!mongoClient) {
-                mongoClient = new MongoClient(getConnectionString());
-            }
-            return mongoClient;
-        },
-        connectionString: getConnectionString,
-        connectMcpClient: async () => {
-            await getMcpClient().callTool({
-                name: "connect",
-                arguments: { options: [{ connectionString: getConnectionString() }] },
-            });
-        },
-        randomDbName: () => randomDbName,
     };
 }
 
-export function getResponseContent(content: unknown): string {
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+export function getResponseContent(content: unknown | { content: unknown }): string {
     return getResponseElements(content)
         .map((item) => item.text)
         .join("\n");
 }
 
-export function getResponseElements(content: unknown): { type: string; text: string }[] {
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+export function getResponseElements(content: unknown | { content: unknown }): { type: string; text: string }[] {
+    if (typeof content === "object" && content !== null && "content" in content) {
+        content = (content as { content: unknown }).content;
+    }
+
     expect(Array.isArray(content)).toBe(true);
 
     const response = content as { type: string; text: string }[];
@@ -198,9 +130,9 @@ export async function connect(client: Client, connectionString: string): Promise
 
 export function getParameters(tool: ToolInfo): ParameterInfo[] {
     expect(tool.inputSchema.type).toBe("object");
-    expect(tool.inputSchema.properties).toBeDefined();
+    expectDefined(tool.inputSchema.properties);
 
-    return Object.entries(tool.inputSchema.properties!)
+    return Object.entries(tool.inputSchema.properties)
         .sort((a, b) => a[0].localeCompare(b[0]))
         .map(([key, value]) => {
             expect(value).toHaveProperty("type");
@@ -218,24 +150,69 @@ export function getParameters(tool: ToolInfo): ParameterInfo[] {
         });
 }
 
-export const dbOperationParameters: ParameterInfo[] = [
+export const databaseParameters: ParameterInfo[] = [
     { name: "database", type: "string", description: "Database name", required: true },
+];
+
+export const databaseCollectionParameters: ParameterInfo[] = [
+    ...databaseParameters,
     { name: "collection", type: "string", description: "Collection name", required: true },
 ];
 
-export function validateParameters(tool: ToolInfo, parameters: ParameterInfo[]): void {
-    const toolParameters = getParameters(tool);
-    expect(toolParameters).toHaveLength(parameters.length);
-    expect(toolParameters).toIncludeAllMembers(parameters);
+export const databaseCollectionInvalidArgs = [
+    {},
+    { database: "test" },
+    { collection: "foo" },
+    { database: 123, collection: "foo" },
+    { database: "test", collection: 123 },
+    { database: [], collection: "foo" },
+    { database: "test", collection: [] },
+];
+
+export const databaseInvalidArgs = [{}, { database: 123 }, { database: [] }];
+
+export function validateToolMetadata(
+    integration: IntegrationTest,
+    name: string,
+    description: string,
+    parameters: ParameterInfo[]
+): void {
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const tool = tools.find((tool) => tool.name === name);
+        expectDefined(tool);
+        expect(tool.description).toBe(description);
+
+        const toolParameters = getParameters(tool);
+        expect(toolParameters).toHaveLength(parameters.length);
+        expect(toolParameters).toIncludeAllMembers(parameters);
+    });
 }
 
-export function describeAtlas(name: number | string | Function | jest.FunctionLike, fn: jest.EmptyFunction) {
-    if (!process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length) {
-        return describe.skip("atlas", () => {
-            describe(name, fn);
-        });
-    }
-    return describe("atlas", () => {
-        describe(name, fn);
+export function validateThrowsForInvalidArguments(
+    integration: IntegrationTest,
+    name: string,
+    args: { [x: string]: unknown }[]
+): void {
+    describe("with invalid arguments", () => {
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                try {
+                    await integration.mcpClient().callTool({ name, arguments: arg });
+                    throw new Error("Expected an error to be thrown");
+                } catch (error) {
+                    expect((error as Error).message).not.toEqual("Expected an error to be thrown");
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain(`Invalid arguments for tool ${name}`);
+                }
+            });
+        }
     });
 }
+
+/** Expects the argument being defined and asserts it */
+export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined> {
+    expect(arg).toBeDefined();
+}

package/tests/integration/inMemoryTransport.ts

@@ -39,6 +39,7 @@ export class InMemoryTransport implements Transport {
         return Promise.resolve();
     }
 
+    // eslint-disable-next-line @typescript-eslint/require-await
     async close(): Promise<void> {
         this.outputController.close();
         this.onclose?.();
@@ -49,10 +50,10 @@ export class InMemoryTransport implements Transport {
     sessionId?: string | undefined;
 
     private static getPromise(): [Promise<void>, resolve: () => void] {
-        let resolve: () => void;
+        let resolve: () => void = () => {};
         const promise = new Promise<void>((res) => {
             resolve = res;
         });
-        return [promise, resolve!];
+        return [promise, resolve];
     }
 }

package/tests/integration/server.test.ts

@@ -1,35 +1,61 @@
-import { setupIntegrationTest } from "./helpers";
+import { expectDefined, setupIntegrationTest } from "./helpers.js";
+import { config } from "../../src/config.js";
 
 describe("Server integration test", () => {
-    const integration = setupIntegrationTest();
+    describe("without atlas", () => {
+        const integration = setupIntegrationTest({
+            ...config,
+            apiClientId: undefined,
+            apiClientSecret: undefined,
+        });
 
-    describe("list capabilities", () => {
-        it("should return positive number of tools", async () => {
+        it("should return positive number of tools and have no atlas tools", async () => {
             const tools = await integration.mcpClient().listTools();
-            expect(tools).toBeDefined();
+            expectDefined(tools);
             expect(tools.tools.length).toBeGreaterThan(0);
+
+            const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
+            expect(atlasTools.length).toBeLessThanOrEqual(0);
         });
+    });
+    describe("with atlas", () => {
+        const integration = setupIntegrationTest({
+            ...config,
+            apiClientId: "test",
+            apiClientSecret: "test",
+        });
+
+        describe("list capabilities", () => {
+            it("should return positive number of tools and have some atlas tools", async () => {
+                const tools = await integration.mcpClient().listTools();
+                expectDefined(tools);
+                expect(tools.tools.length).toBeGreaterThan(0);
 
-        it("should return no resources", async () => {
-            await expect(() => integration.mcpClient().listResources()).rejects.toMatchObject({
-                message: "MCP error -32601: Method not found",
+                const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
+                expect(atlasTools.length).toBeGreaterThan(0);
             });
-        });
 
-        it("should return no prompts", async () => {
-            await expect(() => integration.mcpClient().listPrompts()).rejects.toMatchObject({
-                message: "MCP error -32601: Method not found",
+            it("should return no resources", async () => {
+                await expect(() => integration.mcpClient().listResources()).rejects.toMatchObject({
+                    message: "MCP error -32601: Method not found",
+                });
             });
-        });
 
-        it("should return capabilities", async () => {
-            const capabilities = integration.mcpClient().getServerCapabilities();
-            expect(capabilities).toBeDefined();
-            expect(capabilities?.completions).toBeUndefined();
-            expect(capabilities?.experimental).toBeUndefined();
-            expect(capabilities?.tools).toBeDefined();
-            expect(capabilities?.logging).toBeDefined();
-            expect(capabilities?.prompts).toBeUndefined();
+            it("should return no prompts", async () => {
+                await expect(() => integration.mcpClient().listPrompts()).rejects.toMatchObject({
+                    message: "MCP error -32601: Method not found",
+                });
+            });
+
+            it("should return capabilities", () => {
+                const capabilities = integration.mcpClient().getServerCapabilities();
+                expectDefined(capabilities);
+                expect(capabilities.completions).toBeUndefined();
+                expect(capabilities.experimental).toBeUndefined();
+                expectDefined(capabilities?.tools);
+                expectDefined(capabilities?.logging);
+                expect(capabilities?.prompts).toBeUndefined();
+            });
         });
     });
 });

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

@@ -1,6 +1,6 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { Session } from "../../../../src/session.js";
-import { describeAtlas, withProject } from "./atlasHelpers.js";
+import { describeWithAtlas, withProject } from "./atlasHelpers.js";
+import { expectDefined } from "../../helpers.js";
 
 function generateRandomIp() {
     const randomIp: number[] = [192];
@@ -10,27 +10,25 @@ function generateRandomIp() {
     return randomIp.join(".");
 }
 
-describeAtlas("ip access lists", (integration) => {
+describeWithAtlas("ip access lists", (integration) => {
     withProject(integration, ({ getProjectId }) => {
         const ips = [generateRandomIp(), generateRandomIp()];
         const cidrBlocks = [generateRandomIp() + "/16", generateRandomIp() + "/24"];
         const values = [...ips, ...cidrBlocks];
 
         beforeAll(async () => {
-            const session: Session = integration.mcpServer().session;
-            session.ensureAuthenticated();
-            const ipInfo = await session.apiClient.getIpInfo();
+            const apiClient = integration.mcpServer().session.apiClient;
+            const ipInfo = await apiClient.getIpInfo();
             values.push(ipInfo.currentIpv4Address);
         });
 
         afterAll(async () => {
-            const session: Session = integration.mcpServer().session;
-            session.ensureAuthenticated();
+            const apiClient = integration.mcpServer().session.apiClient;
 
             const projectId = getProjectId();
 
             for (const value of values) {
-                await session.apiClient.deleteProjectIpAccessList({
+                await apiClient.deleteProjectIpAccessList({
                     params: {
                         path: {
                             groupId: projectId,
@@ -44,10 +42,10 @@ describeAtlas("ip access lists", (integration) => {
         describe("atlas-create-access-list", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const createAccessList = tools.find((tool) => tool.name === "atlas-create-access-list")!;
-                expect(createAccessList).toBeDefined();
+                const createAccessList = tools.find((tool) => tool.name === "atlas-create-access-list");
+                expectDefined(createAccessList);
                 expect(createAccessList.inputSchema.type).toBe("object");
-                expect(createAccessList.inputSchema.properties).toBeDefined();
+                expectDefined(createAccessList.inputSchema.properties);
                 expect(createAccessList.inputSchema.properties).toHaveProperty("projectId");
                 expect(createAccessList.inputSchema.properties).toHaveProperty("ipAddresses");
                 expect(createAccessList.inputSchema.properties).toHaveProperty("cidrBlocks");
@@ -76,10 +74,10 @@ describeAtlas("ip access lists", (integration) => {
         describe("atlas-inspect-access-list", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const inspectAccessList = tools.find((tool) => tool.name === "atlas-inspect-access-list")!;
-                expect(inspectAccessList).toBeDefined();
+                const inspectAccessList = tools.find((tool) => tool.name === "atlas-inspect-access-list");
+                expectDefined(inspectAccessList);
                 expect(inspectAccessList.inputSchema.type).toBe("object");
-                expect(inspectAccessList.inputSchema.properties).toBeDefined();
+                expectDefined(inspectAccessList.inputSchema.properties);
                 expect(inspectAccessList.inputSchema.properties).toHaveProperty("projectId");
             });
 

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

@@ -2,7 +2,6 @@ import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
 import { setupIntegrationTest, IntegrationTest } from "../../helpers.js";
-import { Session } from "../../../../src/session.js";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
@@ -10,7 +9,7 @@ export function sleep(ms: number) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-export function describeAtlas(name: number | string | Function | jest.FunctionLike, fn: IntegrationTestFunction) {
+export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     const testDefinition = () => {
         const integration = setupIntegrationTest();
         describe(name, () => {
@@ -35,19 +34,15 @@ export function withProject(integration: IntegrationTest, fn: ProjectTestFunctio
         let projectId: string = "";
 
         beforeAll(async () => {
-            const session: Session = integration.mcpServer().session;
-            session.ensureAuthenticated();
+            const apiClient = integration.mcpServer().session.apiClient;
 
-            const apiClient = session.apiClient;
             const group = await createProject(apiClient);
             projectId = group.id || "";
         });
 
         afterAll(async () => {
-            const session: Session = integration.mcpServer().session;
-            session.ensureAuthenticated();
+            const apiClient = integration.mcpServer().session.apiClient;
 
-            const apiClient = session.apiClient;
             await apiClient.deleteProject({
                 params: {
                     path: {

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

@@ -1,10 +1,9 @@
 import { Session } from "../../../../src/session.js";
-import { describeAtlas, withProject, sleep, randomId } from "./atlasHelpers.js";
+import { expectDefined } from "../../helpers.js";
+import { describeWithAtlas, withProject, sleep, randomId } from "./atlasHelpers.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 
 async function deleteAndWaitCluster(session: Session, projectId: string, clusterName: string) {
-    session.ensureAuthenticated();
-
     await session.apiClient.deleteCluster({
         params: {
             path: {
@@ -30,7 +29,7 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
     }
 }
 
-describeAtlas("clusters", (integration) => {
+describeWithAtlas("clusters", (integration) => {
     withProject(integration, ({ getProjectId }) => {
         const clusterName = "ClusterTest-" + randomId;
 
@@ -45,11 +44,11 @@ describeAtlas("clusters", (integration) => {
         describe("atlas-create-free-cluster", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const createFreeCluster = tools.find((tool) => tool.name === "atlas-create-free-cluster")!;
+                const createFreeCluster = tools.find((tool) => tool.name === "atlas-create-free-cluster");
 
-                expect(createFreeCluster).toBeDefined();
+                expectDefined(createFreeCluster);
                 expect(createFreeCluster.inputSchema.type).toBe("object");
-                expect(createFreeCluster.inputSchema.properties).toBeDefined();
+                expectDefined(createFreeCluster.inputSchema.properties);
                 expect(createFreeCluster.inputSchema.properties).toHaveProperty("projectId");
                 expect(createFreeCluster.inputSchema.properties).toHaveProperty("name");
                 expect(createFreeCluster.inputSchema.properties).toHaveProperty("region");
@@ -75,11 +74,11 @@ describeAtlas("clusters", (integration) => {
         describe("atlas-inspect-cluster", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const inspectCluster = tools.find((tool) => tool.name === "atlas-inspect-cluster")!;
+                const inspectCluster = tools.find((tool) => tool.name === "atlas-inspect-cluster");
 
-                expect(inspectCluster).toBeDefined();
+                expectDefined(inspectCluster);
                 expect(inspectCluster.inputSchema.type).toBe("object");
-                expect(inspectCluster.inputSchema.properties).toBeDefined();
+                expectDefined(inspectCluster.inputSchema.properties);
                 expect(inspectCluster.inputSchema.properties).toHaveProperty("projectId");
                 expect(inspectCluster.inputSchema.properties).toHaveProperty("clusterName");
             });
@@ -100,10 +99,10 @@ describeAtlas("clusters", (integration) => {
         describe("atlas-list-clusters", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const listClusters = tools.find((tool) => tool.name === "atlas-list-clusters")!;
-                expect(listClusters).toBeDefined();
+                const listClusters = tools.find((tool) => tool.name === "atlas-list-clusters");
+                expectDefined(listClusters);
                 expect(listClusters.inputSchema.type).toBe("object");
-                expect(listClusters.inputSchema.properties).toBeDefined();
+                expectDefined(listClusters.inputSchema.properties);
                 expect(listClusters.inputSchema.properties).toHaveProperty("projectId");
             });
 

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

@@ -1,15 +1,15 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { Session } from "../../../../src/session.js";
-import { describeAtlas, withProject, randomId } from "./atlasHelpers.js";
+import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
+import { expectDefined } from "../../helpers.js";
 
-describeAtlas("db users", (integration) => {
+describeWithAtlas("db users", (integration) => {
     const userName = "testuser-" + randomId;
     withProject(integration, ({ getProjectId }) => {
         afterAll(async () => {
             const projectId = getProjectId();
 
             const session: Session = integration.mcpServer().session;
-            session.ensureAuthenticated();
             await session.apiClient.deleteDatabaseUser({
                 params: {
                     path: {
@@ -24,10 +24,10 @@ describeAtlas("db users", (integration) => {
         describe("atlas-create-db-user", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const createDbUser = tools.find((tool) => tool.name === "atlas-create-db-user")!;
-                expect(createDbUser).toBeDefined();
+                const createDbUser = tools.find((tool) => tool.name === "atlas-create-db-user");
+                expectDefined(createDbUser);
                 expect(createDbUser.inputSchema.type).toBe("object");
-                expect(createDbUser.inputSchema.properties).toBeDefined();
+                expectDefined(createDbUser.inputSchema.properties);
                 expect(createDbUser.inputSchema.properties).toHaveProperty("projectId");
                 expect(createDbUser.inputSchema.properties).toHaveProperty("username");
                 expect(createDbUser.inputSchema.properties).toHaveProperty("password");
@@ -59,10 +59,10 @@ describeAtlas("db users", (integration) => {
         describe("atlas-list-db-users", () => {
             it("should have correct metadata", async () => {
                 const { tools } = await integration.mcpClient().listTools();
-                const listDbUsers = tools.find((tool) => tool.name === "atlas-list-db-users")!;
-                expect(listDbUsers).toBeDefined();
+                const listDbUsers = tools.find((tool) => tool.name === "atlas-list-db-users");
+                expectDefined(listDbUsers);
                 expect(listDbUsers.inputSchema.type).toBe("object");
-                expect(listDbUsers.inputSchema.properties).toBeDefined();
+                expectDefined(listDbUsers.inputSchema.properties);
                 expect(listDbUsers.inputSchema.properties).toHaveProperty("projectId");
             });
             it("returns database users by project", async () => {

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

@@ -1,13 +1,13 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { setupIntegrationTest } from "../../helpers.js";
-import { parseTable, describeAtlas } from "./atlasHelpers.js";
+import { expectDefined } from "../../helpers.js";
+import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
 
-describeAtlas("orgs", (integration) => {
+describeWithAtlas("orgs", (integration) => {
     describe("atlas-list-orgs", () => {
         it("should have correct metadata", async () => {
             const { tools } = await integration.mcpClient().listTools();
             const listOrgs = tools.find((tool) => tool.name === "atlas-list-orgs");
-            expect(listOrgs).toBeDefined();
+            expectDefined(listOrgs);
         });
 
         it("returns org names", async () => {