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

package/build/mutation/fileResolver.js

@@ -6,165 +6,196 @@ const glob = require('glob');
 const {
   getRootDirectory
 } = require('../utils/General/RootDirectoryUtils/getRootDirectory');
-class FileResolver {
-  constructor(options = {}) {
-    this._rootdir = getRootDirectory();
-    this._cwd = options.cwd || process.cwd();
-    this._testSuffixes = options.testSuffixes || ['.test.js', '.test.ts', '.test.jsx', '.test.tsx'];
-    this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
-  }
-  findTestForSource(sourceFile) {
-    const parsed = path.parse(sourceFile);
-    const dir = parsed.dir;
-    const name = parsed.name;
-
-    // Strategy 1: Test file alongside source (e.g., src/foo.js -> src/foo.test.js)
-    for (const suffix of this._testSuffixes) {
-      const candidate = path.join(dir, `${name}${suffix}`);
-      if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-        return candidate;
-      }
+
+/**
+ * FileResolver — resolves source ↔ test file pairs.
+ *
+ * Uses heuristic strategies (co-located, __tests__/, mirrored dirs)
+ * to find a test file for every source file and vice versa.
+ *
+ * Compatible with Node 16+.
+ */
+function FileResolver(options) {
+  options = options || {};
+  this._rootdir = getRootDirectory();
+  this._cwd = options.cwd || process.cwd();
+  this._testSuffixes = options.testSuffixes || ['.test.js', '.test.ts', '.test.jsx', '.test.tsx'];
+  this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+}
+
+/* ------------------------------------------------------------------ */
+/*  Source → Test                                                       */
+/* ------------------------------------------------------------------ */
+
+FileResolver.prototype.findTestForSource = function (sourceFile) {
+  var parsed = path.parse(sourceFile);
+  var dir = parsed.dir;
+  var name = parsed.name;
+  var candidate, i, j, k;
+
+  // Strategy 1: co-located  (src/foo.js → src/foo.test.js)
+  for (i = 0; i < this._testSuffixes.length; i++) {
+    candidate = path.join(dir, name + this._testSuffixes[i]);
+    if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+      return candidate;
     }
+  }
 
-    // Strategy 2: Test in __tests__ directory (e.g., src/foo.js -> src/__tests__/foo.test.js)
-    for (const suffix of this._testSuffixes) {
-      const candidate = path.join(dir, '__tests__', `${name}${suffix}`);
-      if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-        return candidate;
-      }
+  // Strategy 2: __tests__ subdir  (src/foo.js → src/__tests__/foo.test.js)
+  for (i = 0; i < this._testSuffixes.length; i++) {
+    candidate = path.join(dir, '__tests__', name + this._testSuffixes[i]);
+    if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+      return candidate;
     }
+  }
 
-    // Strategy 3: Mirror structure under test/tests directory
-    const testDirs = ['test', 'tests', '__tests__'];
-    const srcDirs = ['src', 'lib'];
-    for (const srcDir of srcDirs) {
-      if (dir.startsWith(srcDir)) {
-        const relativePath = dir.substring(srcDir.length);
-        for (const testDir of testDirs) {
-          for (const suffix of this._testSuffixes) {
-            const candidate = path.join(testDir, relativePath, `${name}${suffix}`);
-            if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-              return candidate;
-            }
+  // Strategy 3: mirror structure  (src/x/foo.js → test/x/foo.test.js)
+  var testDirs = ['test', 'tests', '__tests__'];
+  var srcDirs = ['src', 'lib'];
+  for (i = 0; i < srcDirs.length; i++) {
+    if (dir.indexOf(srcDirs[i]) === 0) {
+      var relativePath = dir.substring(srcDirs[i].length);
+      for (j = 0; j < testDirs.length; j++) {
+        for (k = 0; k < this._testSuffixes.length; k++) {
+          candidate = path.join(testDirs[j], relativePath, name + this._testSuffixes[k]);
+          if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+            return candidate;
           }
         }
       }
     }
-    return null;
   }
-  findSourceForTest(testFile) {
-    const parsed = path.parse(testFile);
-    const dir = parsed.dir;
-    let name = parsed.name;
-
-    // Remove .test suffix
-    for (const suffix of ['.test', '.spec']) {
-      if (name.endsWith(suffix)) {
-        name = name.slice(0, -suffix.length);
-        break;
-      }
+  return null;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Test → Source                                                        */
+/* ------------------------------------------------------------------ */
+
+FileResolver.prototype.findSourceForTest = function (testFile) {
+  var parsed = path.parse(testFile);
+  var dir = parsed.dir;
+  var name = parsed.name;
+  var candidate, i, j, k;
+
+  // Strip .test / .spec suffix
+  var suffixes = ['.test', '.spec'];
+  for (i = 0; i < suffixes.length; i++) {
+    if (name.slice(-suffixes[i].length) === suffixes[i]) {
+      name = name.slice(0, -suffixes[i].length);
+      break;
     }
+  }
 
-    // Strategy 1: Source file alongside test
-    for (const ext of this._sourceExtensions) {
-      const candidate = path.join(dir, `${name}${ext}`);
-      if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-        return candidate;
-      }
+  // Strategy 1: co-located
+  for (i = 0; i < this._sourceExtensions.length; i++) {
+    candidate = path.join(dir, name + this._sourceExtensions[i]);
+    if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+      return candidate;
     }
+  }
 
-    // Strategy 2: Source in parent (when test is in __tests__)
-    if (dir.includes('__tests__')) {
-      const parentDir = dir.replace(/__tests__\/?/, '');
-      for (const ext of this._sourceExtensions) {
-        const candidate = path.join(parentDir, `${name}${ext}`);
-        if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-          return candidate;
-        }
+  // Strategy 2: parent of __tests__
+  if (dir.indexOf('__tests__') !== -1) {
+    var parentDir = dir.replace(/__tests__\/?/, '');
+    for (i = 0; i < this._sourceExtensions.length; i++) {
+      candidate = path.join(parentDir, name + this._sourceExtensions[i]);
+      if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+        return candidate;
       }
     }
+  }
 
-    // Strategy 3: Mirror test dir structure back to src/lib
-    const testDirs = ['test', 'tests', '__tests__'];
-    const srcDirs = ['src', 'lib'];
-    for (const testDir of testDirs) {
-      if (dir.startsWith(testDir)) {
-        const relativePath = dir.substring(testDir.length);
-        for (const srcDir of srcDirs) {
-          for (const ext of this._sourceExtensions) {
-            const candidate = path.join(srcDir, relativePath, `${name}${ext}`);
-            if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
-              return candidate;
-            }
+  // Strategy 3: mirror test → src/lib
+  var testDirs = ['test', 'tests', '__tests__'];
+  var srcDirs = ['src', 'lib'];
+  for (i = 0; i < testDirs.length; i++) {
+    if (dir.indexOf(testDirs[i]) === 0) {
+      var relativePath = dir.substring(testDirs[i].length);
+      for (j = 0; j < srcDirs.length; j++) {
+        for (k = 0; k < this._sourceExtensions.length; k++) {
+          candidate = path.join(srcDirs[j], relativePath, name + this._sourceExtensions[k]);
+          if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+            return candidate;
           }
         }
       }
     }
-    return null;
   }
-  resolveSourceTestPairs(sourceFiles, testFiles) {
-    const pairs = [];
-    const resolvedSources = new Set();
-    const resolvedTests = new Set();
-
-    // Map source -> test
-    for (const source of sourceFiles) {
-      const normalizedSource = source.replace(/\\/g, '/');
-      const test = this.findTestForSource(normalizedSource);
-      if (test) {
-        const normalizedTest = test.replace(/\\/g, '/');
-        pairs.push({
-          source: normalizedSource,
-          test: normalizedTest
-        });
-        resolvedSources.add(normalizedSource);
-        resolvedTests.add(normalizedTest);
-      } else {
-        // Source file with no matching test
-        pairs.push({
-          source: normalizedSource,
-          test: null
-        });
-        resolvedSources.add(normalizedSource);
-      }
-    }
+  return null;
+};
 
-    // Map remaining test -> source
-    for (const test of testFiles) {
-      const normalizedTest = test.replace(/\\/g, '/');
-      if (resolvedTests.has(normalizedTest)) continue;
-      const source = this.findSourceForTest(normalizedTest);
-      if (source && !resolvedSources.has(source.replace(/\\/g, '/'))) {
-        pairs.push({
-          source: source.replace(/\\/g, '/'),
-          test: normalizedTest
-        });
-        resolvedSources.add(source.replace(/\\/g, '/'));
-      }
-      resolvedTests.add(normalizedTest);
+/* ------------------------------------------------------------------ */
+/*  Pair resolution                                                     */
+/* ------------------------------------------------------------------ */
+
+FileResolver.prototype.resolveSourceTestPairs = function (sourceFiles, testFiles) {
+  var pairs = [];
+  var resolvedSources = {};
+  var resolvedTests = {};
+  var i, normalizedSource, normalizedTest, test, source;
+
+  // Map source → test
+  for (i = 0; i < sourceFiles.length; i++) {
+    normalizedSource = sourceFiles[i].replace(/\\/g, '/');
+    test = this.findTestForSource(normalizedSource);
+    if (test) {
+      normalizedTest = test.replace(/\\/g, '/');
+      pairs.push({
+        source: normalizedSource,
+        test: normalizedTest
+      });
+      resolvedSources[normalizedSource] = true;
+      resolvedTests[normalizedTest] = true;
+    } else {
+      pairs.push({
+        source: normalizedSource,
+        test: null
+      });
+      resolvedSources[normalizedSource] = true;
     }
-    return pairs;
   }
-  collectFiles(directory, pattern) {
-    const fullPattern = path.join(directory, pattern || '**/*.{js,ts,jsx,tsx}').replace(/\\/g, '/');
-    try {
-      const files = glob.sync(fullPattern, {
-        cwd: this._rootdir,
-        nodir: true
+
+  // Map remaining test → source
+  for (i = 0; i < testFiles.length; i++) {
+    normalizedTest = testFiles[i].replace(/\\/g, '/');
+    if (resolvedTests[normalizedTest]) continue;
+    source = this.findSourceForTest(normalizedTest);
+    if (source && !resolvedSources[source.replace(/\\/g, '/')]) {
+      pairs.push({
+        source: source.replace(/\\/g, '/'),
+        test: normalizedTest
       });
-      return files;
-    } catch (err) {
-      throw new Error(`Failed to collect files from '${directory}': ${err.message}`);
+      resolvedSources[source.replace(/\\/g, '/')] = true;
     }
+    resolvedTests[normalizedTest] = true;
   }
-  collectSourceFiles(srcDir) {
-    const allFiles = this.collectFiles(srcDir, '**/*.{js,ts,jsx,tsx,mjs,cjs}');
-    const testPattern = /\.(test|spec)\.(js|ts|jsx|tsx|mjs|cjs)$/;
-    return allFiles.filter(f => !testPattern.test(f));
-  }
-  collectTestFiles(testDir) {
-    const allFiles = this.collectFiles(testDir, '**/*.{test,spec}.{js,ts,jsx,tsx}');
-    return allFiles;
+  return pairs;
+};
+
+/* ------------------------------------------------------------------ */
+/*  File collectors (glob-based)                                        */
+/* ------------------------------------------------------------------ */
+
+FileResolver.prototype.collectFiles = function (directory, pattern) {
+  var fullPattern = path.join(directory, pattern || '**/*.{js,ts,jsx,tsx}').replace(/\\/g, '/');
+  try {
+    return glob.sync(fullPattern, {
+      cwd: this._rootdir,
+      nodir: true
+    });
+  } catch (err) {
+    throw new Error("Failed to collect files from '" + directory + "': " + err.message);
   }
-}
+};
+FileResolver.prototype.collectSourceFiles = function (srcDir) {
+  var allFiles = this.collectFiles(srcDir, '**/*.{js,ts,jsx,tsx,mjs,cjs}');
+  var testPattern = /\.(test|spec)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+  return allFiles.filter(function (f) {
+    return !testPattern.test(f);
+  });
+};
+FileResolver.prototype.collectTestFiles = function (testDir) {
+  return this.collectFiles(testDir, '**/*.{test,spec}.{js,ts,jsx,tsx}');
+};
 module.exports = FileResolver;

package/build/mutation/mutationCli.js

@@ -1,111 +1,173 @@
 "use strict";
 
-const MutationRunner = require('./mutationRunner');
-class MutationCli {
-  constructor(options = {}) {
-    this._options = options;
+var MutationRunner = require('./mutationRunner');
+var StrykerConfigBuilder = require('./strykerConfigBuilder');
+
+/**
+ * MutationCli — CLI argument parser and executor for mutation testing.
+ *
+ * Two modes:
+ *   local  — pre-commit: staged + branch diff → mutate → JSON report
+ *   ci     — CI pipeline: branch diff → mutate → JSON report
+ *
+ * Usage (zdcodequality):
+ *   npx zdcodequality mutate --local [--branch=<branch>]   (default branch: release)
+ *   npx zdcodequality mutate --ci    [--branch=<branch>]   (default branch: release)
+ *
+ * Legacy (ZDLintFramework):
+ *   npx ZDLintFramework mutate --mode=local --release=<branch>
+ *   npx ZDLintFramework mutate --mode=ci    --release=<branch>
+ *
+ * Optional flags:
+ *   --outputDir=<dir>           (default: reports/mutation)
+ *   --outputFileName=<name>     (default: mutation-report.json)
+ *   --logLevel=<level>          (default: info)
+ *   --concurrency=<n>           (default: cpu count - 1)
+ *   --timeoutMS=<ms>            (default: 60000)
+ *   --strykerConfig=<path>      (external stryker.conf.js)
+ *
+ * Compatible with Node 16+.
+ */
+function MutationCli(options) {
+  this._options = options || {};
+}
+
+/* ------------------------------------------------------------------ */
+/*  Arg parsing                                                         */
+/* ------------------------------------------------------------------ */
+
+MutationCli.prototype.parseArgs = function (args) {
+  var parsed = {
+    command: null,
+    mode: null,
+    release: null,
+    outputDir: null,
+    outputFileName: null,
+    logLevel: 'info',
+    concurrency: null,
+    timeoutMS: null,
+    strykerConfig: null
+  };
+  for (var i = 0; i < args.length; i++) {
+    var arg = args[i];
+    if (arg === 'mutate') {
+      parsed.command = 'mutate';
+    } else if (arg === '--local') {
+      parsed.mode = 'local';
+    } else if (arg === '--ci') {
+      parsed.mode = 'ci';
+    } else if (arg.indexOf('--branch=') === 0) {
+      parsed.release = arg.split('=')[1];
+    } else if (arg.indexOf('--mode=') === 0) {
+      parsed.mode = arg.split('=')[1];
+    } else if (arg.indexOf('--release=') === 0) {
+      parsed.release = arg.split('=')[1];
+    } else if (arg.indexOf('--outputDir=') === 0) {
+      parsed.outputDir = arg.split('=')[1];
+    } else if (arg.indexOf('--outputFileName=') === 0) {
+      parsed.outputFileName = arg.split('=')[1];
+    } else if (arg.indexOf('--logLevel=') === 0) {
+      parsed.logLevel = arg.split('=')[1];
+    } else if (arg.indexOf('--concurrency=') === 0) {
+      parsed.concurrency = arg.split('=')[1];
+    } else if (arg.indexOf('--timeoutMS=') === 0) {
+      parsed.timeoutMS = arg.split('=')[1];
+    } else if (arg.indexOf('--strykerConfig=') === 0) {
+      parsed.strykerConfig = arg.split('=')[1];
+    }
+  }
+  if (parsed.release == null || parsed.release === '') {
+    parsed.release = 'release';
   }
-  parseArgs(args) {
-    const parsed = {
-      command: null,
-      branch: null,
-      src: null,
-      test: null,
-      useApi: false,
-      outputDir: null,
-      outputFileName: null,
-      logLevel: 'info',
-      hostname: null
+  return parsed;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Validation                                                          */
+/* ------------------------------------------------------------------ */
+
+MutationCli.prototype.validate = function (parsed) {
+  if (parsed.command !== 'mutate') {
+    return {
+      valid: false,
+      error: 'Unknown command. Expected "mutate".'
     };
-    for (const arg of args) {
-      if (arg === 'mutate') {
-        parsed.command = 'mutate';
-      } else if (arg.startsWith('--branch=')) {
-        parsed.branch = arg.split('=')[1];
-      } else if (arg.startsWith('--src=')) {
-        parsed.src = arg.split('=')[1];
-      } else if (arg.startsWith('--test=')) {
-        parsed.test = arg.split('=')[1];
-      } else if (arg === '--useApi') {
-        parsed.useApi = true;
-      } else if (arg.startsWith('--outputDir=')) {
-        parsed.outputDir = arg.split('=')[1];
-      } else if (arg.startsWith('--outputFileName=')) {
-        parsed.outputFileName = arg.split('=')[1];
-      } else if (arg.startsWith('--logLevel=')) {
-        parsed.logLevel = arg.split('=')[1];
-      } else if (arg.startsWith('--hostname=')) {
-        parsed.hostname = arg.split('=')[1];
-      }
-    }
-    return parsed;
   }
-  validate(parsed) {
-    if (parsed.command !== 'mutate') {
-      return {
-        valid: false,
-        error: 'Unknown command. Expected "mutate".'
-      };
-    }
-    const hasBranch = !!parsed.branch;
-    const hasSrcTest = !!parsed.src && !!parsed.test;
-    if (!hasBranch && !hasSrcTest) {
-      return {
-        valid: false,
-        error: 'Missing arguments. Usage:\n' + '  npx ZDLintFramework mutate --branch=<branch>\n' + '  npx ZDLintFramework mutate --src=<sourcedir> --test=<testdir>'
-      };
-    }
-    if (hasBranch && hasSrcTest) {
-      return {
-        valid: false,
-        error: 'Cannot use both --branch and --src/--test together. Choose one mode.'
-      };
-    }
+  if (!parsed.mode || parsed.mode !== 'local' && parsed.mode !== 'ci') {
     return {
-      valid: true
+      valid: false,
+      error: 'Invalid or missing mode. Use --local or --ci.\n' + 'Usage:\n' + '  npx zdcodequality mutate --local [--branch=<branch>]\n' + '  npx zdcodequality mutate --ci    [--branch=<branch>]\n' + '(default branch: release)'
     };
   }
-  async execute(args) {
-    const parsed = this.parseArgs(args);
-    const validation = this.validate(parsed);
-    if (!validation.valid) {
-      return {
-        success: false,
-        error: validation.error
-      };
-    }
-    const runner = new MutationRunner({
-      cwd: this._options.cwd,
-      api: this._options.api,
-      patToken: this._options.patToken,
-      jestConfig: this._options.jestConfig,
-      outputDir: parsed.outputDir || this._options.outputDir,
-      outputFileName: parsed.outputFileName || this._options.outputFileName,
-      logLevel: parsed.logLevel,
-      concurrency: this._options.concurrency,
-      timeoutMS: this._options.timeoutMS
+  return {
+    valid: true
+  };
+};
+
+/* ------------------------------------------------------------------ */
+/*  Build config via builder from parsed + defaults                     */
+/* ------------------------------------------------------------------ */
+
+MutationCli.prototype._buildConfig = function (parsed) {
+  var builder = new StrykerConfigBuilder();
+  if (parsed.strykerConfig || this._options.strykerConfigpath) {
+    builder.fromConfigFile(parsed.strykerConfig || this._options.strykerConfigpath);
+  }
+  builder.setLogLevel(parsed.logLevel || this._options.logLevel || 'info');
+  var concurrency = parsed.concurrency || this._options.concurrency;
+  if (concurrency != null) {
+    builder.setConcurrency(concurrency);
+  }
+  var timeoutMS = parsed.timeoutMS || this._options.timeoutMS;
+  if (timeoutMS != null) {
+    builder.setTimeoutMS(timeoutMS);
+  }
+  if (this._options.jestConfig) {
+    builder.setJest(Object.assign({
+      projectType: 'custom',
+      enableFindRelatedTests: true
+    }, this._options.jestConfig));
+  }
+  return builder;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Execution                                                           */
+/* ------------------------------------------------------------------ */
+
+MutationCli.prototype.execute = function (args) {
+  var parsed = this.parseArgs(args);
+  var validation = this.validate(parsed);
+  if (!validation.valid) {
+    return Promise.resolve({
+      success: false,
+      error: validation.error
     });
-    try {
-      let result;
-      if (parsed.branch) {
-        result = await runner.runByBranch(parsed.branch, {
-          useApi: parsed.useApi,
-          hostname: this._options.hostname,
-          projectId: this._options.projectId
-        });
-      } else {
-        result = await runner.runByDirectory(parsed.src, parsed.test);
-      }
-      return {
-        success: true,
-        ...result
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: err.message
-      };
-    }
   }
-}
+  var configBuilder = this._buildConfig(parsed);
+  var runner = new MutationRunner({
+    ...this._options,
+    cwd: this._options.cwd,
+    configBuilder: configBuilder,
+    jestConfig: this._options.jestConfig,
+    outputDir: parsed.outputDir || this._options.outputDir,
+    outputFileName: parsed.outputFileName || this._options.outputFileName
+  });
+  var promise;
+  if (parsed.mode === 'local') {
+    promise = runner.runLocal(parsed.release);
+  } else {
+    promise = runner.runCI(parsed.release);
+  }
+  return promise.then(function (result) {
+    return Object.assign({
+      success: true
+    }, result);
+  }).catch(function (err) {
+    return {
+      success: false,
+      error: err.message
+    };
+  });
+};
 module.exports = MutationCli;