@rog0x/mcp-testing-tools 1.0.0

package/dist/tools/test-coverage-analyzer.js

@@ -0,0 +1,247 @@
+/**
+ * Parse test files and source files to identify untested functions
+ * and suggest which functions need tests most, based on complexity
+ * and public API surface.
+ */
+function extractFunctions(sourceCode) {
+    const functions = [];
+    const lines = sourceCode.split("\n");
+    // Patterns for function declarations
+    const patterns = [
+        // export function name(...)
+        /^(\s*)(export\s+)?(async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
+        // export const name = (...) =>
+        /^(\s*)(export\s+)?(const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*(:\s*\S+)?\s*=>/,
+        // export const name = function(...)
+        /^(\s*)(export\s+)?(const|let|var)\s+(\w+)\s*=\s*(async\s+)?function\s*\(([^)]*)\)/,
+        // class method: name(...) or async name(...)
+        /^(\s+)(public\s+|private\s+|protected\s+)?(static\s+)?(async\s+)?(\w+)\s*\(([^)]*)\)\s*(:\s*\S+)?\s*\{/,
+    ];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Standard function declaration
+        const funcMatch = line.match(patterns[0]);
+        if (funcMatch) {
+            const name = funcMatch[4];
+            const isExported = !!funcMatch[2];
+            const isAsync = !!funcMatch[3];
+            const params = funcMatch[5].trim();
+            const paramCount = params ? params.split(",").length : 0;
+            const complexity = estimateComplexity(sourceCode, i, lines);
+            functions.push({
+                name,
+                line: i + 1,
+                isExported,
+                isAsync,
+                paramCount,
+                estimatedComplexity: complexity,
+                hasBranching: complexity > 1,
+            });
+            continue;
+        }
+        // Arrow function
+        const arrowMatch = line.match(patterns[1]);
+        if (arrowMatch) {
+            const name = arrowMatch[4];
+            const isExported = !!arrowMatch[2];
+            const isAsync = !!arrowMatch[5];
+            const params = arrowMatch[6].trim();
+            const paramCount = params ? params.split(",").length : 0;
+            const complexity = estimateComplexity(sourceCode, i, lines);
+            functions.push({
+                name,
+                line: i + 1,
+                isExported,
+                isAsync,
+                paramCount,
+                estimatedComplexity: complexity,
+                hasBranching: complexity > 1,
+            });
+            continue;
+        }
+        // Function expression
+        const exprMatch = line.match(patterns[2]);
+        if (exprMatch) {
+            const name = exprMatch[4];
+            const isExported = !!exprMatch[2];
+            const isAsync = !!exprMatch[5];
+            const params = exprMatch[6].trim();
+            const paramCount = params ? params.split(",").length : 0;
+            const complexity = estimateComplexity(sourceCode, i, lines);
+            functions.push({
+                name,
+                line: i + 1,
+                isExported,
+                isAsync,
+                paramCount,
+                estimatedComplexity: complexity,
+                hasBranching: complexity > 1,
+            });
+            continue;
+        }
+        // Class method
+        const methodMatch = line.match(patterns[3]);
+        if (methodMatch) {
+            const name = methodMatch[5];
+            if (name === "constructor" || name === "if" || name === "for" || name === "while" || name === "switch")
+                continue;
+            const visibility = (methodMatch[2] || "").trim();
+            const isExported = visibility !== "private";
+            const isAsync = !!methodMatch[4];
+            const params = methodMatch[6].trim();
+            const paramCount = params ? params.split(",").length : 0;
+            const complexity = estimateComplexity(sourceCode, i, lines);
+            functions.push({
+                name,
+                line: i + 1,
+                isExported,
+                isAsync,
+                paramCount,
+                estimatedComplexity: complexity,
+                hasBranching: complexity > 1,
+            });
+        }
+    }
+    return functions;
+}
+function estimateComplexity(source, startLine, lines) {
+    // Count branching keywords in the function body (approximate)
+    let complexity = 1; // base complexity
+    let braceDepth = 0;
+    let started = false;
+    for (let i = startLine; i < Math.min(startLine + 200, lines.length); i++) {
+        const line = lines[i];
+        for (const ch of line) {
+            if (ch === "{") {
+                braceDepth++;
+                started = true;
+            }
+            if (ch === "}")
+                braceDepth--;
+        }
+        if (started && braceDepth === 0)
+            break;
+        // Count branching constructs
+        if (/\bif\s*\(/.test(line))
+            complexity++;
+        if (/\belse\s+if\s*\(/.test(line))
+            complexity++;
+        if (/\belse\s*\{/.test(line))
+            complexity++;
+        if (/\bfor\s*\(/.test(line))
+            complexity++;
+        if (/\bwhile\s*\(/.test(line))
+            complexity++;
+        if (/\bswitch\s*\(/.test(line))
+            complexity++;
+        if (/\bcase\s+/.test(line))
+            complexity++;
+        if (/\bcatch\s*\(/.test(line))
+            complexity++;
+        if (/\?\?/.test(line))
+            complexity++;
+        if (/\?\./.test(line))
+            complexity++;
+        if (/\b\?\s/.test(line) && /:/.test(line))
+            complexity++; // ternary
+    }
+    return complexity;
+}
+function extractTestedNames(testCode) {
+    const tested = new Set();
+    // Match patterns like: describe("functionName" / it("should ... functionName"
+    const describeMatches = testCode.matchAll(/describe\s*\(\s*["'`]([^"'`]+)["'`]/g);
+    for (const m of describeMatches) {
+        const name = m[1].trim();
+        // If it looks like a function name (single word, camelCase, etc.)
+        if (/^\w+$/.test(name)) {
+            tested.add(name);
+        }
+    }
+    // Match direct function calls in test blocks
+    const callMatches = testCode.matchAll(/(?:expect|assert)\s*\(\s*(?:await\s+)?(\w+)\s*\(/g);
+    for (const m of callMatches) {
+        tested.add(m[1]);
+    }
+    // Match imports
+    const importMatches = testCode.matchAll(/import\s*\{([^}]+)\}/g);
+    for (const m of importMatches) {
+        const names = m[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+        for (const name of names) {
+            if (name)
+                tested.add(name);
+        }
+    }
+    // Match require destructuring
+    const requireMatches = testCode.matchAll(/const\s*\{([^}]+)\}\s*=\s*require/g);
+    for (const m of requireMatches) {
+        const names = m[1].split(",").map((n) => n.trim().split(/\s*:\s*/)[0].trim());
+        for (const name of names) {
+            if (name)
+                tested.add(name);
+        }
+    }
+    return Array.from(tested);
+}
+function prioritize(fn) {
+    const reasons = [];
+    let score = 0;
+    if (fn.isExported) {
+        score += 3;
+        reasons.push("exported/public API");
+    }
+    if (fn.estimatedComplexity > 5) {
+        score += 3;
+        reasons.push(`high complexity (${fn.estimatedComplexity})`);
+    }
+    else if (fn.estimatedComplexity > 2) {
+        score += 2;
+        reasons.push(`moderate complexity (${fn.estimatedComplexity})`);
+    }
+    if (fn.paramCount >= 3) {
+        score += 1;
+        reasons.push(`${fn.paramCount} parameters`);
+    }
+    if (fn.hasBranching) {
+        score += 1;
+        reasons.push("contains branching logic");
+    }
+    if (fn.isAsync) {
+        score += 1;
+        reasons.push("async (potential error paths)");
+    }
+    const priority = score >= 5 ? "high" : score >= 3 ? "medium" : "low";
+    return { priority, reason: reasons.join("; ") };
+}
+export function analyzeCoverage(sourceCode, testCode, sourceFileName = "source.ts") {
+    const functions = extractFunctions(sourceCode);
+    const testedNames = extractTestedNames(testCode);
+    const testedFunctions = [];
+    const untestedFunctions = [];
+    for (const fn of functions) {
+        if (testedNames.includes(fn.name)) {
+            testedFunctions.push(fn.name);
+        }
+        else {
+            untestedFunctions.push(fn);
+        }
+    }
+    const suggestions = untestedFunctions
+        .map((fn) => {
+        const { priority, reason } = prioritize(fn);
+        return { functionName: fn.name, priority, reason };
+    })
+        .sort((a, b) => {
+        const order = { high: 0, medium: 1, low: 2 };
+        return order[a.priority] - order[b.priority];
+    });
+    return {
+        sourceFile: sourceFileName,
+        totalFunctions: functions.length,
+        exportedFunctions: functions.filter((f) => f.isExported).length,
+        testedFunctions,
+        untestedFunctions,
+        suggestions,
+    };
+}
+//# sourceMappingURL=test-coverage-analyzer.js.map

package/dist/tools/test-generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate test cases from a function signature.
+ * Produces happy path, edge cases, error cases, and boundary value tests
+ * as Jest/Vitest-compatible test code.
+ */
+export declare function generateTests(signature: string, framework?: string, modulePath?: string): string;
+//# sourceMappingURL=test-generator.d.ts.map

package/dist/tools/test-generator.js

@@ -0,0 +1,278 @@
+/**
+ * Generate test cases from a function signature.
+ * Produces happy path, edge cases, error cases, and boundary value tests
+ * as Jest/Vitest-compatible test code.
+ */
+function parseSignature(signature) {
+    const asyncMatch = signature.trim().startsWith("async");
+    const cleaned = signature.replace(/^(export\s+)?(async\s+)?function\s+/, "").trim();
+    const nameMatch = cleaned.match(/^(\w+)/);
+    const name = nameMatch ? nameMatch[1] : "unknownFunction";
+    const paramsMatch = cleaned.match(/\(([^)]*)\)/);
+    const paramsStr = paramsMatch ? paramsMatch[1].trim() : "";
+    const returnMatch = cleaned.match(/\):\s*(.+?)(\s*\{|$)/);
+    const returnType = returnMatch ? returnMatch[1].trim() : "void";
+    const params = [];
+    if (paramsStr) {
+        const paramParts = splitParams(paramsStr);
+        for (const part of paramParts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            const optional = trimmed.includes("?:");
+            const defaultMatch = trimmed.match(/=\s*(.+)$/);
+            const cleanPart = trimmed.replace(/\s*=\s*.+$/, "").trim();
+            const colonIdx = cleanPart.indexOf(":");
+            let paramName;
+            let paramType;
+            if (colonIdx !== -1) {
+                paramName = cleanPart.slice(0, colonIdx).replace("?", "").trim();
+                paramType = cleanPart.slice(colonIdx + 1).trim();
+            }
+            else {
+                paramName = cleanPart.replace("?", "").trim();
+                paramType = "unknown";
+            }
+            params.push({
+                name: paramName,
+                type: paramType,
+                optional: optional || !!defaultMatch,
+                defaultValue: defaultMatch ? defaultMatch[1].trim() : undefined,
+            });
+        }
+    }
+    return { name, params, returnType, isAsync: asyncMatch };
+}
+function splitParams(str) {
+    const results = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of str) {
+        if (ch === "<" || ch === "(" || ch === "[" || ch === "{")
+            depth++;
+        if (ch === ">" || ch === ")" || ch === "]" || ch === "}")
+            depth--;
+        if (ch === "," && depth === 0) {
+            results.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        results.push(current);
+    return results;
+}
+function sampleValueForType(type, variant) {
+    const t = type.toLowerCase().replace(/\s/g, "");
+    if (t === "string" || t.includes("string")) {
+        switch (variant) {
+            case "happy": return '"hello world"';
+            case "edge": return '""';
+            case "boundary": return '"a".repeat(10000)';
+        }
+    }
+    if (t === "number" || t.includes("number")) {
+        switch (variant) {
+            case "happy": return "42";
+            case "edge": return "0";
+            case "boundary": return "Number.MAX_SAFE_INTEGER";
+        }
+    }
+    if (t === "boolean" || t.includes("boolean")) {
+        return variant === "happy" ? "true" : "false";
+    }
+    if (t.endsWith("[]") || t.startsWith("array")) {
+        switch (variant) {
+            case "happy": return "[1, 2, 3]";
+            case "edge": return "[]";
+            case "boundary": return "Array.from({ length: 10000 }, (_, i) => i)";
+        }
+    }
+    if (t === "object" || t.startsWith("{")) {
+        switch (variant) {
+            case "happy": return '{ key: "value" }';
+            case "edge": return "{}";
+            case "boundary": return "Object.create(null)";
+        }
+    }
+    if (t === "date") {
+        switch (variant) {
+            case "happy": return 'new Date("2025-06-15")';
+            case "edge": return "new Date(0)";
+            case "boundary": return 'new Date("9999-12-31")';
+        }
+    }
+    if (t.includes("|")) {
+        const parts = t.split("|").map((p) => p.trim());
+        return sampleValueForType(parts[0], variant);
+    }
+    if (t === "null")
+        return "null";
+    if (t === "undefined")
+        return "undefined";
+    return variant === "happy" ? "{}" : "undefined";
+}
+function buildArgs(params, variant, omitOptional) {
+    const args = [];
+    for (const p of params) {
+        if (omitOptional && p.optional)
+            continue;
+        args.push(sampleValueForType(p.type, variant));
+    }
+    return args.join(", ");
+}
+function generateReturnAssertion(returnType, callExpr, isAsync) {
+    const awaited = isAsync ? `await ${callExpr}` : callExpr;
+    const t = returnType.toLowerCase().replace(/\s/g, "");
+    if (t === "void" || t === "promise<void>") {
+        return `    expect(${awaited}).toBeUndefined();`;
+    }
+    if (t === "boolean" || t === "promise<boolean>") {
+        return `    expect(typeof (${awaited})).toBe("boolean");`;
+    }
+    if (t === "string" || t === "promise<string>") {
+        return `    expect(typeof (${awaited})).toBe("string");`;
+    }
+    if (t === "number" || t === "promise<number>") {
+        return `    expect(typeof (${awaited})).toBe("number");`;
+    }
+    if (t.endsWith("[]") || t.startsWith("array") || t.includes("promise<") && t.includes("[]")) {
+        return `    const result = ${awaited};\n    expect(Array.isArray(result)).toBe(true);`;
+    }
+    return `    const result = ${awaited};\n    expect(result).toBeDefined();`;
+}
+export function generateTests(signature, framework = "vitest", modulePath = "./module") {
+    const parsed = parseSignature(signature);
+    const fn = parsed.isAsync ? "async " : "";
+    const importStatement = framework === "jest"
+        ? `const { ${parsed.name} } = require("${modulePath}");`
+        : `import { ${parsed.name} } from "${modulePath}";`;
+    const lines = [];
+    lines.push(importStatement);
+    lines.push("");
+    lines.push(`describe("${parsed.name}", () => {`);
+    // Happy path
+    lines.push(`  describe("happy path", () => {`);
+    const happyArgs = buildArgs(parsed.params, "happy", false);
+    lines.push(`    it("should return expected result with valid inputs", ${fn}() => {`);
+    lines.push(generateReturnAssertion(parsed.returnType, `${parsed.name}(${happyArgs})`, parsed.isAsync));
+    lines.push("    });");
+    if (parsed.params.some((p) => p.optional)) {
+        const minArgs = buildArgs(parsed.params, "happy", true);
+        lines.push("");
+        lines.push(`    it("should work with only required parameters", ${fn}() => {`);
+        lines.push(generateReturnAssertion(parsed.returnType, `${parsed.name}(${minArgs})`, parsed.isAsync));
+        lines.push("    });");
+    }
+    lines.push("  });");
+    // Edge cases
+    lines.push("");
+    lines.push(`  describe("edge cases", () => {`);
+    const edgeArgs = buildArgs(parsed.params, "edge", false);
+    lines.push(`    it("should handle edge-case inputs gracefully", ${fn}() => {`);
+    if (parsed.isAsync) {
+        lines.push(`      await expect(${parsed.name}(${edgeArgs})).resolves.toBeDefined();`);
+    }
+    else {
+        lines.push(`      expect(() => ${parsed.name}(${edgeArgs})).not.toThrow();`);
+    }
+    lines.push("    });");
+    // null/undefined for each param
+    for (const param of parsed.params) {
+        if (!param.optional) {
+            lines.push("");
+            lines.push(`    it("should handle null ${param.name}", ${fn}() => {`);
+            const nullArgs = parsed.params.map((p) => (p.name === param.name ? "null as any" : sampleValueForType(p.type, "happy"))).join(", ");
+            if (parsed.isAsync) {
+                lines.push(`      await expect(${parsed.name}(${nullArgs})).rejects.toThrow();`);
+            }
+            else {
+                lines.push(`      expect(() => ${parsed.name}(${nullArgs})).toThrow();`);
+            }
+            lines.push("    });");
+        }
+    }
+    lines.push("  });");
+    // Error cases
+    lines.push("");
+    lines.push(`  describe("error cases", () => {`);
+    if (parsed.params.length > 0) {
+        lines.push(`    it("should throw when called with no arguments", ${fn}() => {`);
+        if (parsed.isAsync) {
+            lines.push(`      // @ts-expect-error testing missing arguments`);
+            lines.push(`      await expect(${parsed.name}()).rejects.toThrow();`);
+        }
+        else {
+            lines.push(`      // @ts-expect-error testing missing arguments`);
+            lines.push(`      expect(() => ${parsed.name}()).toThrow();`);
+        }
+        lines.push("    });");
+        lines.push("");
+        lines.push(`    it("should throw with wrong argument types", ${fn}() => {`);
+        const wrongArgs = parsed.params.map(() => "Symbol() as any").join(", ");
+        if (parsed.isAsync) {
+            lines.push(`      await expect(${parsed.name}(${wrongArgs})).rejects.toThrow();`);
+        }
+        else {
+            lines.push(`      expect(() => ${parsed.name}(${wrongArgs})).toThrow();`);
+        }
+        lines.push("    });");
+    }
+    else {
+        lines.push(`    // No parameters — limited error scenarios`);
+        lines.push(`    it("should not throw when called", ${fn}() => {`);
+        if (parsed.isAsync) {
+            lines.push(`      await expect(${parsed.name}()).resolves.toBeDefined();`);
+        }
+        else {
+            lines.push(`      expect(() => ${parsed.name}()).not.toThrow();`);
+        }
+        lines.push("    });");
+    }
+    lines.push("  });");
+    // Boundary values
+    lines.push("");
+    lines.push(`  describe("boundary values", () => {`);
+    const boundaryArgs = buildArgs(parsed.params, "boundary", false);
+    lines.push(`    it("should handle extreme values", ${fn}() => {`);
+    if (parsed.isAsync) {
+        lines.push(`      await expect(${parsed.name}(${boundaryArgs})).resolves.toBeDefined();`);
+    }
+    else {
+        lines.push(`      expect(() => ${parsed.name}(${boundaryArgs})).not.toThrow();`);
+    }
+    lines.push("    });");
+    // Negative numbers for number params
+    const numericParams = parsed.params.filter((p) => p.type.toLowerCase().includes("number"));
+    for (const param of numericParams) {
+        lines.push("");
+        lines.push(`    it("should handle negative value for ${param.name}", ${fn}() => {`);
+        const negArgs = parsed.params.map((p) => (p.name === param.name ? "-1" : sampleValueForType(p.type, "happy"))).join(", ");
+        lines.push(`      const call = () => ${parsed.name}(${negArgs});`);
+        if (parsed.isAsync) {
+            lines.push(`      // Depending on implementation, may resolve or reject`);
+            lines.push(`      await expect(call()).resolves.toBeDefined();`);
+        }
+        else {
+            lines.push(`      // Depending on implementation, may return or throw`);
+            lines.push(`      expect(call).not.toThrow();`);
+        }
+        lines.push("    });");
+        lines.push("");
+        lines.push(`    it("should handle NaN for ${param.name}", ${fn}() => {`);
+        const nanArgs = parsed.params.map((p) => (p.name === param.name ? "NaN" : sampleValueForType(p.type, "happy"))).join(", ");
+        if (parsed.isAsync) {
+            lines.push(`      await expect(${parsed.name}(${nanArgs})).rejects.toThrow();`);
+        }
+        else {
+            lines.push(`      expect(() => ${parsed.name}(${nanArgs})).toThrow();`);
+        }
+        lines.push("    });");
+    }
+    lines.push("  });");
+    lines.push("});");
+    return lines.join("\n");
+}
+//# sourceMappingURL=test-generator.js.map

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@rog0x/mcp-testing-tools",
+  "version": "1.0.0",
+  "description": "Testing and quality assurance tools for AI agents via MCP",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "testing",
+    "quality-assurance",
+    "mock-data",
+    "test-generation"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/node": "^22.15.2"
+  }
+}