chore: address PR feedback

1. assert function are not assertions so fixed them with relevant names
2. moved static method logic to cli entry point and added e2e for test
   cases

Author: himanshusinghs

package.json

@@ -65,8 +65,8 @@
     "generate": "npm run generate:api && npm run generate:arguments",
     "generate:api": "./scripts/generate.sh",
     "generate:arguments": "tsx scripts/generateArguments.ts",
+    "pretest": "npm run build",
     "test": "vitest --project eslint-rules --project unit-and-integration --coverage",
-    "pretest:accuracy": "npm run build",
     "test:accuracy": "sh ./scripts/accuracy/runAccuracyTests.sh",
     "test:long-running-tests": "vitest --project long-running-tests --coverage",
     "atlas:cleanup": "vitest --project atlas-cleanup"

src/common/config/argsParserOptions.ts

@@ -60,7 +60,7 @@ export const OPTIONS = {
         "apiDeprecationErrors",
         "apiStrict",
         "disableEmbeddingsValidation",
-        "dry",
+        "dryRun",
         "help",
         "indexCheck",
         "ipv6",

src/common/config/userConfig.ts

@@ -167,7 +167,7 @@ export const UserConfigSchema = z4.object({
         )
         .default([])
         .describe("An array of preview features that are enabled."),
-    dry: z4
+    dryRun: z4
         .boolean()
         .default(false)
         .describe(

src/index.ts

@@ -44,15 +44,23 @@ import { StdioRunner } from "./transports/stdio.js";
 import { StreamableHttpRunner } from "./transports/streamableHttp.js";
 import { systemCA } from "@mongodb-js/devtools-proxy-support";
 import { Keychain } from "./common/keychain.js";
-import { DryModeRunner } from "./transports/dryModeRunner.js";
+import { DryRunModeRunner } from "./transports/dryModeRunner.js";
 
 async function main(): Promise<void> {
     systemCA().catch(() => undefined); // load system CA asynchronously as in mongosh
 
     const config = createUserConfig();
-    assertHelpMode(config);
-    assertVersionMode(config);
-    await DryModeRunner.assertDryMode({ userConfig: config });
+    if (config.help) {
+        handleHelpRequest();
+    }
+
+    if (config.version) {
+        handleVersionRequest();
+    }
+
+    if (config.dryRun) {
+        await handleDryRunRequest(config);
+    }
 
     const transportRunner =
         config.transport === "stdio"
@@ -135,17 +143,34 @@ main().catch((error: unknown) => {
     process.exit(1);
 });
 
-function assertHelpMode(config: UserConfig): void | never {
-    if (config.help) {
-        console.log("For usage information refer to the README.md:");
-        console.log("https://github.com/mongodb-js/mongodb-mcp-server?tab=readme-ov-file#quick-start");
-        process.exit(0);
-    }
+function handleHelpRequest(): never {
+    console.log("For usage information refer to the README.md:");
+    console.log("https://github.com/mongodb-js/mongodb-mcp-server?tab=readme-ov-file#quick-start");
+    process.exit(0);
 }
 
-function assertVersionMode(config: UserConfig): void | never {
-    if (config.version) {
-        console.log(packageInfo.version);
+function handleVersionRequest(): never {
+    console.log(packageInfo.version);
+    process.exit(0);
+}
+
+export async function handleDryRunRequest(config: UserConfig): Promise<never> {
+    try {
+        const runner = new DryRunModeRunner({
+            userConfig: config,
+            logger: {
+                log(message): void {
+                    console.log(message);
+                },
+                error(message): void {
+                    console.error(message);
+                },
+            },
+        });
+        await runner.start();
         process.exit(0);
+    } catch (error) {
+        console.error(`Fatal error running server in dry run mode: ${error as string}`);
+        process.exit(1);
     }
 }

src/transports/dryModeRunner.ts

@@ -2,49 +2,34 @@ import { InMemoryTransport } from "./inMemoryTransport.js";
 import { TransportRunnerBase, type TransportRunnerConfig } from "./base.js";
 import { type Server } from "../server.js";
 
-export type DryModeTestHelpers = {
-    exit(this: void, exitCode: number): never;
+export type DryRunModeTestHelpers = {
     logger: {
         log(this: void, message: string): void;
         error(this: void, message: string): void;
     };
 };
 
-type DryModeRunnerConfig = TransportRunnerConfig & DryModeTestHelpers;
+type DryRunModeRunnerConfig = TransportRunnerConfig & DryRunModeTestHelpers;
 
-const defaultLogger: DryModeTestHelpers["logger"] = {
-    log(message) {
-        console.warn(message);
-    },
-    error(message) {
-        console.error(message);
-    },
-};
-
-export class DryModeRunner extends TransportRunnerBase {
+export class DryRunModeRunner extends TransportRunnerBase {
     private server: Server | undefined;
-    private exitProcess: DryModeTestHelpers["exit"];
-    private consoleLogger: DryModeTestHelpers["logger"];
+    private consoleLogger: DryRunModeTestHelpers["logger"];
 
-    constructor({ exit, logger, ...transportRunnerConfig }: DryModeRunnerConfig) {
+    constructor({ logger, ...transportRunnerConfig }: DryRunModeRunnerConfig) {
         super(transportRunnerConfig);
-        this.exitProcess = exit;
         this.consoleLogger = logger;
     }
 
-    async start(): Promise<void> {
-        try {
-            this.server = await this.setupServer();
-            const transport = new InMemoryTransport();
+    override async start(): Promise<void> {
+        this.server = await this.setupServer();
+        const transport = new InMemoryTransport();
 
-            await this.server.connect(transport);
-        } catch (error: unknown) {
-            this.consoleLogger.error(`Fatal error running server: ${error as string}`);
-            this.exitProcess(1);
-        }
+        await this.server.connect(transport);
+        this.dumpConfig();
+        this.dumpTools();
     }
 
-    async closeTransport(): Promise<void> {
+    override async closeTransport(): Promise<void> {
         await this.server?.close();
     }
 
@@ -56,24 +41,9 @@ export class DryModeRunner extends TransportRunnerBase {
     private dumpTools(): void {
         const tools = this.server?.tools.map((tool) => ({
             name: tool.name,
-            description: tool.description,
             category: tool.category,
         }));
         this.consoleLogger.log("Enabled tools:");
         this.consoleLogger.log(JSON.stringify(tools, null, 2));
     }
-
-    static async assertDryMode(
-        runnerConfig: TransportRunnerConfig,
-        exit: DryModeTestHelpers["exit"] = (exitCode: number) => process.exit(exitCode),
-        logger: DryModeTestHelpers["logger"] = defaultLogger
-    ): Promise<void> | never {
-        if (runnerConfig.userConfig.dry) {
-            const runner = new this({ ...runnerConfig, exit, logger });
-            await runner.start();
-            runner.dumpConfig();
-            runner.dumpTools();
-            exit(0);
-        }
-    }
 }

tests/e2e/cli.test.ts

@@ -0,0 +1,29 @@
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { describe, expect, it } from "vitest";
+import packageJson from "../../package.json" with { type: "json" };
+
+const execAsync = promisify(exec);
+const CLI_PATH = path.join(import.meta.dirname, "..", "..", "dist", "index.js");
+
+describe("CLI entrypoint", () => {
+    it("should handle version request", async () => {
+        const { stdout, stderr } = await execAsync(`${process.execPath} ${CLI_PATH} --version`);
+        expect(stdout).toContain(packageJson.version);
+        expect(stderr).toEqual("");
+    });
+
+    it("should handle help request", async () => {
+        const { stdout, stderr } = await execAsync(`${process.execPath} ${CLI_PATH} --help`);
+        expect(stdout).toContain("For usage information refer to the README.md");
+        expect(stderr).toEqual("");
+    });
+
+    it("should handle dry run request", async () => {
+        const { stdout, stderr } = await execAsync(`${process.execPath} ${CLI_PATH} --dryRun`);
+        expect(stdout).toContain("Configuration:");
+        expect(stdout).toContain("Enabled tools:");
+        expect(stderr).toEqual("");
+    });
+});

tests/unit/common/config.test.ts

@@ -59,7 +59,7 @@ const expectedDefaults = {
     vectorSearchSimilarityFunction: "euclidean",
     disableEmbeddingsValidation: false,
     previewFeatures: [],
-    dry: false,
+    dryRun: false,
 };
 
 describe("config", () => {

tests/unit/transports/dryModeRunner.test.ts

@@ -1,16 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { DryModeRunner, type DryModeTestHelpers } from "../../../src/transports/dryModeRunner.js";
+import { DryRunModeRunner, type DryRunModeTestHelpers } from "../../../src/transports/dryModeRunner.js";
 import { type UserConfig } from "../../../src/common/config/userConfig.js";
 import { type TransportRunnerConfig } from "../../../src/transports/base.js";
 import { defaultTestConfig } from "../../integration/helpers.js";
 
-describe("DryModeRunner", () => {
-    let exitMock: DryModeTestHelpers["exit"];
-    let loggerMock: DryModeTestHelpers["logger"];
+describe.only("DryModeRunner", () => {
+    let loggerMock: DryRunModeTestHelpers["logger"];
     let runnerConfig: TransportRunnerConfig;
 
     beforeEach(() => {
-        exitMock = vi.fn<DryModeTestHelpers["exit"]>();
         loggerMock = {
             log: vi.fn(),
             error: vi.fn(),
@@ -24,25 +22,21 @@ describe("DryModeRunner", () => {
         vi.clearAllMocks();
     });
 
-    it("should not do anything if dry mode is disabled", async () => {
-        await DryModeRunner.assertDryMode(runnerConfig, exitMock, loggerMock);
-        expect(exitMock).not.toHaveBeenCalled();
-        expect(loggerMock.log).not.toHaveBeenCalled();
-    });
-
     it.each([{ transport: "http", httpHost: "127.0.0.1", httpPort: "3001" }, { transport: "stdio" }] as Array<
         Partial<UserConfig>
-    >)("should run in dry mode if enabled for transport - $transport", async (partialConfig) => {
+    >)("should handle dry run request for transport - $transport", async (partialConfig) => {
         runnerConfig.userConfig = {
             ...runnerConfig.userConfig,
             ...partialConfig,
-            dry: true,
+            dryRun: true,
         };
-        await DryModeRunner.assertDryMode(runnerConfig, exitMock, loggerMock);
-        expect(exitMock).toHaveBeenCalledWith(0);
+        const runner = new DryRunModeRunner({ logger: loggerMock, ...runnerConfig });
+        await runner.start();
         expect(loggerMock.log).toHaveBeenNthCalledWith(1, "Configuration:");
         expect(loggerMock.log).toHaveBeenNthCalledWith(2, JSON.stringify(runnerConfig.userConfig, null, 2));
         expect(loggerMock.log).toHaveBeenNthCalledWith(3, "Enabled tools:");
         expect(loggerMock.log).toHaveBeenNthCalledWith(4, expect.stringContaining('"name": "connect"'));
+        // Because switch-connection is not enabled by default
+        expect(loggerMock.log).toHaveBeenNthCalledWith(4, expect.not.stringContaining('"name": "switch-connection"'));
     });
 });