jest-test-lineage-reporter 2.1.3 → 2.2.0

package/README.md

@@ -90,16 +90,24 @@ 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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-test-lineage-reporter",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "main": "src/TestCoverageReporter.js",
   "bin": {
     "jest-lineage": "./bin/jest-lineage.js"

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/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;
   }