chore: add arg validation test coverage

blva · blva · commit 93c27ece51ee · 2025-09-18T14:56:55.000+01:00
diff --git a/src/tools/mongodb/mongodbTool.ts b/src/tools/mongodb/mongodbTool.ts
@@ -6,10 +6,11 @@ import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../common/errors.js";
 import { LogId } from "../../common/logger.js";
 import type { Server } from "../../server.js";
+import { CommonArgs } from "../args.js";
 
 export const DbOperationArgs = {
-    database: z.string().describe("Database name"),
-    collection: z.string().describe("Collection name"),
+    database: CommonArgs.string().describe("Database name"),
+    collection: CommonArgs.string().describe("Collection name"),
 };
 
 export abstract class MongoDBToolBase extends ToolBase {
diff --git a/tests/integration/helpers.ts b/tests/integration/helpers.ts
@@ -96,8 +96,10 @@ export function setupIntegrationTest(
             keychain: new Keychain(),
         });
 
-        // Mock hasValidAccessToken for tests
+        // Mock API Client for tests
         if (!userConfig.apiClientId && !userConfig.apiClientSecret) {
+            userConfig.apiClientId = "test";
+            userConfig.apiClientSecret = "test";
             const mockFn = vi.fn().mockResolvedValue(true);
             session.apiClient.validateAccessToken = mockFn;
         }
@@ -235,6 +237,29 @@ export const databaseCollectionParameters: ParameterInfo[] = [
     { name: "collection", type: "string", description: "Collection name", required: true },
 ];
 
+export const projectIdParameters: ParameterInfo[] = [
+    { name: "projectId", type: "string", description: "Atlas project ID", required: true },
+];
+
+export const createClusterParameters: ParameterInfo[] = [
+    { name: "name", type: "string", description: "Name of the cluster", required: true },
+    { name: "projectId", type: "string", description: "Atlas project ID to create the cluster in", required: true },
+    { name: "region", type: "string", description: "Region of the cluster", required: false },
+];
+
+export const createDbUserParameters: ParameterInfo[] = [
+    {
+        name: "projectId",
+        type: "string",
+        description: "Atlas project ID to create the database user in",
+        required: true,
+    },
+    { name: "username", type: "string", description: "Username of the database user", required: true },
+    { name: "password", type: "string", description: "Password of the database user", required: false },
+    { name: "roles", type: "array", description: "Roles of the database user", required: true },
+    { name: "scopes", type: "array", description: "Scopes of the database user", required: false },
+];
+
 export const databaseCollectionInvalidArgs = [
     {},
     { database: "test" },
@@ -245,6 +270,14 @@ export const databaseCollectionInvalidArgs = [
     { database: "test", collection: [] },
 ];
 
+export const projectIdInvalidArgs = [
+    {},
+    { projectId: 123 },
+    { projectId: [] },
+    { projectId: "!✅invalid" },
+    { projectId: "invalid-test-project-id" },
+];
+
 export const databaseInvalidArgs = [{}, { database: 123 }, { database: [] }];
 
 export function validateToolMetadata(
diff --git a/tests/integration/tools/atlas/alerts.test.ts b/tests/integration/tools/atlas/alerts.test.ts
@@ -1,15 +1,24 @@
-import { expectDefined, getResponseElements } from "../../helpers.js";
+import {
+    getResponseElements,
+    projectIdInvalidArgs,
+    validateThrowsForInvalidArguments,
+    validateToolMetadata,
+} from "../../helpers.js";
 import { parseTable, describeWithAtlas, withProject } from "./atlasHelpers.js";
-import { expect, it } from "vitest";
+import { expect, it, describe } from "vitest";
 
 describeWithAtlas("atlas-list-alerts", (integration) => {
-    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");
+    describe("should have correct metadata and validate invalid arguments", () => {
+        validateToolMetadata(integration, "atlas-list-alerts", "List MongoDB Atlas alerts", [
+            {
+                name: "projectId",
+                type: "string",
+                description: "Atlas project ID to list alerts for",
+                required: true,
+            },
+        ]);
+
+        validateThrowsForInvalidArguments(integration, "atlas-list-alerts", projectIdInvalidArgs);
     });
 
     withProject(integration, ({ getProjectId }) => {
diff --git a/tests/integration/tools/atlas/atlasHelpers.ts b/tests/integration/tools/atlas/atlasHelpers.ts
@@ -9,11 +9,7 @@ import { afterAll, beforeAll, describe } from "vitest";
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
 export function describeWithAtlas(name: string, fn: IntegrationTestFunction): void {
-    const describeFn =
-        !process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length
-            ? describe.skip
-            : describe;
-    describeFn(name, () => {
+    describe(name, () => {
         const integration = setupIntegrationTest(
             () => ({
                 ...defaultTestConfig,
@@ -34,8 +30,23 @@ interface ProjectTestArgs {
 
 type ProjectTestFunction = (args: ProjectTestArgs) => void;
 
+export function withCredentials(integration: IntegrationTest, fn: IntegrationTestFunction): SuiteCollector<object> {
+    const describeFn =
+        !process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length
+            ? describe.skip
+            : describe;
+    return describeFn("with credentials", () => {
+        fn(integration);
+    });
+}
+
 export function withProject(integration: IntegrationTest, fn: ProjectTestFunction): SuiteCollector<object> {
-    return describe("with project", () => {
+    const describeFn =
+        !process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length
+            ? describe.skip
+            : describe;
+
+    return describeFn("with project", () => {
         let projectId: string = "";
         let ipAddress: string = "";
 
diff --git a/tests/integration/tools/atlas/clusters.test.ts b/tests/integration/tools/atlas/clusters.test.ts
@@ -1,5 +1,13 @@
 import type { Session } from "../../../../src/common/session.js";
-import { expectDefined, getDataFromUntrustedContent, getResponseElements } from "../../helpers.js";
+import {
+    expectDefined,
+    getResponseElements,
+    getDataFromUntrustedContent,
+    createClusterParameters,
+    projectIdInvalidArgs,
+    validateThrowsForInvalidArguments,
+    validateToolMetadata,
+} from "../../helpers.js";
 import { describeWithAtlas, withProject, randomId, parseTable } from "./atlasHelpers.js";
 import type { ClusterDescription20240805 } from "../../../../src/common/atlas/openapi.js";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
@@ -57,6 +65,19 @@ async function waitCluster(
 }
 
 describeWithAtlas("clusters", (integration) => {
+    describe("should have correct metadata and validate invalid arguments", () => {
+        validateToolMetadata(
+            integration,
+            "atlas-create-free-cluster",
+            "Create a free MongoDB Atlas cluster",
+            createClusterParameters
+        );
+
+        expect(() => {
+            validateThrowsForInvalidArguments(integration, "atlas-create-free-cluster", projectIdInvalidArgs);
+        }).not.toThrow();
+    });
+
     withProject(integration, ({ getProjectId, getIpAddress }) => {
         const clusterName = "ClusterTest-" + randomId;
 
diff --git a/tests/integration/tools/atlas/dbUsers.test.ts b/tests/integration/tools/atlas/dbUsers.test.ts
@@ -1,10 +1,21 @@
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { expectDefined, getResponseElements } from "../../helpers.js";
+import {
+    expectDefined,
+    getResponseElements,
+    projectIdInvalidArgs,
+    validateThrowsForInvalidArguments,
+    validateToolMetadata,
+} from "../../helpers.js";
 import { ApiClientError } from "../../../../src/common/atlas/apiClientError.js";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { Keychain } from "../../../../src/common/keychain.js";
 
 describeWithAtlas("db users", (integration) => {
+    describe("should have correct metadata and validate invalid arguments", () => {
+        validateToolMetadata(integration, "atlas-create-db-user", "Create a database user", createDbUserParameters);
+        validateThrowsForInvalidArguments(integration, "atlas-create-db-user", projectIdInvalidArgs);
+    });
+
     withProject(integration, ({ getProjectId }) => {
         let userName: string;
         beforeEach(() => {
diff --git a/tests/integration/tools/atlas/orgs.test.ts b/tests/integration/tools/atlas/orgs.test.ts
@@ -1,23 +1,25 @@
 import { expectDefined, getDataFromUntrustedContent, getResponseElements } from "../../helpers.js";
-import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
+import { parseTable, describeWithAtlas, withCredentials } from "./atlasHelpers.js";
 import { describe, expect, it } from "vitest";
 
 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");
-            expectDefined(listOrgs);
-        });
+    withCredentials(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");
+                expectDefined(listOrgs);
+            });
 
-        it("returns org names", async () => {
-            const response = await integration.mcpClient().callTool({ name: "atlas-list-orgs", arguments: {} });
-            const elements = getResponseElements(response);
-            expect(elements[0]?.text).toContain("Found 1 organizations");
-            expect(elements[1]?.text).toContain("<untrusted-user-data-");
-            const data = parseTable(getDataFromUntrustedContent(elements[1]?.text ?? ""));
-            expect(data).toHaveLength(1);
-            expect(data[0]?.["Organization Name"]).toEqual("MongoDB MCP Test");
+            it("returns org names", async () => {
+                const response = await integration.mcpClient().callTool({ name: "atlas-list-orgs", arguments: {} });
+                const elements = getResponseElements(response);
+                expect(elements[0]?.text).toContain("Found 1 organizations");
+                expect(elements[1]?.text).toContain("<untrusted-user-data-");
+                const data = parseTable(getDataFromUntrustedContent(elements[1]?.text ?? ""));
+                expect(data).toHaveLength(1);
+                expect(data[0]?.["Organization Name"]).toEqual("MongoDB MCP Test");
+            });
         });
     });
 });
diff --git a/tests/integration/tools/atlas/projects.test.ts b/tests/integration/tools/atlas/projects.test.ts
@@ -1,79 +1,81 @@
 import { ObjectId } from "mongodb";
-import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
+import { parseTable, describeWithAtlas, withCredentials } from "./atlasHelpers.js";
 import { expectDefined, getDataFromUntrustedContent, getResponseElements } from "../../helpers.js";
 import { afterAll, describe, expect, it } from "vitest";
 
 const randomId = new ObjectId().toString();
 
 describeWithAtlas("projects", (integration) => {
-    const projName = "testProj-" + randomId;
+    withCredentials(integration, () => {
+        const projName = "testProj-" + randomId;
 
-    afterAll(async () => {
-        const session = integration.mcpServer().session;
+        afterAll(async () => {
+            const session = integration.mcpServer().session;
 
-        const projects = await session.apiClient.listProjects();
-        for (const project of projects?.results || []) {
-            if (project.name === projName) {
-                await session.apiClient.deleteProject({
-                    params: {
-                        path: {
-                            groupId: project.id || "",
+            const projects = await session.apiClient.listProjects();
+            for (const project of projects?.results || []) {
+                if (project.name === projName) {
+                    await session.apiClient.deleteProject({
+                        params: {
+                            path: {
+                                groupId: project.id || "",
+                            },
                         },
-                    },
-                });
-                break;
+                    });
+                    break;
+                }
             }
-        }
-    });
-
-    describe("atlas-create-project", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const createProject = tools.find((tool) => tool.name === "atlas-create-project");
-            expectDefined(createProject);
-            expect(createProject.inputSchema.type).toBe("object");
-            expectDefined(createProject.inputSchema.properties);
-            expect(createProject.inputSchema.properties).toHaveProperty("projectName");
-            expect(createProject.inputSchema.properties).toHaveProperty("organizationId");
         });
-        it("should create a project", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "atlas-create-project",
-                arguments: { projectName: projName },
+
+        describe("atlas-create-project", () => {
+            it("should have correct metadata", async () => {
+                const { tools } = await integration.mcpClient().listTools();
+                const createProject = tools.find((tool) => tool.name === "atlas-create-project");
+                expectDefined(createProject);
+                expect(createProject.inputSchema.type).toBe("object");
+                expectDefined(createProject.inputSchema.properties);
+                expect(createProject.inputSchema.properties).toHaveProperty("projectName");
+                expect(createProject.inputSchema.properties).toHaveProperty("organizationId");
             });
+            it("should create a project", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "atlas-create-project",
+                    arguments: { projectName: projName },
+                });
 
-            const elements = getResponseElements(response);
-            expect(elements).toHaveLength(1);
-            expect(elements[0]?.text).toContain(projName);
-        });
-    });
-    describe("atlas-list-projects", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const listProjects = tools.find((tool) => tool.name === "atlas-list-projects");
-            expectDefined(listProjects);
-            expect(listProjects.inputSchema.type).toBe("object");
-            expectDefined(listProjects.inputSchema.properties);
-            expect(listProjects.inputSchema.properties).toHaveProperty("orgId");
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(1);
+                expect(elements[0]?.text).toContain(projName);
+            });
         });
+        describe("atlas-list-projects", () => {
+            it("should have correct metadata", async () => {
+                const { tools } = await integration.mcpClient().listTools();
+                const listProjects = tools.find((tool) => tool.name === "atlas-list-projects");
+                expectDefined(listProjects);
+                expect(listProjects.inputSchema.type).toBe("object");
+                expectDefined(listProjects.inputSchema.properties);
+                expect(listProjects.inputSchema.properties).toHaveProperty("orgId");
+            });
 
-        it("returns project names", async () => {
-            const response = await integration.mcpClient().callTool({ name: "atlas-list-projects", arguments: {} });
-            const elements = getResponseElements(response);
-            expect(elements).toHaveLength(2);
-            expect(elements[1]?.text).toContain("<untrusted-user-data-");
-            expect(elements[1]?.text).toContain(projName);
-            const data = parseTable(getDataFromUntrustedContent(elements[1]?.text ?? ""));
-            expect(data.length).toBeGreaterThan(0);
-            let found = false;
-            for (const project of data) {
-                if (project["Project Name"] === projName) {
-                    found = true;
+            it("returns project names", async () => {
+                const response = await integration.mcpClient().callTool({ name: "atlas-list-projects", arguments: {} });
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(2);
+                expect(elements[1]?.text).toContain("<untrusted-user-data-");
+                expect(elements[1]?.text).toContain(projName);
+                const data = parseTable(getDataFromUntrustedContent(elements[1]?.text ?? ""));
+                expect(data.length).toBeGreaterThan(0);
+                let found = false;
+                for (const project of data) {
+                    if (project["Project Name"] === projName) {
+                        found = true;
+                    }
                 }
-            }
-            expect(found).toBe(true);
+                expect(found).toBe(true);
 
-            expect(elements[0]?.text).toBe(`Found ${data.length} projects`);
+                expect(elements[0]?.text).toBe(`Found ${data.length} projects`);
+            });
         });
     });
 });
