jest-test-lineage-reporter 2.1.2 → 2.2.0

package/README.md

@@ -90,27 +90,39 @@ jest-lineage test --no-performance --no-quality
 Run mutation testing standalone (on existing lineage data).
 
 ```bash
-# Basic mutation testing
+# Basic mutation testing (serial)
 jest-lineage mutate
 
 # With custom threshold
 jest-lineage mutate --threshold 90
 
+# Parallel execution with 4 workers (faster!)
+jest-lineage mutate --workers 4
+
+# Auto-detect CPU cores and use optimal worker count
+jest-lineage mutate --workers 0
+
 # Debug mode (create mutation files without running tests)
 jest-lineage mutate --debug --debug-dir ./mutations
 ```
 
+**Performance Tip**: Use `--workers` to run mutations in parallel. Each worker processes a different file concurrently, significantly reducing execution time for projects with multiple files.
+
+**Note**: Mutation results are saved to `.jest-lineage-mutation-results.json`. Run `jest-lineage report` after mutation testing to generate an HTML report with mutation data included.
+
 #### `jest-lineage report`
-Generate HTML report from existing lineage data.
+Generate HTML report from existing lineage data and mutation results.
 
 ```bash
-# Generate and open report
+# Generate and open report (includes mutation results if available)
 jest-lineage report --open
 
 # Custom output path
 jest-lineage report --output coverage-report.html
 ```
 
+**Tip**: The report command automatically loads mutation results from `.jest-lineage-mutation-results.json` if available.
+
 #### `jest-lineage query <file> [line]`
 Query which tests cover specific files or lines.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-test-lineage-reporter",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "main": "src/TestCoverageReporter.js",
   "bin": {
     "jest-lineage": "./bin/jest-lineage.js"
@@ -57,6 +57,7 @@
     "LICENSE"
   ],
   "dependencies": {
+    "@babel/runtime": "^7.28.4",
     "@modelcontextprotocol/sdk": "^0.5.0",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.3",

package/src/MutationTester.js

@@ -219,42 +219,99 @@ class MutationTester {
       fileResults: {},
     };
 
-    let currentFileIndex = 0;
-    let currentMutationIndex = 0;
+    // Determine worker count
+    const workers = this.config.workers || 1;
+    const shouldParallelize = workers > 1 || workers === 0;
+
+    if (shouldParallelize) {
+      // Parallel execution - process multiple files concurrently
+      const os = require('os');
+      const actualWorkers = workers === 0 ? Math.max(1, os.cpus().length - 1) : workers;
+      console.log(`\n⚡ Running mutations in parallel with ${actualWorkers} workers\n`);
+
+      const fileEntries = Object.entries(this.lineageData);
+      const filePromises = fileEntries.map(async ([filePath, lines], index) => {
+        console.log(
+          `\n🔬 [Worker ${(index % actualWorkers) + 1}] Testing mutations in ${filePath} (${index + 1}/${totalFiles})...`
+        );
 
-    for (const [filePath, lines] of Object.entries(this.lineageData)) {
-      currentFileIndex++;
-      console.log(
-        `\n🔬 Testing mutations in ${filePath} (${currentFileIndex}/${totalFiles})...`
-      );
+        const fileResults = await this.testFileLines(
+          filePath,
+          lines,
+          0, // Start from 0 for each file in parallel mode
+          totalMutationsCount
+        );
 
-      const fileResults = await this.testFileLines(
-        filePath,
-        lines,
-        currentMutationIndex,
-        totalMutationsCount
-      );
-      results.fileResults[filePath] = fileResults;
-
-      results.totalMutations += fileResults.totalMutations;
-      results.killedMutations += fileResults.killedMutations;
-      results.survivedMutations += fileResults.survivedMutations;
-      results.timeoutMutations += fileResults.timeoutMutations;
-      results.errorMutations += fileResults.errorMutations;
-
-      currentMutationIndex += fileResults.totalMutations;
-
-      // Log file completion summary
-      const fileName = filePath.split("/").pop();
-      const fileScore =
-        fileResults.totalMutations > 0
-          ? Math.round(
-              (fileResults.killedMutations / fileResults.totalMutations) * 100
-            )
-          : 0;
-      console.log(
-        `✅ ${fileName}: ${fileResults.totalMutations} mutations, ${fileResults.killedMutations} killed, ${fileResults.survivedMutations} survived (${fileScore}% score)`
-      );
+        // Log file completion summary
+        const fileName = filePath.split("/").pop();
+        const fileScore =
+          fileResults.totalMutations > 0
+            ? Math.round(
+                (fileResults.killedMutations / fileResults.totalMutations) * 100
+              )
+            : 0;
+        console.log(
+          `✅ [Worker ${(index % actualWorkers) + 1}] ${fileName}: ${fileResults.totalMutations} mutations, ${fileResults.killedMutations} killed, ${fileResults.survivedMutations} survived (${fileScore}% score)`
+        );
+
+        return { filePath, fileResults };
+      });
+
+      // Process files with concurrency limit
+      const chunkSize = actualWorkers;
+      for (let i = 0; i < filePromises.length; i += chunkSize) {
+        const chunk = filePromises.slice(i, i + chunkSize);
+        const chunkResults = await Promise.all(chunk);
+
+        // Aggregate results
+        for (const { filePath, fileResults } of chunkResults) {
+          results.fileResults[filePath] = fileResults;
+          results.totalMutations += fileResults.totalMutations;
+          results.killedMutations += fileResults.killedMutations;
+          results.survivedMutations += fileResults.survivedMutations;
+          results.timeoutMutations += fileResults.timeoutMutations;
+          results.errorMutations += fileResults.errorMutations;
+        }
+      }
+    } else {
+      // Serial execution - process one file at a time
+      let currentFileIndex = 0;
+      let currentMutationIndex = 0;
+
+      for (const [filePath, lines] of Object.entries(this.lineageData)) {
+        currentFileIndex++;
+        console.log(
+          `\n🔬 Testing mutations in ${filePath} (${currentFileIndex}/${totalFiles})...`
+        );
+
+        const fileResults = await this.testFileLines(
+          filePath,
+          lines,
+          currentMutationIndex,
+          totalMutationsCount
+        );
+        results.fileResults[filePath] = fileResults;
+
+        results.totalMutations += fileResults.totalMutations;
+        results.killedMutations += fileResults.killedMutations;
+        results.survivedMutations += fileResults.survivedMutations;
+        results.timeoutMutations += fileResults.timeoutMutations;
+        results.errorMutations += fileResults.errorMutations;
+
+        currentMutationIndex += fileResults.totalMutations;
+
+        // Log file completion summary
+        const fileName = filePath.split("/").pop();
+        const fileScore =
+          fileResults.totalMutations > 0
+            ? Math.round(
+                (fileResults.killedMutations / fileResults.totalMutations) * 100
+              )
+            : 0;
+        console.log(
+          `✅ ${fileName}: ${fileResults.totalMutations} mutations, ${fileResults.killedMutations} killed, ${fileResults.survivedMutations} survived (${fileScore}% score)`
+        );
+      }
     }
 
     // Calculate mutation score

package/src/TestCoverageReporter.js

@@ -3104,7 +3104,7 @@ class TestCoverageReporter {
                 // Group mutations by line
                 const mutationsByLine = {};
                 fileData.mutations.forEach(mutation => {
-                    const line = mutation.line || 'unknown';
+                    const line = mutation.lineNumber || mutation.line || 'unknown';
                     if (!mutationsByLine[line]) {
                         mutationsByLine[line] = [];
                     }

package/src/cli/commands/mutate.js

@@ -55,6 +55,13 @@ async function mutateCommand(options) {
       spin.succeed('Mutation testing completed!');
     }
 
+    // Save results to file for HTML report
+    const fs = require('fs');
+    const path = require('path');
+    const resultsPath = path.join(process.cwd(), '.jest-lineage-mutation-results.json');
+    fs.writeFileSync(resultsPath, JSON.stringify(results, null, 2));
+    info(`Mutation results saved to: ${chalk.yellow(resultsPath)}`);
+
     // Print results
     printMutationSummary(results);
 

package/src/cli/commands/report.js

@@ -26,6 +26,19 @@ async function reportCommand(options) {
     // Process lineage data
     const lineageData = processLineageDataForMutation(rawData);
 
+    // Load mutation results if available
+    const fs = require('fs');
+    const mutationResultsPath = path.join(process.cwd(), '.jest-lineage-mutation-results.json');
+    let mutationResults = null;
+    if (fs.existsSync(mutationResultsPath)) {
+      try {
+        mutationResults = JSON.parse(fs.readFileSync(mutationResultsPath, 'utf8'));
+        info(`Loaded mutation results: ${chalk.cyan(mutationResults.totalMutations)} mutations tested`);
+      } catch (e) {
+        // Ignore errors loading mutation results
+      }
+    }
+
     // Create reporter instance with minimal config
     const reporter = new TestCoverageReporter(
       { rootDir: process.cwd() },
@@ -35,6 +48,11 @@ async function reportCommand(options) {
     // Load data into reporter
     reporter.processLineageResults(lineageData, 'unknown');
 
+    // Set mutation results if available
+    if (mutationResults) {
+      reporter.mutationResults = mutationResults;
+    }
+
     // Generate HTML report
     const spin = spinner('Generating HTML report...');
     spin.start();

package/src/cli/index.js

@@ -47,6 +47,7 @@ async function run(argv) {
     .option('--data <path>', 'Path to lineage data file', '.jest-lineage-data.json')
     .option('--threshold <number>', 'Mutation score threshold (%)', '80')
     .option('--timeout <ms>', 'Timeout per mutation (ms)', '5000')
+    .option('--workers <number>', 'Number of parallel workers (1=serial, 0=auto)', '1')
     .option('--debug', 'Create debug mutation files instead of running tests')
     .option('--debug-dir <path>', 'Directory for debug files', './mutations-debug')
     .option('--operators <list>', 'Comma-separated mutation operators to enable')

package/src/cli/utils/config-loader.js

@@ -50,6 +50,9 @@ function mapCliOptionsToConfig(cliOptions) {
   if (cliOptions.timeout !== undefined) {
     config.mutationTimeout = parseInt(cliOptions.timeout);
   }
+  if (cliOptions.workers !== undefined) {
+    config.workers = parseInt(cliOptions.workers);
+  }
   if (cliOptions.debug === true) {
     config.debugMutations = true;
   }

package/src/cli/utils/jest-runner.js

@@ -39,6 +39,12 @@ async function runJest(options = {}) {
     jestArgs.push('--coverage');
   }
 
+  // Run tests serially when lineage tracking is enabled to avoid race conditions
+  // with file writes from parallel workers
+  if (enableLineage && !jestArgs.includes('--runInBand') && !jestArgs.includes('--maxWorkers')) {
+    jestArgs.push('--runInBand');
+  }
+
   // Set environment variables for lineage tracking
   const env = {
     ...process.env,

package/src/testSetup.js

@@ -278,7 +278,31 @@ function createTestWrapper(originalFn, testType) {
         if (process.env.JEST_LINEAGE_MUTATION !== 'true') {
           // Also store in a more persistent way for the reporter
           if (!global.__LINEAGE_PERSISTENT_DATA__) {
-            global.__LINEAGE_PERSISTENT_DATA__ = [];
+            // Initialize array - load existing tests from file if merging is enabled
+            // This ensures data persists across test files running in separate workers
+            const shouldMerge = process.env.JEST_LINEAGE_MERGE !== 'false';
+            if (shouldMerge) {
+              const fs = require('fs');
+              const path = require('path');
+              const filePath = path.join(process.cwd(), '.jest-lineage-data.json');
+
+              if (fs.existsSync(filePath)) {
+                try {
+                  const existingData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                  // Convert coverage objects back to Maps
+                  global.__LINEAGE_PERSISTENT_DATA__ = existingData.tests.map(test => ({
+                    ...test,
+                    coverage: new Map(Object.entries(test.coverage || {}))
+                  }));
+                } catch (e) {
+                  global.__LINEAGE_PERSISTENT_DATA__ = [];
+                }
+              } else {
+                global.__LINEAGE_PERSISTENT_DATA__ = [];
+              }
+            } else {
+              global.__LINEAGE_PERSISTENT_DATA__ = [];
+            }
           }
           global.__LINEAGE_PERSISTENT_DATA__.push(testData);
 
@@ -645,8 +669,9 @@ function writeTrackingDataToFile() {
   try {
     const filePath = path.join(process.cwd(), '.jest-lineage-data.json');
 
-    // Check if we should merge with existing data (default: false - recreate from scratch)
-    const shouldMerge = process.env.JEST_LINEAGE_MERGE === 'true';
+    // Check if we should merge with existing data (default: true for multiple test files)
+    // Set JEST_LINEAGE_MERGE=false to disable merging and recreate from scratch
+    const shouldMerge = process.env.JEST_LINEAGE_MERGE !== 'false';
 
     let existingData = { timestamp: Date.now(), tests: [] };
     if (shouldMerge && fs.existsSync(filePath)) {
@@ -717,8 +742,6 @@ function writeTrackingDataToFile() {
     }
 
     fs.writeFileSync(filePath, JSON.stringify(dataToWrite, null, 2));
-
-    // console.log(`📝 Wrote tracking data: ${dataToWrite.tests.length} total tests to ${filePath}`);
   } catch (error) {
     console.warn('Warning: Could not write tracking data to file:', error.message);
   }