@zohodesk/codestandard-validator 1.2.4-exp-5 → 1.2.4-exp-7

package/build/mutation/mutationRunner.js

@@ -1,208 +1,235 @@
 "use strict";
 
-const path = require('path');
-const StrykerWrapper = require('./strykerWrapper');
-const BranchDiff = require('./branchDiff');
-const FileResolver = require('./fileResolver');
-const ReportGenerator = require('./reportGenerator');
-class MutationRunner {
-  constructor(options = {}) {
-    this._cwd = options.cwd || process.cwd();
-    this._stryker = new StrykerWrapper({
-      reportPath: options.reportPath,
-      concurrency: options.concurrency,
-      timeoutMS: options.timeoutMS,
-      logLevel: options.logLevel
-    });
-    this._branchDiff = new BranchDiff({
-      cwd: this._cwd,
-      api: options.api || null,
-      patToken: options.patToken || null
-    });
-    this._fileResolver = new FileResolver({
-      cwd: this._cwd
-    });
-    this._reportGenerator = new ReportGenerator({
-      cwd: this._cwd,
-      outputDir: options.outputDir || 'reports/mutation',
-      outputFileName: options.outputFileName || 'mutation-report.json'
-    });
-    this._jestConfig = options.jestConfig || {};
-  }
-  async runByBranch(branch, options = {}) {
-    if (!branch) {
-      throw new Error('Branch name is required. Usage: npx ZDLintFramework mutate --branch=<branch>');
+var StrykerWrapper = require('./strykerWrapper');
+var StrykerConfigBuilder = require('./strykerConfigBuilder');
+var BranchDiff = require('./branchDiff');
+var FileResolver = require('./fileResolver');
+var ReportGenerator = require('./reportGenerator');
+var path = require('path');
+/**
+ * MutationRunner — orchestrates mutation testing.
+ *
+ * Exposes exactly two public methods:
+ *
+ *   runLocal(releaseBranch)
+ *     Pre-commit / local dev.  Collects staged files AND changed files
+ *     vs the release branch, deduplicates, resolves source↔test pairs,
+ *     runs Stryker on those specific files, and writes JSON reports
+ *     (mutation summary + SonarQube-compatible external issues report).
+ *
+ *   runCI(releaseBranch)
+ *     CI pipeline.  Collects changed files vs the release branch,
+ *     resolves source↔test pairs, runs Stryker, and writes JSON reports.
+ *     The caller decides pass/fail based on the report.
+ *
+ * Compatible with Node 16+ and @stryker-mutator/core v5.
+ *
+ * @param {object} options
+ * @param {StrykerConfigBuilder} [options.configBuilder] - pre-configured builder
+ */
+function MutationRunner(options) {
+  options = options || {};
+  this._cwd = options.cwd || process.cwd();
+  var configBuilder = options.configBuilder;
+  if (!configBuilder) {
+    configBuilder = new StrykerConfigBuilder();
+    if (options.strykerConfigpath) {
+      configBuilder.fromConfigFile(options.strykerConfigpath);
     }
-
-    // Step 1: Get changed files
-    const {
-      sourceFiles,
-      testFiles
-    } = await this._branchDiff.getChangedFiles(branch, {
-      useApi: options.useApi || false,
-      hostname: options.hostname || null,
-      projectId: options.projectId || null
-    });
-    if (sourceFiles.length === 0 && testFiles.length === 0) {
-      const emptyResult = this._buildEmptyResult();
-      const {
-        report,
-        filePath
-      } = this._reportGenerator.generateAndWrite(emptyResult, {
-        command: `mutate --branch=${branch}`,
-        branch,
-        filePairs: []
+    if (options.concurrency != null) configBuilder.setConcurrency(options.concurrency);
+    if (options.timeoutMS != null) configBuilder.setTimeoutMS(options.timeoutMS);
+    if (options.logLevel) configBuilder.setLogLevel(options.logLevel);
+    if (options.reportPath) {
+      configBuilder.setHtmlReporter({
+        fileName: options.reportPath
+      }).setJsonReporter({
+        fileName: options.reportPath
       });
-      return {
-        report,
-        filePath,
-        message: 'No changed source or test files found in branch diff.'
-      };
     }
+  }
+  this._stryker = new StrykerWrapper(configBuilder);
+  this._branchDiff = new BranchDiff({
+    cwd: this._cwd,
+    token: options.token,
+    gitEndPoint: options.gitEndPoint,
+    branchDiffPath: options.branchDiffPath,
+    compareBranch: options.compareBranch,
+    projectId: options.projectId
+  });
+  this._fileResolver = new FileResolver({
+    cwd: this._cwd
+  });
+  this._reportGenerator = new ReportGenerator({
+    cwd: this._cwd,
+    outputDir: options.outputDir || 'reports/mutation',
+    outputFileName: options.outputFileName || 'mutation-report.json'
+  });
+  this._jestConfig = options.jestConfig || {};
+}
 
-    // Step 2: Resolve source-test pairs
-    const pairs = this._fileResolver.resolveSourceTestPairs(sourceFiles, testFiles);
-    const validPairs = pairs.filter(p => p.source && p.test);
-    const sourcesToMutate = [...new Set(validPairs.map(p => p.source))];
-    const testsToRun = [...new Set(validPairs.map(p => p.test))];
-    if (sourcesToMutate.length === 0) {
-      const emptyResult = this._buildEmptyResult();
-      const {
-        report,
-        filePath
-      } = this._reportGenerator.generateAndWrite(emptyResult, {
-        command: `mutate --branch=${branch}`,
-        branch,
-        filePairs: pairs
-      });
-      return {
-        report,
-        filePath,
-        message: 'No source files with corresponding test files found.'
-      };
-    }
+/* ------------------------------------------------------------------ */
+/*  1. LOCAL  (pre-commit / staged)                                     */
+/* ------------------------------------------------------------------ */
 
-    // Step 3: Run Stryker mutation testing
-    const mutationResult = await this._stryker.run(sourcesToMutate, {
-      testFiles: testsToRun,
-      jest: {
-        ...this._jestConfig,
-        enableFindRelatedTests: true
-      }
+/**
+ * Run mutation testing on locally-changed files.
+ *
+ * Combines:
+ *   • staged files   (git diff --staged)
+ *   • changed files  (git diff vs releaseBranch, filter ACMR)
+ *
+ * @param {string} releaseBranch - branch to diff against (e.g. 'release')
+ * @returns {Promise<{ report: object, sonarReport: object, filePath: string, sonarFilePath: string, message?: string }>}
+ */
+MutationRunner.prototype.runLocal = function (releaseBranch) {
+  if (!releaseBranch) {
+    throw new Error('releaseBranch is required. Usage: mutate --mode=local --release=<branch>');
+  }
+  var self = this;
+  return self._branchDiff.getLocalChanges(releaseBranch).then(function (categorized) {
+    return self._runMutation(categorized.sourceFiles, categorized.testFiles, {
+      mode: 'local',
+      releaseBranch: releaseBranch,
+      command: 'mutate --mode=local --release=' + releaseBranch
     });
+  });
+};
 
-    // Step 4: Generate report
-    const {
-      report,
-      filePath
-    } = this._reportGenerator.generateAndWrite(mutationResult, {
-      command: `mutate --branch=${branch}`,
-      branch,
-      filePairs: pairs
-    });
-    return {
-      report,
-      filePath
-    };
-  }
-  async runByDirectory(srcDir, testDir, options = {}) {
-    if (!srcDir || !testDir) {
-      throw new Error('Both source and test directories are required. Usage: npx ZDLintFramework mutate --src=<sourcedir> --test=<testdir>');
-    }
+/* ------------------------------------------------------------------ */
+/*  2. CI                                                               */
+/* ------------------------------------------------------------------ */
 
-    // Step 1: Collect all source and test files
-    const sourceFiles = this._fileResolver.collectSourceFiles(srcDir);
-    const testFiles = this._fileResolver.collectTestFiles(testDir);
-    if (sourceFiles.length === 0) {
-      const emptyResult = this._buildEmptyResult();
-      const {
-        report,
-        filePath
-      } = this._reportGenerator.generateAndWrite(emptyResult, {
-        command: `mutate --src=${srcDir} --test=${testDir}`,
-        srcDir,
-        testDir,
-        filePairs: []
-      });
-      return {
-        report,
-        filePath,
-        message: 'No source files found in the specified directory.'
-      };
-    }
+/**
+ * Run mutation testing on files changed vs the release branch (CI).
+ *
+ * @param {string} releaseBranch - branch to diff against
+ * @returns {Promise<{ report: object, sonarReport: object, filePath: string, sonarFilePath: string, message?: string }>}
+ */
+MutationRunner.prototype.runCI = function (releaseBranch) {
+  if (!releaseBranch) {
+    throw new Error('releaseBranch is required. Usage: mutate --mode=ci --release=<branch>');
+  }
+  var self = this;
+  return self._branchDiff.getCIChanges(releaseBranch).then(function (categorized) {
+    return self._runMutation(categorized.sourceFiles, categorized.testFiles, {
+      mode: 'ci',
+      releaseBranch: releaseBranch,
+      command: 'mutate --mode=ci --release=' + releaseBranch
+    });
+  });
+};
 
-    // Step 2: Resolve source-test pairs
-    const pairs = this._fileResolver.resolveSourceTestPairs(sourceFiles, testFiles);
-    const validPairs = pairs.filter(p => p.source && p.test);
-    const sourcesToMutate = [...new Set(validPairs.map(p => p.source))];
-    const testsToRun = [...new Set(validPairs.map(p => p.test))];
-    if (sourcesToMutate.length === 0) {
-      // Fallback: mutate all source files with all test files
-      const mutationResult = await this._stryker.run(sourceFiles, {
-        testFiles,
-        jest: {
-          ...this._jestConfig,
-          enableFindRelatedTests: true
-        }
-      });
-      const {
-        report,
-        filePath
-      } = this._reportGenerator.generateAndWrite(mutationResult, {
-        command: `mutate --src=${srcDir} --test=${testDir}`,
-        srcDir,
-        testDir,
-        filePairs: sourceFiles.map(s => ({
-          source: s,
-          test: null
-        }))
-      });
-      return {
-        report,
-        filePath
-      };
-    }
+/* ------------------------------------------------------------------ */
+/*  Shared pipeline                                                     */
+/* ------------------------------------------------------------------ */
 
-    // Step 3: Run Stryker mutation testing
-    const mutationResult = await this._stryker.run(sourcesToMutate, {
-      testFiles: testsToRun,
-      jest: {
-        ...this._jestConfig,
-        enableFindRelatedTests: true
-      }
+/**
+ * Internal — common mutation pipeline for both modes.
+ *
+ * @param {string[]} sourceFiles
+ * @param {string[]} testFiles
+ * @param {{ mode: string, releaseBranch: string, command: string }} ctx
+ * @returns {Promise<{ report: object, sonarReport: object, filePath: string, sonarFilePath: string, message?: string }>}
+ */
+MutationRunner.prototype._runMutation = function (sourceFiles, testFiles, ctx) {
+  var self = this;
+  if (sourceFiles.length === 0 && testFiles.length === 0) {
+    var emptyResult = self._buildEmptyResult();
+    var out = self._reportGenerator.generateAndWrite(emptyResult, {
+      command: ctx.command,
+      mode: ctx.mode,
+      releaseBranch: ctx.releaseBranch,
+      filePairs: []
     });
-
-    // Step 4: Generate report
-    const {
-      report,
-      filePath
-    } = this._reportGenerator.generateAndWrite(mutationResult, {
-      command: `mutate --src=${srcDir} --test=${testDir}`,
-      srcDir,
-      testDir,
+    return Promise.resolve({
+      report: out.report,
+      sonarReport: out.sonarReport,
+      filePath: out.filePath,
+      sonarFilePath: out.sonarFilePath,
+      message: 'No changed source or test files found.'
+    });
+  }
+  var pairs = self._fileResolver.resolveSourceTestPairs(sourceFiles, testFiles);
+  var validPairs = pairs.filter(function (p) {
+    return p.source && p.test;
+  });
+  var sourcesToMutate = [];
+  var testsToRun = [];
+  var seenSrc = {};
+  var seenTest = {};
+  var i;
+  for (i = 0; i < validPairs.length; i++) {
+    if (!seenSrc[validPairs[i].source]) {
+      seenSrc[validPairs[i].source] = true;
+      sourcesToMutate.push(validPairs[i].source);
+    }
+    if (!seenTest[validPairs[i].test]) {
+      seenTest[validPairs[i].test] = true;
+      testsToRun.push(path.join(this._branchDiff.getRootDirectory(), validPairs[i].test));
+    }
+  }
+  if (sourcesToMutate.length === 0) {
+    var emptyResult2 = self._buildEmptyResult();
+    var out2 = self._reportGenerator.generateAndWrite(emptyResult2, {
+      command: ctx.command,
+      mode: ctx.mode,
+      releaseBranch: ctx.releaseBranch,
       filePairs: pairs
     });
-    return {
-      report,
-      filePath
-    };
+    return Promise.resolve({
+      report: out2.report,
+      sonarReport: out2.sonarReport,
+      filePath: out2.filePath,
+      sonarFilePath: out2.sonarFilePath,
+      message: 'No source files with corresponding test files found.'
+    });
   }
-  _buildEmptyResult() {
+  var strykerOpts = {
+    rootDirectory: this._branchDiff.getRootDirectory(),
+    testFiles: testsToRun,
+    jest: Object.assign({}, self._jestConfig, {
+      config: {
+        testMatch: testsToRun,
+        reporters: ['json']
+      },
+      enableFindRelatedTests: true
+    })
+  };
+  return self._stryker.run(sourcesToMutate, strykerOpts).then(function (mutationResult) {
+    var out3 = self._reportGenerator.generateAndWrite(mutationResult, {
+      command: ctx.command,
+      mode: ctx.mode,
+      releaseBranch: ctx.releaseBranch,
+      filePairs: pairs
+    });
     return {
-      files: {},
-      mutants: [],
-      summary: {
-        totalMutants: 0,
-        killed: 0,
-        survived: 0,
-        timeout: 0,
-        noCoverage: 0,
-        ignored: 0,
-        runtimeErrors: 0,
-        compileErrors: 0,
-        mutationScore: 0
-      }
+      report: out3.report,
+      sonarReport: out3.sonarReport,
+      filePath: out3.filePath,
+      sonarFilePath: out3.sonarFilePath
     };
-  }
-}
+  });
+};
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+MutationRunner.prototype._buildEmptyResult = function () {
+  return {
+    files: {},
+    mutants: [],
+    summary: {
+      totalMutants: 0,
+      killed: 0,
+      survived: 0,
+      timeout: 0,
+      noCoverage: 0,
+      ignored: 0,
+      runtimeErrors: 0,
+      compileErrors: 0,
+      mutationScore: 0
+    }
+  };
+};
 module.exports = MutationRunner;