chore: add arg validation test coverage

src/tools/args.ts

@@ -29,7 +29,7 @@ export const CommonArgs = {
 };
 
 export const AtlasArgs = {
-    projectId: (): z.ZodString => CommonArgs.objectId("projectId"),
+    projectId: (): z.ZodString => CommonArgs.objectId("projectId").describe("Atlas project ID"),
 
     organizationId: (): z.ZodString => CommonArgs.objectId("organizationId"),
 
@@ -68,3 +68,12 @@ export const AtlasArgs = {
     password: (): z.ZodString =>
         z.string().min(1, "Password is required").max(100, "Password must be 100 characters or less"),
 };
+
+export const ProjectAndClusterArgs = {
+    projectId: AtlasArgs.projectId(),
+    clusterName: AtlasArgs.clusterName().describe("Atlas cluster name"),
+};
+
+export const ProjectArgs = {
+    projectId: AtlasArgs.projectId(),
+};

src/tools/atlas/connect/connectCluster.ts

@@ -20,7 +20,7 @@ function sleep(ms: number): Promise<void> {
 }
 
 export const ConnectClusterArgs = {
-    projectId: AtlasArgs.projectId().describe("Atlas project ID"),
+    projectId: AtlasArgs.projectId(),
     clusterName: AtlasArgs.clusterName().describe("Atlas cluster name"),
 };
 

src/tools/atlas/create/createAccessList.ts

@@ -3,10 +3,10 @@ import { type OperationType, type ToolArgs } from "../../tool.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { makeCurrentIpAccessListEntry, DEFAULT_ACCESS_LIST_COMMENT } from "../../../common/atlas/accessListUtils.js";
-import { AtlasArgs, CommonArgs } from "../../args.js";
+import { AtlasArgs, CommonArgs, ProjectArgs } from "../../args.js";
 
 export const CreateAccessListArgs = {
-    projectId: AtlasArgs.projectId().describe("Atlas project ID"),
+    ...ProjectArgs,
     ipAddresses: z.array(AtlasArgs.ipAddress()).describe("IP addresses to allow access from").optional(),
     cidrBlocks: z.array(AtlasArgs.cidrBlock()).describe("CIDR blocks to allow access from").optional(),
     currentIpAddress: z.boolean().describe("Add the current IP address").default(false),

src/tools/atlas/create/createDBUser.ts

@@ -8,7 +8,7 @@ import { ensureCurrentIpInAccessList } from "../../../common/atlas/accessListUti
 import { AtlasArgs, CommonArgs } from "../../args.js";
 
 export const CreateDBUserArgs = {
-    projectId: AtlasArgs.projectId().describe("Atlas project ID"),
+    projectId: AtlasArgs.projectId(),
     username: AtlasArgs.username().describe("Username for the new user"),
     // Models will generate overly simplistic passwords like SecurePassword123 or
     // AtlasPassword123, which are easily guessable and exploitable. We're instructing
@@ -26,7 +26,7 @@ export const CreateDBUserArgs = {
                 collectionName: CommonArgs.string().describe("Collection name").optional(),
             })
         )
-        .describe("Roles for the new user"),
+        .describe("Roles for the new database user"),
     clusters: z
         .array(AtlasArgs.clusterName())
         .describe("Clusters to assign the user to, leave empty for access to all clusters")
@@ -35,7 +35,7 @@ export const CreateDBUserArgs = {
 
 export class CreateDBUserTool extends AtlasToolBase {
     public name = "atlas-create-db-user";
-    protected description = "Create an MongoDB Atlas database user";
+    protected description = "Create a MongoDB Atlas database user";
     public operationType: OperationType = "create";
     protected argsShape = {
         ...CreateDBUserArgs,

src/tools/atlas/read/inspectAccessList.ts

@@ -4,7 +4,7 @@ import { AtlasToolBase } from "../atlasTool.js";
 import { AtlasArgs } from "../../args.js";
 
 export const InspectAccessListArgs = {
-    projectId: AtlasArgs.projectId().describe("Atlas project ID"),
+    projectId: AtlasArgs.projectId(),
 };
 
 export class InspectAccessListTool extends AtlasToolBase {

src/tools/atlas/read/inspectCluster.ts

@@ -3,19 +3,14 @@ import { type OperationType, type ToolArgs, formatUntrustedData } from "../../to
 import { AtlasToolBase } from "../atlasTool.js";
 import type { Cluster } from "../../../common/atlas/cluster.js";
 import { inspectCluster } from "../../../common/atlas/cluster.js";
-import { AtlasArgs } from "../../args.js";
-
-export const InspectClusterArgs = {
-    projectId: AtlasArgs.projectId().describe("Atlas project ID"),
-    clusterName: AtlasArgs.clusterName().describe("Atlas cluster name"),
-};
+import { ProjectAndClusterArgs } from "../../args.js";
 
 export class InspectClusterTool extends AtlasToolBase {
     public name = "atlas-inspect-cluster";
     protected description = "Inspect MongoDB Atlas cluster";
     public operationType: OperationType = "read";
     protected argsShape = {
-        ...InspectClusterArgs,
+        ...ProjectAndClusterArgs,
     };
 
     protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {

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,16 @@ 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 databaseCollectionInvalidArgs = [
     {},
     { database: "test" },
@@ -245,6 +257,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(

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 }) => {

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 = "";
 

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;
 

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

@@ -1,10 +1,19 @@
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { expectDefined, getResponseElements } from "../../helpers.js";
+import {
+    expectDefined,
+    getResponseElements,
+    projectIdInvalidArgs,
+    validateThrowsForInvalidArguments,
+} 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", () => {
+        validateThrowsForInvalidArguments(integration, "atlas-create-db-user", projectIdInvalidArgs);
+    });
+
     withProject(integration, ({ getProjectId }) => {
         let userName: string;
         beforeEach(() => {

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");
+            });
         });
     });
 });