SP-1383: add module-handler discovery + builder tests to cover new-code lines

Sonar counts pre-existing module-handler code (discoverAndRegisterModules, argument) as new code for this PR due to the project's New Code Definition. Cover it with tests to clear the coverage gate. No source changes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: admirjashari

tests/core/command/module-discovery.spec.ts

@@ -0,0 +1,155 @@
+import * as fs from "fs";
+import { tmpdir } from "os";
+import { join, dirname } from "path";
+import { Command } from "commander";
+import { ModuleHandler } from "../../../src/core/command/module-handler";
+import { testContext } from "../../utls/test-context";
+import { loggingTestTransport } from "../../jest.setup";
+
+const createdRoots: string[] = [];
+
+function createCommandsTree(files: Record<string, string>): string {
+    const root = fs.mkdtempSync(join(tmpdir(), "mh-discovery-"));
+    createdRoots.push(root);
+    fs.mkdirSync(join(root, "commands"));
+    for (const [relPath, content] of Object.entries(files)) {
+        const full = join(root, "commands", relPath);
+        fs.mkdirSync(dirname(full), { recursive: true });
+        fs.writeFileSync(full, content);
+    }
+    return root;
+}
+
+function newHandler(): ModuleHandler {
+    return new ModuleHandler(new Command(), testContext);
+}
+
+function messages(): string[] {
+    return loggingTestTransport.logMessages.map(entry => String(entry.message));
+}
+
+describe("ModuleHandler.discoverAndRegisterModules", () => {
+    let exitSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        loggingTestTransport.logMessages = [];
+        // The logger's transport calls process.exit on error-level logs; stub it so
+        // the error branches can be exercised without killing the test runner.
+        exitSpy = jest.spyOn(process, "exit").mockImplementation((() => undefined) as never);
+    });
+
+    afterEach(() => {
+        exitSpy.mockRestore();
+    });
+
+    afterAll(() => {
+        for (const root of createdRoots) {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+
+    it("registers a module that exports a class with a register method", () => {
+        const root = createCommandsTree({ "valid/module.js": "module.exports = class { register() {} };" });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(1);
+    });
+
+    it("skips a folder that has no module entry point", () => {
+        const root = createCommandsTree({ "empty/readme.txt": "no module here" });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+    });
+
+    it("warns when the module export is not a class", () => {
+        const root = createCommandsTree({ "notclass/module.js": "module.exports = { notAClass: true };" });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("is not a class/constructor function"))).toBe(true);
+    });
+
+    it("warns when the module class has no register method", () => {
+        const root = createCommandsTree({ "noregister/module.js": "module.exports = class {};" });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("does not have a 'register' method"))).toBe(true);
+    });
+
+    it("warns when a module cannot be required due to a missing dependency", () => {
+        const root = createCommandsTree({
+            "badrequire/module.js": "require('a-package-that-does-not-exist-xyz');",
+        });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("Could not require module"))).toBe(true);
+    });
+
+    it("warns when requiring a module fails with an ENOENT error", () => {
+        const root = createCommandsTree({
+            "enoent/module.js": "require('fs').readFileSync('/no/such/path/xyz-content-cli-test');",
+        });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("does not contain a compiled module.js file"))).toBe(true);
+    });
+
+    it("logs an error when the commands path is not a directory", () => {
+        const root = fs.mkdtempSync(join(tmpdir(), "mh-notdir-"));
+        createdRoots.push(root);
+        fs.writeFileSync(join(root, "commands"), "this is a file, not a directory");
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("Failed to read modules directory"))).toBe(true);
+    });
+
+    it("logs an error when requiring a module throws unexpectedly", () => {
+        const root = createCommandsTree({ "throws/module.js": "throw new Error('boom');" });
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("Error processing module in"))).toBe(true);
+    });
+
+    it("logs an error when the commands directory does not exist", () => {
+        const root = fs.mkdtempSync(join(tmpdir(), "mh-nocommands-"));
+        createdRoots.push(root);
+        const handler = newHandler();
+
+        handler.discoverAndRegisterModules(root, false);
+
+        expect(handler.registeredModules).toHaveLength(0);
+        expect(messages().some(m => m.includes("Modules directory not found"))).toBe(true);
+    });
+
+    it("looks for module.ts (not module.js) in dev mode", () => {
+        const root = createCommandsTree({ "devonly/module.js": "module.exports = class { register() {} };" });
+        const handler = newHandler();
+
+        // dev mode looks for module.ts, which is absent here, so the folder is skipped
+        handler.discoverAndRegisterModules(root, true);
+
+        expect(handler.registeredModules).toHaveLength(0);
+    });
+});

tests/core/command/module-handler.spec.ts

@@ -150,3 +150,11 @@ describe("CommandConfig early access gating", () => {
         expect(handler).toHaveBeenCalled();
     });
 });
+
+describe("CommandConfig builder methods", () => {
+    it("supports the argument() builder", () => {
+        const configurator = new Configurator(new Command(), testContext);
+
+        expect(() => configurator.command("with-arg").argument("<value>", "an argument")).not.toThrow();
+    });
+});