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

package/build/mutation/reportGenerator.js

@@ -2,27 +2,54 @@
 
 const fs = require('fs');
 const path = require('path');
-class ReportGenerator {
-  constructor(options = {}) {
-    this._outputDir = options.outputDir || 'reports/mutation';
-    this._outputFileName = options.outputFileName || 'mutation-report.json';
-    this._cwd = options.cwd || process.cwd();
-  }
-  generate(mutationResult, context = {}) {
-    const report = {
-      schemaVersion: '1.0',
-      timestamp: new Date().toISOString(),
-      projectRoot: this._cwd,
-      command: context.command || 'unknown',
-      configuration: {
-        branch: context.branch || null,
-        srcDir: context.srcDir || null,
-        testDir: context.testDir || null
-      },
-      filePairs: context.filePairs || [],
-      summary: mutationResult.summary || this._buildEmptySummary(),
-      files: mutationResult.files || {},
-      mutants: (mutationResult.mutants || []).map(m => ({
+
+/**
+ * ReportGenerator — builds and writes mutation reports.
+ *
+ * Produces TWO files:
+ *   1. Mutation summary report  (mutation-report.json)
+ *      Contains mutation score, summary, file details — used by CI
+ *      to decide pass/fail.
+ *
+ *   2. SonarQube external issues report  (sonar-mutation-report.json)
+ *      Compatible with sonar.externalIssuesReportPaths property.
+ *      Reports survived and no-coverage mutants as issues so they
+ *      show up inside SonarQube.
+ *
+ * Compatible with Node 16+.
+ */
+function ReportGenerator(options) {
+  options = options || {};
+  this._outputDir = options.outputDir || 'reports/mutation';
+  this._outputFileName = options.outputFileName || 'mutation-report.json';
+  this._sonarFileName = options.sonarFileName || 'sonar-mutation-report.json';
+  this._cwd = options.cwd || process.cwd();
+}
+
+/* ------------------------------------------------------------------ */
+/*  Mutation summary report                                             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Build the mutation summary report object (does not write to disk).
+ */
+ReportGenerator.prototype.generate = function (mutationResult, context) {
+  context = context || {};
+  var mutants = mutationResult.mutants || [];
+  return {
+    schemaVersion: '1.0',
+    timestamp: new Date().toISOString(),
+    projectRoot: this._cwd,
+    command: context.command || 'unknown',
+    mode: context.mode || null,
+    configuration: {
+      releaseBranch: context.releaseBranch || null
+    },
+    filePairs: context.filePairs || [],
+    summary: mutationResult.summary || this._buildEmptySummary(),
+    files: mutationResult.files || {},
+    mutants: mutants.map(function (m) {
+      return {
         id: m.id,
         mutatorName: m.mutatorName,
         replacement: m.replacement,
@@ -32,41 +59,202 @@ class ReportGenerator {
         killedBy: m.killedBy || [],
         coveredBy: m.coveredBy || [],
         description: m.description || ''
-      }))
+      };
+    })
+  };
+};
+
+/* ------------------------------------------------------------------ */
+/*  SonarQube external issues report                                    */
+/* ------------------------------------------------------------------ */
+
+/**
+ * SonarQube severity mapping for mutant statuses.
+ *
+ * Only survived and no-coverage mutants are reported as issues.
+ * Killed, Timeout, Ignored, etc. are NOT issues.
+ */
+var SONAR_SEVERITY_MAP = {
+  survived: 'MAJOR',
+  nocoverage: 'MINOR'
+};
+var SONAR_RULE_MAP = {
+  survived: 'mutant-survived',
+  nocoverage: 'mutant-no-coverage'
+};
+
+/**
+ * Build a SonarQube-compatible external issues report.
+ *
+ * Format: { issues: [ { engineId, ruleId, severity, type, primaryLocation, effortMinutes } ] }
+ * Ref: https://docs.sonarsource.com/sonarqube/latest/analyzing-source-code/importing-external-issues/generic-issue-import-format/
+ *
+ * @param {object} mutationResult - normalized Stryker result
+ * @returns {object} SonarQube generic issue import object
+ */
+ReportGenerator.prototype.generateSonarReport = function (mutationResult) {
+  var mutants = mutationResult.mutants || [];
+  var issues = [];
+  for (var i = 0; i < mutants.length; i++) {
+    var mutant = mutants[i];
+    var status = (mutant.status || '').toLowerCase();
+
+    // Only survived and no-coverage are actionable issues
+    if (!SONAR_SEVERITY_MAP[status]) {
+      continue;
+    }
+    var fileName = mutant.fileName || mutant.sourceFile || '';
+    if (!fileName) continue;
+    var message = this._buildSonarMessage(mutant, status);
+    var textRange = this._buildSonarTextRange(mutant.location);
+    var issue = {
+      engineId: 'stryker',
+      ruleId: SONAR_RULE_MAP[status],
+      severity: SONAR_SEVERITY_MAP[status],
+      type: 'CODE_SMELL',
+      primaryLocation: {
+        message: message,
+        filePath: fileName.replace(/\\/g, '/'),
+        textRange: textRange
+      },
+      effortMinutes: status === 'survived' ? 15 : 10
     };
-    return report;
+    issues.push(issue);
   }
-  _buildEmptySummary() {
-    return {
-      totalMutants: 0,
-      killed: 0,
-      survived: 0,
-      timeout: 0,
-      noCoverage: 0,
-      ignored: 0,
-      runtimeErrors: 0,
-      compileErrors: 0,
-      mutationScore: 0
-    };
+  return {
+    issues: issues
+  };
+};
+
+/**
+ * Build a human-readable message for a SonarQube issue.
+ */
+ReportGenerator.prototype._buildSonarMessage = function (mutant, status) {
+  var parts = [];
+  if (status === 'survived') {
+    parts.push('Survived mutant');
+  } else {
+    parts.push('Mutant has no test coverage');
   }
-  write(report) {
-    const outputPath = path.resolve(this._cwd, this._outputDir);
-    if (!fs.existsSync(outputPath)) {
-      fs.mkdirSync(outputPath, {
-        recursive: true
-      });
-    }
-    const filePath = path.join(outputPath, this._outputFileName);
-    fs.writeFileSync(filePath, JSON.stringify(report, null, 2), 'utf-8');
-    return filePath;
+  if (mutant.mutatorName) {
+    parts.push(': ' + mutant.mutatorName);
+  }
+  if (mutant.replacement !== undefined && mutant.replacement !== null) {
+    parts.push(' → replaced with "' + String(mutant.replacement) + '"');
   }
-  generateAndWrite(mutationResult, context = {}) {
-    const report = this.generate(mutationResult, context);
-    const filePath = this.write(report);
+  if (mutant.description) {
+    parts.push(' (' + mutant.description + ')');
+  }
+  return parts.join('');
+};
+
+/**
+ * Build a SonarQube textRange from Stryker location.
+ *
+ * SonarQube expects 1-based lines and 0-based columns.
+ * Stryker v5 uses 0-based lines and 0-based columns by default,
+ * but some reporters produce 1-based; we handle both.
+ */
+ReportGenerator.prototype._buildSonarTextRange = function (location) {
+  if (!location || !location.start) {
     return {
-      report,
-      filePath
+      startLine: 1,
+      endLine: 1,
+      startColumn: 0,
+      endColumn: 1
     };
   }
-}
+  var startLine = location.start.line;
+  var endLine = location.end && location.end.line || startLine;
+  var startColumn = location.start.column || 0;
+  var endColumn = location.end && location.end.column || startColumn + 1;
+
+  // Ensure lines are at least 1 (SonarQube requires 1-based)
+  if (startLine < 1) startLine = 1;
+  if (endLine < 1) endLine = 1;
+  return {
+    startLine: startLine,
+    endLine: endLine,
+    startColumn: startColumn,
+    endColumn: endColumn
+  };
+};
+
+/* ------------------------------------------------------------------ */
+/*  Common helpers                                                      */
+/* ------------------------------------------------------------------ */
+
+ReportGenerator.prototype._buildEmptySummary = function () {
+  return {
+    totalMutants: 0,
+    killed: 0,
+    survived: 0,
+    timeout: 0,
+    noCoverage: 0,
+    ignored: 0,
+    runtimeErrors: 0,
+    compileErrors: 0,
+    mutationScore: 0
+  };
+};
+
+/* ------------------------------------------------------------------ */
+/*  Write to disk                                                       */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Write the mutation summary report to disk.
+ *
+ * @param {object} report
+ * @returns {string} absolute file path
+ */
+ReportGenerator.prototype.write = function (report) {
+  var outputPath = path.resolve(this._cwd, this._outputDir);
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, {
+      recursive: true
+    });
+  }
+  var filePath = path.join(outputPath, this._outputFileName);
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2), 'utf-8');
+  return filePath;
+};
+
+/**
+ * Write the SonarQube external issues report to disk.
+ *
+ * @param {object} sonarReport
+ * @returns {string} absolute file path
+ */
+ReportGenerator.prototype.writeSonarReport = function (sonarReport) {
+  var outputPath = path.resolve(this._cwd, this._outputDir);
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, {
+      recursive: true
+    });
+  }
+  var filePath = path.join(outputPath, this._sonarFileName);
+  fs.writeFileSync(filePath, JSON.stringify(sonarReport, null, 2), 'utf-8');
+  return filePath;
+};
+
+/**
+ * Generate + write both reports in one call.
+ *
+ * @param {object} mutationResult - normalized Stryker result
+ * @param {object} context        - command, mode, releaseBranch, filePairs
+ * @returns {{ report: object, sonarReport: object, filePath: string, sonarFilePath: string }}
+ */
+ReportGenerator.prototype.generateAndWrite = function (mutationResult, context) {
+  var report = this.generate(mutationResult, context);
+  var sonarReport = this.generateSonarReport(mutationResult);
+  var filePath = this.write(report);
+  var sonarFilePath = this.writeSonarReport(sonarReport);
+  return {
+    report: report,
+    sonarReport: sonarReport,
+    filePath: filePath,
+    sonarFilePath: sonarFilePath
+  };
+};
 module.exports = ReportGenerator;

package/build/mutation/strykerConfigBuilder.js

@@ -0,0 +1,327 @@
+"use strict";
+
+var path = require('path');
+var os = require('os');
+var VALID_TEST_RUNNERS = ['jest', 'command'];
+var VALID_COVERAGE_ANALYSES = ['off', 'all', 'perTest'];
+var VALID_LOG_LEVELS = ['off', 'fatal', 'error', 'warn', 'info', 'debug', 'trace'];
+var VALID_REPORTERS = ['html', 'json', 'clear-text', 'progress', 'dots', 'dashboard', 'event-recorder'];
+var VALID_JEST_PROJECT_TYPES = ['custom', 'create-react-app', 'create-react-app-ts'];
+
+/**
+ * StrykerConfigBuilder — fluent builder for @stryker-mutator/core config.
+ *
+ * Covers every option from the PartialStrykerOptions API and applies
+ * sensible defaults.  Call .build() to produce the final frozen config
+ * object that can be fed directly to `new Stryker(config)`.
+ *
+ * Usage:
+ *   var config = new StrykerConfigBuilder()
+ *     .setPackageManager('npm')
+ *     .setTestRunner('jest')
+ *     .setCoverageAnalysis('perTest')
+ *     .setMutate(['src/**\/*.ts', '!src/**\/*.d.ts'])
+ *     .setJest({ configFile: 'jest.config.js', enableFindRelatedTests: true })
+ *     .setConcurrency(4)
+ *     .build();
+ */
+function StrykerConfigBuilder() {
+  this._config = {};
+}
+
+/* ------------------------------------------------------------------ */
+/*  Core settings                                                       */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setPackageManager = function (value) {
+  if (value !== 'npm' && value !== 'yarn' && value !== 'pnpm') {
+    throw new Error('packageManager must be "npm", "yarn", or "pnpm". Got: ' + value);
+  }
+  this._config.packageManager = value;
+  return this;
+};
+StrykerConfigBuilder.prototype.setTestRunner = function (value) {
+  if (VALID_TEST_RUNNERS.indexOf(value) === -1) {
+    throw new Error('testRunner must be one of [' + VALID_TEST_RUNNERS.join(', ') + ']. Got: ' + value);
+  }
+  this._config.testRunner = value;
+  return this;
+};
+StrykerConfigBuilder.prototype.setCoverageAnalysis = function (value) {
+  if (VALID_COVERAGE_ANALYSES.indexOf(value) === -1) {
+    throw new Error('coverageAnalysis must be one of [' + VALID_COVERAGE_ANALYSES.join(', ') + ']. Got: ' + value);
+  }
+  this._config.coverageAnalysis = value;
+  return this;
+};
+StrykerConfigBuilder.prototype.setLogLevel = function (value) {
+  if (VALID_LOG_LEVELS.indexOf(value) === -1) {
+    throw new Error('logLevel must be one of [' + VALID_LOG_LEVELS.join(', ') + ']. Got: ' + value);
+  }
+  this._config.logLevel = value;
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Reporters                                                           */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setReporters = function (reporters) {
+  if (!Array.isArray(reporters) || reporters.length === 0) {
+    throw new Error('reporters must be a non-empty array.');
+  }
+  for (var i = 0; i < reporters.length; i++) {
+    if (VALID_REPORTERS.indexOf(reporters[i]) === -1) {
+      throw new Error('Unknown reporter "' + reporters[i] + '". Valid: [' + VALID_REPORTERS.join(', ') + ']');
+    }
+  }
+  this._config.reporters = reporters.slice();
+  return this;
+};
+StrykerConfigBuilder.prototype.setHtmlReporter = function (opts) {
+  if (!opts || typeof opts.fileName !== 'string') {
+    throw new Error('htmlReporter requires a fileName string.');
+  }
+  this._config.htmlReporter = {
+    fileName: opts.fileName
+  };
+  return this;
+};
+StrykerConfigBuilder.prototype.setJsonReporter = function (opts) {
+  if (!opts || typeof opts.fileName !== 'string') {
+    throw new Error('jsonReporter requires a fileName string.');
+  }
+  this._config.jsonReporter = {
+    fileName: opts.fileName
+  };
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Mutate patterns                                                     */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setMutate = function (patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0) {
+    throw new Error('mutate must be a non-empty array of glob patterns.');
+  }
+  this._config.mutate = patterns.slice();
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Jest configuration                                                  */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setJest = function (jestOpts) {
+  if (!jestOpts || typeof jestOpts !== 'object') {
+    throw new Error('jest config must be a non-null object.');
+  }
+  var jest = {};
+  if (jestOpts.projectType) {
+    if (VALID_JEST_PROJECT_TYPES.indexOf(jestOpts.projectType) === -1) {
+      throw new Error('jest.projectType must be one of [' + VALID_JEST_PROJECT_TYPES.join(', ') + ']. Got: ' + jestOpts.projectType);
+    }
+    jest.projectType = jestOpts.projectType;
+  }
+  if (jestOpts.configFile) {
+    jest.configFile = jestOpts.configFile;
+  }
+  if (jestOpts.enableFindRelatedTests != null) {
+    jest.enableFindRelatedTests = !!jestOpts.enableFindRelatedTests;
+  }
+  if (jestOpts.config && typeof jestOpts.config === 'object') {
+    jest.config = Object.assign({}, jestOpts.config);
+  }
+  this._config.jest = jest;
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Command runner (alternative to jest runner)                         */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setCommandRunner = function (opts) {
+  if (!opts || typeof opts.command !== 'string') {
+    throw new Error('commandRunner requires a command string.');
+  }
+  this._config.commandRunner = {
+    command: opts.command
+  };
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Timeouts & concurrency                                              */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setTimeoutMS = function (value) {
+  var n = Number(value);
+  if (isNaN(n) || n <= 0) {
+    throw new Error('timeoutMS must be a positive number. Got: ' + value);
+  }
+  this._config.timeoutMS = n;
+  return this;
+};
+StrykerConfigBuilder.prototype.setTimeoutFactor = function (value) {
+  var n = Number(value);
+  if (isNaN(n) || n <= 0) {
+    throw new Error('timeoutFactor must be a positive number. Got: ' + value);
+  }
+  this._config.timeoutFactor = n;
+  return this;
+};
+StrykerConfigBuilder.prototype.setConcurrency = function (value) {
+  var n = Number(value);
+  if (isNaN(n) || n < 1) {
+    throw new Error('concurrency must be >= 1. Got: ' + value);
+  }
+  this._config.concurrency = Math.floor(n);
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Temp directory & cleanup                                            */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setTempDirName = function (value) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error('tempDirName must be a non-empty string.');
+  }
+  this._config.tempDirName = value;
+  return this;
+};
+StrykerConfigBuilder.prototype.setCleanTempDir = function (value) {
+  this._config.cleanTempDir = !!value;
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Thresholds                                                          */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setThresholds = function (opts) {
+  if (!opts || typeof opts !== 'object') {
+    throw new Error('thresholds must be a non-null object.');
+  }
+  this._config.thresholds = {
+    high: opts.high != null ? Number(opts.high) : 80,
+    low: opts.low != null ? Number(opts.low) : 60,
+    break: opts.break != null ? Number(opts.break) : null
+  };
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Miscellaneous                                                       */
+/* ------------------------------------------------------------------ */
+
+StrykerConfigBuilder.prototype.setAllowEmpty = function (value) {
+  this._config.allowEmpty = !!value;
+  return this;
+};
+StrykerConfigBuilder.prototype.setConfigFile = function (filePath) {
+  if (typeof filePath !== 'string' || filePath.length === 0) {
+    throw new Error('configFile must be a non-empty string.');
+  }
+  this._config.configFile = filePath;
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Build from external config file (stryker.conf.js)                   */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Seed the builder from an existing Stryker config file (JS/JSON).
+ * Values set after this call override what the file provides.
+ */
+StrykerConfigBuilder.prototype.fromConfigFile = function (filePath) {
+  var resolved = path.resolve(filePath);
+  var external = require(resolved);
+  this._config = Object.assign({}, external, this._config);
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Build from a plain options hash (backwards compat)                  */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Populate builder fields from a flat options object.
+ * Useful for migrating existing code that already passes an options bag.
+ */
+StrykerConfigBuilder.prototype.fromOptions = function (opts) {
+  if (!opts || typeof opts !== 'object') return this;
+  if (opts.packageManager) this.setPackageManager(opts.packageManager);
+  if (opts.testRunner) this.setTestRunner(opts.testRunner);
+  if (opts.coverageAnalysis) this.setCoverageAnalysis(opts.coverageAnalysis);
+  if (opts.logLevel) this.setLogLevel(opts.logLevel);
+  if (opts.reporters) this.setReporters(opts.reporters);
+  if (opts.htmlReporter) this.setHtmlReporter(opts.htmlReporter);
+  if (opts.jsonReporter) this.setJsonReporter(opts.jsonReporter);
+  if (opts.mutate) this.setMutate(opts.mutate);
+  if (opts.jest) this.setJest(opts.jest);
+  if (opts.commandRunner) this.setCommandRunner(opts.commandRunner);
+  if (opts.timeoutMS != null) this.setTimeoutMS(opts.timeoutMS);
+  if (opts.timeoutFactor != null) this.setTimeoutFactor(opts.timeoutFactor);
+  if (opts.concurrency != null) this.setConcurrency(opts.concurrency);
+  if (opts.tempDirName) this.setTempDirName(opts.tempDirName);
+  if (opts.cleanTempDir != null) this.setCleanTempDir(opts.cleanTempDir);
+  if (opts.thresholds) this.setThresholds(opts.thresholds);
+  if (opts.allowEmpty != null) this.setAllowEmpty(opts.allowEmpty);
+  if (opts.configFile) this.setConfigFile(opts.configFile);
+  return this;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Build                                                               */
+/* ------------------------------------------------------------------ */
+
+var DEFAULTS = {
+  packageManager: 'npm',
+  testRunner: 'jest',
+  coverageAnalysis: 'perTest',
+  reporters: ['html', 'json'],
+  logLevel: 'info',
+  timeoutMS: 60000,
+  timeoutFactor: 1.5,
+  cleanTempDir: true,
+  allowEmpty: true,
+  thresholds: {
+    high: 80,
+    low: 60,
+    break: null
+  }
+};
+
+/**
+ * Produce the final config object.
+ *
+ * Merges explicit values over sensible defaults; computes concurrency
+ * from CPU count if not specified.
+ *
+ * @returns {object} frozen Stryker-compatible config
+ */
+StrykerConfigBuilder.prototype.build = function () {
+  var cfg = Object.assign({}, DEFAULTS, this._config);
+  if (cfg.concurrency == null) {
+    cfg.concurrency = Math.max(1, os.cpus().length - 1);
+  }
+  return cfg;
+};
+
+/**
+ * Snapshot the current builder state (shallow copy).
+ * Useful for forking a shared base config per Stryker run.
+ */
+StrykerConfigBuilder.prototype.clone = function () {
+  var copy = new StrykerConfigBuilder();
+  copy._config = Object.assign({}, this._config);
+  if (this._config.mutate) copy._config.mutate = this._config.mutate.slice();
+  if (this._config.reporters) copy._config.reporters = this._config.reporters.slice();
+  if (this._config.jest) copy._config.jest = Object.assign({}, this._config.jest);
+  if (this._config.thresholds) copy._config.thresholds = Object.assign({}, this._config.thresholds);
+  return copy;
+};
+module.exports = StrykerConfigBuilder;