fchek 1.0.0

package/lib/test.js

@@ -0,0 +1,471 @@
+'use strict';
+
+/**
+ * test.js — auto-detect test framework and run tests
+ *
+ * Detects: pytest, jest, vitest, cargo test, go test, dotnet test,
+ *          mocha, jasmine, rspec, phpunit
+ *
+ * Returns structured JSON: passed, failed, errors, duration.
+ * Agent uses this to verify nothing is broken after every change.
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const { output, ok, fail } = require('./output');
+const { findPython } = require('./python');
+
+const HELP = `
+fchek test [dir] [--watch] [--coverage] [--filter=<name>]
+
+Auto-detect test framework and run tests. Returns structured results.
+
+Supported frameworks (auto-detected):
+  Python   → pytest (preferred) or unittest
+  JS/TS    → jest, vitest, mocha (reads package.json test script)
+  Rust     → cargo test
+  Go       → go test ./...
+  C#/.NET  → dotnet test
+  C/C++    → CMake + CTest / GoogleTest / Catch2
+
+Options:
+  --coverage       Run with coverage enabled
+  --filter=<name>  Run only tests matching name
+  --timeout=60000  Max time in ms (default: 120000)
+
+Examples:
+  fchek test
+  fchek test src/
+  fchek test --filter=auth
+  fchek test --coverage
+`.trim();
+
+const DEFAULT_TIMEOUT = 120_000;
+
+function commandExists(cmd) {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+      { stdio: 'ignore', timeout: 3000 }
+    );
+    return true;
+  } catch { return false; }
+}
+
+// ─── Framework detection ─────────────────────────────────────────────────────
+
+function detectFramework(dir) {
+  const abs = path.resolve(dir);
+
+  // .fchekrc override
+  try {
+    const rc = JSON.parse(fs.readFileSync(path.join(abs, '.fchekrc'), 'utf8'));
+    if (rc.test_command) return { type: 'custom', command: rc.test_command, dir: abs };
+  } catch {}
+
+  // C# / .NET
+  if (fs.readdirSync(abs).some(f => f.endsWith('.csproj') || f.endsWith('.sln'))) {
+    return { type: 'dotnet', dir: abs };
+  }
+
+  // Rust
+  if (fs.existsSync(path.join(abs, 'Cargo.toml'))) {
+    return { type: 'cargo', dir: abs };
+  }
+
+  // Go
+  if (fs.existsSync(path.join(abs, 'go.mod'))) {
+    return { type: 'go', dir: abs };
+  }
+
+  // C/C++ — CMakeLists.txt (CTest/GoogleTest/Catch2)
+  const hasCMake = fs.existsSync(path.join(abs, 'CMakeLists.txt'));
+  const hasMakefile = fs.existsSync(path.join(abs, 'Makefile')) || fs.existsSync(path.join(abs, 'makefile'));
+  const hasCFiles = (() => {
+    try { return fs.readdirSync(abs).some(f => f.endsWith('.cpp') || f.endsWith('.c')); } catch { return false; }
+  })();
+  if (hasCMake || (hasMakefile && hasCFiles)) {
+    return { type: 'ctest', dir: abs, hasCMake, hasMakefile };
+  }
+  const pkgPath = path.join(abs, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const testScript = pkg.scripts?.test || '';
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.vitest || testScript.includes('vitest')) return { type: 'vitest', dir: abs };
+      if (deps.jest || testScript.includes('jest'))     return { type: 'jest',   dir: abs };
+      if (deps.mocha || testScript.includes('mocha'))   return { type: 'mocha',  dir: abs };
+      if (testScript) return { type: 'npm_test', dir: abs };
+    } catch {}
+  }
+
+  // Python
+  const pyMarkers = ['pytest.ini', 'pyproject.toml', 'setup.cfg', 'conftest.py'];
+  if (pyMarkers.some(m => fs.existsSync(path.join(abs, m)))) {
+    return { type: 'pytest', dir: abs };
+  }
+  // Fallback: check for test files
+  const hasTestPy = (() => {
+    try {
+      return fs.readdirSync(abs).some(f => f.startsWith('test_') && f.endsWith('.py'));
+    } catch { return false; }
+  })();
+  if (hasTestPy) return { type: 'pytest', dir: abs };
+
+  // Walk up
+  const parent = path.dirname(abs);
+  if (parent !== abs) return detectFramework(parent);
+
+  return null;
+}
+
+// ─── Result parsers ───────────────────────────────────────────────────────────
+
+function parsePytest(stdout, stderr, status) {
+  // pytest writes summary to stderr on some versions, stdout on others
+  const combined = (stdout || '') + (stderr || '');
+
+  const passedM  = combined.match(/(\d+) passed/);
+  const failedM  = combined.match(/(\d+) failed/);
+  const errorsM  = combined.match(/(\d+) error/);
+  const skippedM = combined.match(/(\d+) skipped/);
+
+  const passed  = passedM  ? parseInt(passedM[1])  : 0;
+  const failed  = failedM  ? parseInt(failedM[1])  : 0;
+  const errors  = errorsM  ? parseInt(errorsM[1])  : 0;
+  const skipped = skippedM ? parseInt(skippedM[1]) : 0;
+
+  // If exit_code 0 and no numbers found — pytest ran but output format unexpected
+  // Try alternate: count "PASSED" / "FAILED" lines
+  const passedAlt = (combined.match(/\bPASSED\b/g) || []).length;
+  const failedAlt = (combined.match(/\bFAILED\b/g) || []).length;
+
+  const finalPassed = passed > 0 ? passed : passedAlt;
+  const finalFailed = failed > 0 ? failed : failedAlt;
+
+  const failures = [];
+  for (const m of combined.matchAll(/FAILED (.+?) - (.+)/g)) {
+    failures.push({ test: m[1].trim(), reason: m[2].trim() });
+  }
+  // Also catch short failure format
+  for (const m of combined.matchAll(/FAILED (.+)\n/g)) {
+    if (!failures.find(f => f.test === m[1].trim())) {
+      failures.push({ test: m[1].trim(), reason: '' });
+    }
+  }
+
+  return {
+    passed:   finalPassed,
+    failed:   finalFailed,
+    errors,
+    skipped,
+    failures: failures.slice(0, 20),
+  };
+}
+
+function parseJest(stdout, stderr, status) {
+  const combined = stdout + stderr;
+  const suitesPassed = parseInt((combined.match(/(\d+) passed/)  || [0, 0])[1]);
+  const suitesFailed = parseInt((combined.match(/(\d+) failed/)  || [0, 0])[1]);
+  const tests        = parseInt((combined.match(/Tests:\s+.*?(\d+) total/) || [0, 0])[1]);
+
+  const failures = [];
+  for (const m of combined.matchAll(/● (.+)\n\n([\s\S]+?)(?=●|\n\n\n)/g)) {
+    failures.push({ test: m[1].trim(), reason: m[2].trim().slice(0, 200) });
+  }
+
+  return { passed: suitesPassed, failed: suitesFailed, total_tests: tests, failures: failures.slice(0, 20) };
+}
+
+function parseCargo(stdout, stderr, status) {
+  const combined = stdout + stderr;
+  const passed = parseInt((combined.match(/(\d+) passed/) || [0, 0])[1]);
+  const failed = parseInt((combined.match(/(\d+) failed/) || [0, 0])[1]);
+
+  const failures = [];
+  for (const m of combined.matchAll(/---- (.+) stdout ----\n([\s\S]+?)(?=----|\z)/g)) {
+    failures.push({ test: m[1].trim(), output: m[2].trim().slice(0, 200) });
+  }
+
+  return { passed, failed, failures: failures.slice(0, 20) };
+}
+
+function parseGo(stdout, stderr, status) {
+  const combined = stdout + stderr;
+  const passed = (combined.match(/--- PASS/g) || []).length;
+  const failed = (combined.match(/--- FAIL/g) || []).length;
+
+  const failures = [];
+  for (const m of combined.matchAll(/--- FAIL: (\S+)/g)) {
+    failures.push({ test: m[1] });
+  }
+
+  return { passed, failed, failures };
+}
+
+function parseCtest(stdout, stderr, status) {
+  const combined = stdout + stderr;
+
+  // CTest format: "X/Y Test #N: name ... Passed/Failed  Xs"
+  const passed = (combined.match(/\bPassed\b/g) || []).length;
+  const failed = (combined.match(/\bFailed\b/g) || []).length;
+
+  // GoogleTest format: "[  PASSED  ] N tests." / "[  FAILED  ] N tests"
+  const gtPassM = combined.match(/\[\s+PASSED\s+\]\s+(\d+) test/);
+  const gtFailM = combined.match(/\[\s+FAILED\s+\]\s+(\d+) test/);
+  const gtPassed = gtPassM ? parseInt(gtPassM[1]) : null;
+  const gtFailed = gtFailM ? parseInt(gtFailM[1]) : null;
+
+  // Catch2 format: "N test cases, N assertions, N failures"
+  const c2M = combined.match(/(\d+) test cases?,\s*(\d+) assertions?,\s*(\d+) failures?/);
+  const c2Passed = c2M ? parseInt(c2M[1]) - parseInt(c2M[3]) : null;
+  const c2Failed = c2M ? parseInt(c2M[3]) : null;
+
+  const finalPassed = gtPassed ?? c2Passed ?? passed;
+  const finalFailed = gtFailed ?? c2Failed ?? failed;
+
+  // Collect failed test names from GTest
+  const failures = [];
+  for (const m of combined.matchAll(/\[\s+FAILED\s+\]\s+(.+)/g)) {
+    failures.push({ test: m[1].trim() });
+  }
+  // CTest failures
+  for (const m of combined.matchAll(/Test\s+#\d+:\s+(\S+)\s+.*?Failed/g)) {
+    if (!failures.find(f => f.test === m[1])) {
+      failures.push({ test: m[1].trim() });
+    }
+  }
+
+  return {
+    passed:   finalPassed,
+    failed:   finalFailed,
+    failures: failures.slice(0, 20),
+    framework_hint: gtPassed !== null ? 'googletest' : c2Passed !== null ? 'catch2' : 'ctest',
+  };
+}
+
+function parseDotnet(stdout, stderr, status) {
+  const combined = stdout + stderr;
+  const passed  = parseInt((combined.match(/(\d+) test(?:s)? passed/)  || [0, 0])[1]);
+  const failed  = parseInt((combined.match(/(\d+) test(?:s)? failed/)  || [0, 0])[1]);
+  const skipped = parseInt((combined.match(/(\d+) test(?:s)? skipped/) || [0, 0])[1]);
+
+  const failures = [];
+  for (const m of combined.matchAll(/X (.+) \[/g)) {
+    failures.push({ test: m[1].trim() });
+  }
+
+  return { passed, failed, skipped, failures: failures.slice(0, 20) };
+}
+
+// ─── Runners ──────────────────────────────────────────────────────────────────
+
+function runFramework(framework, opts, timeoutMs) {
+  const { type, dir, command } = framework;
+  const { coverage, filter } = opts;
+
+  let cmd, args, env = { ...process.env };
+
+  switch (type) {
+    case 'custom': {
+      const parts = command.split(/\s+/);
+      cmd = parts[0]; args = parts.slice(1);
+      break;
+    }
+    case 'pytest': {
+      const py = findPython();
+      if (!py) return { error: 'Python not found' };
+      // Check if pytest is available
+      const checkPytest = spawnSync(py, ['-m', 'pytest', '--version'], {
+        encoding: 'utf8', timeout: 5000, windowsHide: true,
+      });
+      if (checkPytest.status !== 0) {
+        return { error: 'pytest not found. Install: pip install pytest' };
+      }
+      cmd  = py;
+      args = ['-m', 'pytest', '--tb=short', '-q'];
+      if (coverage) args.push('--cov=.', '--cov-report=term-missing');
+      if (filter)   args.push('-k', filter);
+      break;
+    }
+    case 'jest': {
+      cmd  = commandExists('jest') ? 'jest' : (commandExists('npx') ? 'npx' : null);
+      args = cmd === 'npx' ? ['jest'] : [];
+      args.push('--json', '--no-coverage');
+      if (coverage) args.push('--coverage');
+      if (filter)   args.push('--testNamePattern', filter);
+      break;
+    }
+    case 'vitest': {
+      cmd  = 'npx';
+      args = ['vitest', 'run', '--reporter=json'];
+      if (filter) args.push('--testNamePattern', filter);
+      break;
+    }
+    case 'mocha': {
+      cmd  = commandExists('mocha') ? 'mocha' : 'npx';
+      args = cmd === 'npx' ? ['mocha'] : [];
+      if (filter) args.push('--grep', filter);
+      break;
+    }
+    case 'npm_test': {
+      cmd = 'npm'; args = ['test'];
+      break;
+    }
+    case 'cargo': {
+      cmd = 'cargo'; args = ['test'];
+      if (filter) args.push(filter);
+      break;
+    }
+    case 'go': {
+      cmd = 'go'; args = ['test', './...', '-v'];
+      if (filter) args.push('-run', filter);
+      if (coverage) args.push('-cover');
+      break;
+    }
+    case 'dotnet': {
+      cmd = 'dotnet'; args = ['test', '--logger', 'console;verbosity=normal'];
+      if (filter) args.push('--filter', filter);
+      if (coverage) args.push('--collect', 'XPlat Code Coverage');
+      break;
+    }
+    case 'ctest': {
+      // Step 1: Build with CMake or Make
+      if (framework.hasCMake) {
+        // cmake -B build && cmake --build build
+        const cmakeConf = spawnSync(
+          'cmake', ['-B', 'build', '-DCMAKE_BUILD_TYPE=Debug'],
+          { encoding: 'utf8', cwd: framework.dir, timeout: 60000, windowsHide: true }
+        );
+        if (cmakeConf.status !== 0) {
+          return { error: `CMake configure failed:\n${(cmakeConf.stderr || cmakeConf.stdout || '').slice(0, 500)}` };
+        }
+        const cmakeBuild = spawnSync(
+          'cmake', ['--build', 'build'],
+          { encoding: 'utf8', cwd: framework.dir, timeout: timeoutMs, windowsHide: true }
+        );
+        if (cmakeBuild.status !== 0) {
+          return { error: `CMake build failed:\n${(cmakeBuild.stderr || cmakeBuild.stdout || '').slice(0, 500)}` };
+        }
+        // Run with ctest
+        const ctestArgs = ['--output-on-failure', '-V'];
+        if (filter) ctestArgs.push('-R', filter);
+        cmd = 'ctest'; args = ctestArgs;
+      } else if (framework.hasMakefile) {
+        // make test or make check
+        const makeTest = spawnSync(
+          'make', ['test'],
+          { encoding: 'utf8', cwd: framework.dir, timeout: timeoutMs, windowsHide: true }
+        );
+        if (makeTest.status !== 0) {
+          // Fallback: try "make check"
+          const makeCheck = spawnSync(
+            'make', ['check'],
+            { encoding: 'utf8', cwd: framework.dir, timeout: timeoutMs, windowsHide: true }
+          );
+          return {
+            exit_code: makeCheck.status,
+            all_passed: makeCheck.status === 0,
+            duration_ms: 0,
+            stdout: (makeCheck.stdout || '').slice(0, 5000),
+            stderr: (makeCheck.stderr || '').slice(0, 2000),
+            ...parseCtest(makeCheck.stdout || '', makeCheck.stderr || '', makeCheck.status),
+          };
+        }
+        return {
+          exit_code: makeTest.status,
+          all_passed: makeTest.status === 0,
+          duration_ms: 0,
+          stdout: (makeTest.stdout || '').slice(0, 5000),
+          stderr: (makeTest.stderr || '').slice(0, 2000),
+          ...parseCtest(makeTest.stdout || '', makeTest.stderr || '', makeTest.status),
+        };
+      }
+      break;
+    }
+    default:
+      return { error: `Unknown framework: ${type}` };
+  }
+
+  if (!cmd) return { error: `Test runner not found for ${type}` };
+
+  const t0  = Date.now();
+  const res = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    cwd:      dir,
+    timeout:  timeoutMs,
+    env,
+    windowsHide: true,
+  });
+  const duration = Date.now() - t0;
+
+  if (res.error?.code === 'ETIMEDOUT') {
+    return { error: `Tests timed out after ${timeoutMs}ms` };
+  }
+
+  const stdout = res.stdout || '';
+  const stderr = res.stderr || '';
+
+  let parsed;
+  switch (type) {
+    case 'pytest':   parsed = parsePytest(stdout, stderr, res.status); break;
+    case 'jest':     parsed = parseJest(stdout, stderr, res.status);   break;
+    case 'vitest':   parsed = parseJest(stdout, stderr, res.status);   break;
+    case 'cargo':    parsed = parseCargo(stdout, stderr, res.status);  break;
+    case 'go':       parsed = parseGo(stdout, stderr, res.status);     break;
+    case 'dotnet':   parsed = parseDotnet(stdout, stderr, res.status); break;
+    case 'ctest':    parsed = parseCtest(stdout, stderr, res.status);  break;
+    default:         parsed = { raw: true };
+  }
+
+  return {
+    ...parsed,
+    exit_code:   res.status,
+    all_passed:  res.status === 0,
+    duration_ms: duration,
+    stdout:      stdout.slice(0, 5000),
+    stderr:      stderr.slice(0, 2000),
+  };
+}
+
+async function run(args) {
+  if (args[0] === '--help') { console.log(HELP); return; }
+
+  const dir      = args.find(a => !a.startsWith('--')) || '.';
+  const coverage = args.includes('--coverage');
+  const filter   = (args.find(a => a.startsWith('--filter=')) || '').replace('--filter=', '') || null;
+  const timeout  = parseInt(
+    (args.find(a => a.startsWith('--timeout=')) || `--timeout=${DEFAULT_TIMEOUT}`)
+      .replace('--timeout=', ''), 10
+  );
+
+  if (!fs.existsSync(dir)) {
+    return output(fail(`Directory not found: ${dir}`));
+  }
+
+  const framework = detectFramework(path.resolve(dir));
+  if (!framework) {
+    return output(fail(
+      `No test framework detected in: ${path.resolve(dir)}\n` +
+      `Supported: pytest, jest, vitest, mocha, cargo test, go test, dotnet test\n` +
+      `Or set "test_command" in .fchekrc`
+    ));
+  }
+
+  const result = runFramework(framework, { coverage, filter }, timeout);
+
+  if (result.error) {
+    return output(fail(result.error));
+  }
+
+  output(ok({
+    dir:       path.resolve(dir),
+    framework: framework.type,
+    ...result,
+    verdict: result.all_passed ? 'all_passed' : 'failures_found',
+  }));
+}
+
+module.exports = { run, detectFramework };