@rog0x/mcp-testing-tools 1.0.0

package/src/tools/test-coverage-analyzer.ts

@@ -0,0 +1,283 @@
+/**
+ * Parse test files and source files to identify untested functions
+ * and suggest which functions need tests most, based on complexity
+ * and public API surface.
+ */
+
+interface FunctionInfo {
+  name: string;
+  line: number;
+  isExported: boolean;
+  isAsync: boolean;
+  paramCount: number;
+  estimatedComplexity: number;
+  hasBranching: boolean;
+}
+
+interface CoverageResult {
+  sourceFile: string;
+  totalFunctions: number;
+  exportedFunctions: number;
+  testedFunctions: string[];
+  untestedFunctions: FunctionInfo[];
+  suggestions: Suggestion[];
+}
+
+interface Suggestion {
+  functionName: string;
+  priority: "high" | "medium" | "low";
+  reason: string;
+}
+
+function extractFunctions(sourceCode: string): FunctionInfo[] {
+  const functions: FunctionInfo[] = [];
+  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: string, startLine: number, lines: string[]): number {
+  // 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: string): string[] {
+  const tested = new Set<string>();
+
+  // 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: FunctionInfo): { priority: "high" | "medium" | "low"; reason: string } {
+  const reasons: string[] = [];
+  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: string,
+  testCode: string,
+  sourceFileName: string = "source.ts"
+): CoverageResult {
+  const functions = extractFunctions(sourceCode);
+  const testedNames = extractTestedNames(testCode);
+
+  const testedFunctions: string[] = [];
+  const untestedFunctions: FunctionInfo[] = [];
+
+  for (const fn of functions) {
+    if (testedNames.includes(fn.name)) {
+      testedFunctions.push(fn.name);
+    } else {
+      untestedFunctions.push(fn);
+    }
+  }
+
+  const suggestions: Suggestion[] = 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,
+  };
+}

package/src/tools/test-generator.ts

@@ -0,0 +1,300 @@
+/**
+ * Generate test cases from a function signature.
+ * Produces happy path, edge cases, error cases, and boundary value tests
+ * as Jest/Vitest-compatible test code.
+ */
+
+interface FunctionParam {
+  name: string;
+  type: string;
+  optional?: boolean;
+  defaultValue?: string;
+}
+
+interface ParsedSignature {
+  name: string;
+  params: FunctionParam[];
+  returnType: string;
+  isAsync: boolean;
+}
+
+function parseSignature(signature: string): ParsedSignature {
+  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: FunctionParam[] = [];
+  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: string;
+      let paramType: string;
+      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: string): string[] {
+  const results: string[] = [];
+  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: string, variant: "happy" | "edge" | "boundary"): string {
+  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: FunctionParam[], variant: "happy" | "edge" | "boundary", omitOptional: boolean): string {
+  const args: string[] = [];
+  for (const p of params) {
+    if (omitOptional && p.optional) continue;
+    args.push(sampleValueForType(p.type, variant));
+  }
+  return args.join(", ");
+}
+
+function generateReturnAssertion(returnType: string, callExpr: string, isAsync: boolean): string {
+  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: string,
+  framework: string = "vitest",
+  modulePath: string = "./module"
+): string {
+  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: string[] = [];
+  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");
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}