@zohodesk/codestandard-validator 1.1.4 → 1.2.4-exp-2

package/build/mutation/reportGenerator.js

@@ -0,0 +1,72 @@
+"use strict";
+
+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 => ({
+        id: m.id,
+        mutatorName: m.mutatorName,
+        replacement: m.replacement,
+        fileName: m.fileName || m.sourceFile,
+        status: m.status,
+        location: m.location || null,
+        killedBy: m.killedBy || [],
+        coveredBy: m.coveredBy || [],
+        description: m.description || ''
+      }))
+    };
+    return report;
+  }
+  _buildEmptySummary() {
+    return {
+      totalMutants: 0,
+      killed: 0,
+      survived: 0,
+      timeout: 0,
+      noCoverage: 0,
+      ignored: 0,
+      runtimeErrors: 0,
+      compileErrors: 0,
+      mutationScore: 0
+    };
+  }
+  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;
+  }
+  generateAndWrite(mutationResult, context = {}) {
+    const report = this.generate(mutationResult, context);
+    const filePath = this.write(report);
+    return {
+      report,
+      filePath
+    };
+  }
+}
+module.exports = ReportGenerator;

package/build/mutation/strykerWrapper.js

@@ -0,0 +1,180 @@
+"use strict";
+
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var path = require('path');
+var patternConfig = require('./mutatePattern.json');
+var DEFAULT_MUTATE_PATTERN = patternConfig.defaultPattern;
+function StrykerWrapper(options) {
+  options = options || {};
+  this._strykerModule = null;
+  this._defaultOptions = {
+    testRunner: 'jest',
+    coverageAnalysis: 'perTest',
+    reporters: ['json', 'clear-text'],
+    jsonReporter: {
+      fileName: options.reportPath || 'reports/mutation/mutation.json'
+    },
+    cleanTempDir: true,
+    concurrency: options.concurrency || Math.max(1, require('os').cpus().length - 1),
+    timeoutMS: options.timeoutMS || 60000,
+    timeoutFactor: options.timeoutFactor || 1.5,
+    logLevel: options.logLevel || 'info',
+    allowEmpty: true
+  };
+}
+StrykerWrapper.prototype._loadStryker = async function () {
+  if (!this._strykerModule) {
+    try {
+      this._strykerModule = await Promise.resolve().then(() => _interopRequireWildcard(require('@stryker-mutator/core')));
+    } catch (err) {
+      throw new Error('Failed to load @stryker-mutator/core. Install it: ' + 'npm i --save-dev @stryker-mutator/core @stryker-mutator/jest-runner\n' + err.message);
+    }
+  }
+  return this._strykerModule;
+};
+StrykerWrapper.prototype._buildMutatePatterns = function (sourceFiles) {
+  if (!sourceFiles || sourceFiles.length === 0) {
+    return [DEFAULT_MUTATE_PATTERN];
+  }
+  return sourceFiles.map(function (f) {
+    return f.replace(/\\/g, '/');
+  });
+};
+StrykerWrapper.prototype._buildStrykerConfig = function (sourceFiles, options) {
+  options = options || {};
+  var mutatePatterns = this._buildMutatePatterns(sourceFiles);
+  var config = Object.assign({}, this._defaultOptions, {
+    mutate: mutatePatterns
+  });
+  if (options.testFiles && options.testFiles.length > 0) {
+    config.testFiles = options.testFiles.map(function (f) {
+      return f.replace(/\\/g, '/');
+    });
+  }
+  if (options.jest) {
+    config.jest = Object.assign({
+      projectType: 'custom',
+      enableFindRelatedTests: true
+    }, options.jest);
+  }
+  if (options.configFile) {
+    config.configFile = options.configFile;
+  }
+  if (options.reportPath) {
+    config.jsonReporter = {
+      fileName: options.reportPath
+    };
+  }
+  if (options.tempDirName) {
+    config.tempDirName = options.tempDirName;
+  }
+  if (options.thresholds) {
+    config.thresholds = options.thresholds;
+  }
+  return config;
+};
+StrykerWrapper.prototype.run = async function (sourceFiles, options) {
+  options = options || {};
+  var strykerModule = await this._loadStryker();
+  var Stryker = strykerModule.Stryker || strykerModule.default || strykerModule;
+  var config = this._buildStrykerConfig(sourceFiles, options);
+  try {
+    var instance = new Stryker(config);
+    var result = await instance.runMutationTest();
+    return this._normalizeResult(result);
+  } catch (err) {
+    throw new Error('Stryker mutation test failed: ' + err.message);
+  }
+};
+StrykerWrapper.prototype._normalizeResult = function (rawResult) {
+  if (!rawResult) {
+    return this._emptyNormalizedResult();
+  }
+  var mutants = Array.isArray(rawResult) ? rawResult : rawResult.mutants || [];
+  var summary = this._buildSummary(mutants);
+  var fileMap = this._buildFileMap(mutants);
+  return {
+    files: fileMap,
+    schemaVersion: '1',
+    thresholds: {
+      high: 80,
+      low: 60,
+      break: null
+    },
+    projectRoot: process.cwd(),
+    mutants: mutants,
+    summary: summary
+  };
+};
+StrykerWrapper.prototype._buildSummary = function (mutants) {
+  var summary = {
+    totalMutants: mutants.length,
+    killed: 0,
+    survived: 0,
+    timeout: 0,
+    noCoverage: 0,
+    ignored: 0,
+    runtimeErrors: 0,
+    compileErrors: 0,
+    mutationScore: 0
+  };
+  for (var i = 0; i < mutants.length; i++) {
+    var status = (mutants[i].status || '').toLowerCase();
+    if (status === 'killed') summary.killed++;else if (status === 'survived') summary.survived++;else if (status === 'timeout') summary.timeout++;else if (status === 'nocoverage') summary.noCoverage++;else if (status === 'ignored') summary.ignored++;else if (status === 'runtimeerror') summary.runtimeErrors++;else if (status === 'compileerror') summary.compileErrors++;
+  }
+  var detected = summary.killed + summary.timeout;
+  var totalValid = summary.totalMutants - summary.ignored - summary.compileErrors - summary.runtimeErrors;
+  summary.mutationScore = totalValid > 0 ? parseFloat((detected / totalValid * 100).toFixed(2)) : 0;
+  return summary;
+};
+StrykerWrapper.prototype._buildFileMap = function (mutants) {
+  var fileMap = {};
+  for (var i = 0; i < mutants.length; i++) {
+    var mutant = mutants[i];
+    var fileName = mutant.fileName || mutant.sourceFile || 'unknown';
+    if (!fileMap[fileName]) {
+      fileMap[fileName] = [];
+    }
+    fileMap[fileName].push({
+      id: mutant.id,
+      mutatorName: mutant.mutatorName,
+      replacement: mutant.replacement,
+      status: mutant.status,
+      location: mutant.location,
+      killedBy: mutant.killedBy || [],
+      coveredBy: mutant.coveredBy || [],
+      description: mutant.description || ''
+    });
+  }
+  return fileMap;
+};
+StrykerWrapper.prototype._emptyNormalizedResult = function () {
+  return {
+    files: {},
+    schemaVersion: '1',
+    thresholds: {
+      high: 80,
+      low: 60,
+      break: null
+    },
+    projectRoot: process.cwd(),
+    mutants: [],
+    summary: {
+      totalMutants: 0,
+      killed: 0,
+      survived: 0,
+      timeout: 0,
+      noCoverage: 0,
+      ignored: 0,
+      runtimeErrors: 0,
+      compileErrors: 0,
+      mutationScore: 0
+    }
+  };
+};
+StrykerWrapper.prototype.getDefaultConfig = function () {
+  return Object.assign({}, this._defaultOptions);
+};
+module.exports = StrykerWrapper;
+module.exports.DEFAULT_MUTATE_PATTERN = DEFAULT_MUTATE_PATTERN;

package/build/utils/FileAndFolderOperations/filterFiles.js

@@ -3,9 +3,7 @@
 const {
   Logger
 } = require('../Logger/Logger');
-const {
-  existsSync
-} = require("fs");
+const path = require('path');
 /**
  * @function filterFiles - removes certain files from set of source files
  * @param {Array} arrayOfFilesToBeFiltered - array of files which must be filtered 
@@ -20,14 +18,18 @@ function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNee
    * @returns {Array<String>} 
    * */
   function filterFilesByExtension(lintFiles) {
+    const ext = file => path.extname(file).toLowerCase();
     return lintFiles.reduce((files, currentFile) => {
-      if (currentFile.includes('.feature') && existsSync(currentFile)) {
+      //   if (!existsSync(currentFile)) return files;
+
+      const e = ext(currentFile);
+      if (e === '.feature') {
         files.featureFiles.push(currentFile);
       }
-      if (currentFile.includes('.js') || currentFile.includes('.ts') || currentFile.includes('.tsx') || currentFile.includes('.jsx') || currentFile.includes('.properties') && existsSync(currentFile)) {
+      if (['.js', '.ts', '.tsx', '.jsx', '.properties'].includes(e)) {
         files.JsFiles.push(currentFile);
       }
-      if (currentFile.includes('.css') && existsSync(currentFile)) {
+      if (e === '.css') {
         files.CssFiles.push(currentFile);
       }
       return files;

package/build/utils/FileAndFolderOperations/removeFolder.js

@@ -2,7 +2,7 @@
 
 const {
   existsSync,
-  rmSync
+  rm
 } = require('fs');
 const {
   Logger
@@ -20,7 +20,7 @@ function removeFolder(folderPath) {
   try {
     let isCommonConfigFolderPresent = existsSync(folderPath);
     if (isCommonConfigFolderPresent) {
-      executeSynchronizedCommands(rmSync, [folderPath, {
+      executeSynchronizedCommands(rm, [folderPath, {
         recursive: true,
         force: true
       }], 'common linter configuration folder removed successfully', 'Unable to remove the common linter configuration folder', false, false);

package/build/utils/General/Config.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const path = require('path');
+function initConfig(actualConfigPath) {
+  const config = getConfigObject(actualConfigPath);
+  process.env.SONARQUBE_EXTERNAL = config.metric_token;
+  process.env.SONARQUBE = config.meticHandler_api_token;
+  process.env.ZGIT_TOKEN = config.token;
+  process.env.TOOL_TOKEN = config.toolToken;
+}
+function getConfigPathPostInstall() {
+  return path.resolve(process.cwd(), '..', '..', '..');
+}
+function getConfigPathExecute() {
+  return path.resolve(process.cwd());
+}
+function getConfigObject(actualConfigPath) {
+  return require(path.join(actualConfigPath, 'lint.config.js'));
+}
+module.exports = {
+  initConfig,
+  getConfigPathExecute,
+  getConfigPathPostInstall,
+  getConfigObject
+};

package/build/utils/General/SonarQubeUtil.js

@@ -78,7 +78,7 @@ async function fetchProjectIssuesViaCurl(componentKey) {
   _Logger.Logger.log(_Logger.Logger.INFO_TYPE, `\n Fetching issues (curl) for component: ${componentKey}`);
   const url = buildIssuesSearchUrl(componentKey);
   try {
-    const token = process.env.SONARQUBE; //'sqa_1f6675c05f63c4784dc741ce751efa0066d2693c' || decrypt(getAPIToken(), ); // sonarqube
+    const token = process.env.SONARQUBE;
     const command = `curl --tlsv1.2 -s -u "${token}:" "${url}"`;
     const output = execSync(command).toString();
     const json = JSON.parse(output.toString());

package/jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   testEnvironment: 'node',
   clearMocks: true,
-  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js']
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "1.1.4",
+  "version": "1.2.4-exp-2",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {
@@ -18,7 +18,10 @@
   "dependencies": {
     "@zohodesk-private/client_deployment_tool": "0.0.5",
     "@zohodesk/codestandard-analytics": "1.1.4-exp-2",
+    "@stryker-mutator/core": "5.0.0",
     "eslint": "8.26.0",
+    "marked": "9.1.6",
+    "marked-terminal": "6.2.0",
     "stylelint": "16.23.0"
   },
   "devDependencies": {

package/samples/sample-branch-mode.js

@@ -0,0 +1,34 @@
+// Usage: node samples/sample-branch-mode.js
+
+var MutationCli = require('../src/mutation').MutationCli;
+
+var cli = new MutationCli({ cwd: process.cwd() });
+
+console.log('Running mutation testing in branch diff mode...');
+console.log('Diffing current branch against: main');
+console.log('');
+
+cli.execute(['mutate', '--branch=main']).then(function (result) {
+  if (result.success) {
+    console.log('=== SUCCESS ===');
+    console.log('Report file:  ', result.filePath);
+    console.log('Score:        ', result.report.summary.mutationScore + '%');
+    console.log('Total:        ', result.report.summary.totalMutants);
+    console.log('Killed:       ', result.report.summary.killed);
+    console.log('Survived:     ', result.report.summary.survived);
+    console.log('No Coverage:  ', result.report.summary.noCoverage);
+    if (result.message) {
+      console.log('Note:         ', result.message);
+    }
+    console.log('');
+    console.log('File pairs tested:');
+    result.report.filePairs.forEach(function (pair) {
+      console.log('  Source: ' + pair.source + ' -> Test: ' + (pair.test || 'NONE'));
+    });
+  } else {
+    console.error('=== FAILED ===');
+    console.error('Error:', result.error);
+  }
+}).catch(function (err) {
+  console.error('Unexpected error:', err);
+});

package/samples/sample-cli-entry.js

@@ -0,0 +1,34 @@
+// Usage: node samples/sample-cli-entry.js
+// Tests CLI argument parsing and validation only (no Stryker run)
+
+var MutationCli = require('../src/mutation').MutationCli;
+
+var testCases = [
+  { name: 'Directory mode', args: ['mutate', '--src=src', '--test=test'] },
+  { name: 'Branch mode', args: ['mutate', '--branch=main'] },
+  { name: 'Missing args (should fail)', args: ['mutate'] },
+  { name: 'Both modes (should fail)', args: ['mutate', '--branch=main', '--src=src', '--test=test'] },
+  { name: 'Unknown command (should fail)', args: ['lint'] },
+  { name: 'With optional flags', args: ['mutate', '--src=src', '--test=test', '--outputDir=custom-reports', '--logLevel=debug'] },
+  { name: 'Branch with useApi', args: ['mutate', '--branch=develop', '--useApi'] },
+];
+
+var cli = new MutationCli({ cwd: process.cwd() });
+
+console.log('=== CLI Argument Parsing Tests ===');
+console.log('');
+
+testCases.forEach(function (tc) {
+  console.log('Test: ' + tc.name);
+  console.log('  Args: ' + tc.args.join(' '));
+
+  var parsed = cli.parseArgs(tc.args);
+  console.log('  Parsed:', JSON.stringify(parsed));
+
+  var validation = cli.validate(parsed);
+  console.log('  Valid:', validation.valid);
+  if (!validation.valid) {
+    console.log('  Error:', validation.error.split('\n')[0]);
+  }
+  console.log('');
+});

package/samples/sample-components.js

@@ -0,0 +1,63 @@
+// Usage: node samples/sample-components.js
+
+var mutation = require('../src/mutation');
+
+console.log('=== 1. Testing BranchDiff ===');
+var branchDiff = new mutation.BranchDiff({ cwd: process.cwd() });
+
+branchDiff.getChangedFiles('main').then(function (changed) {
+  console.log('Source files changed:', changed.sourceFiles);
+  console.log('Test files changed:', changed.testFiles);
+  console.log('');
+
+  console.log('=== 2. Testing FileResolver ===');
+  var resolver = new mutation.FileResolver({ cwd: process.cwd() });
+  var pairs = resolver.resolveSourceTestPairs(changed.sourceFiles, changed.testFiles);
+  console.log('Resolved pairs:');
+  pairs.forEach(function (pair) {
+    console.log('  ' + pair.source + ' -> ' + (pair.test || 'NO TEST'));
+  });
+  console.log('');
+
+  console.log('=== 3. Testing StrykerWrapper config ===');
+  var stryker = new mutation.StrykerWrapper({
+    reportPath: 'reports/mutation/sample-report.json',
+  });
+  var config = stryker.getDefaultConfig();
+  console.log('Default config:');
+  console.log('  testRunner:', config.testRunner);
+  console.log('  coverageAnalysis:', config.coverageAnalysis);
+  console.log('');
+
+  console.log('=== 4. Testing ReportGenerator ===');
+  var reporter = new mutation.ReportGenerator({
+    cwd: process.cwd(),
+    outputDir: 'reports/mutation',
+    outputFileName: 'sample-component-report.json',
+  });
+
+  var fakeResult = {
+    summary: {
+      totalMutants: 5, killed: 3, survived: 1, timeout: 0,
+      noCoverage: 1, ignored: 0, runtimeErrors: 0, compileErrors: 0,
+      mutationScore: 60,
+    },
+    files: {},
+    mutants: [
+      { id: '1', status: 'Killed', fileName: 'src/app.js', mutatorName: 'StringLiteral' },
+      { id: '2', status: 'Survived', fileName: 'src/app.js', mutatorName: 'BooleanLiteral' },
+    ],
+  };
+
+  var output = reporter.generateAndWrite(fakeResult, {
+    command: 'sample-components test',
+    branch: 'main',
+    filePairs: pairs,
+  });
+  console.log('Report written to:', output.filePath);
+  console.log('Report summary:', output.report.summary);
+  console.log('');
+  console.log('=== All component tests complete ===');
+}).catch(function (err) {
+  console.error('Error:', err.message);
+});

package/samples/sample-directory-mode.js

@@ -0,0 +1,30 @@
+// Usage: node samples/sample-directory-mode.js
+
+var MutationCli = require('../src/mutation').MutationCli;
+
+var cli = new MutationCli({ cwd: process.cwd() });
+
+console.log('Running mutation testing in directory mode...');
+console.log('Source dir: src');
+console.log('Test dir:   test');
+console.log('');
+
+cli.execute(['mutate', '--src=src', '--test=test']).then(function (result) {
+  if (result.success) {
+    console.log('=== SUCCESS ===');
+    console.log('Report file:  ', result.filePath);
+    console.log('Score:        ', result.report.summary.mutationScore + '%');
+    console.log('Total:        ', result.report.summary.totalMutants);
+    console.log('Killed:       ', result.report.summary.killed);
+    console.log('Survived:     ', result.report.summary.survived);
+    console.log('No Coverage:  ', result.report.summary.noCoverage);
+    if (result.message) {
+      console.log('Note:         ', result.message);
+    }
+  } else {
+    console.error('=== FAILED ===');
+    console.error('Error:', result.error);
+  }
+}).catch(function (err) {
+  console.error('Unexpected error:', err);
+});

package/samples/sample-runner-direct.js

@@ -0,0 +1,32 @@
+// Usage: node samples/sample-runner-direct.js
+
+var MutationRunner = require('../src/mutation').MutationRunner;
+
+var runner = new MutationRunner({
+  cwd: process.cwd(),
+  outputDir: 'reports/mutation',
+  outputFileName: 'direct-runner-report.json',
+});
+
+console.log('=== Testing runByBranch ===');
+runner.runByBranch('main').then(function (result) {
+  console.log('Branch mode result:');
+  console.log('  Report:', result.filePath);
+  console.log('  Score:', result.report.summary.mutationScore + '%');
+  if (result.message) {
+    console.log('  Note:', result.message);
+  }
+
+  console.log('');
+  console.log('=== Testing runByDirectory ===');
+  return runner.runByDirectory('src', 'test');
+}).then(function (result) {
+  console.log('Directory mode result:');
+  console.log('  Report:', result.filePath);
+  console.log('  Score:', result.report.summary.mutationScore + '%');
+  if (result.message) {
+    console.log('  Note:', result.message);
+  }
+}).catch(function (err) {
+  console.error('Error:', err.message);
+});

package/samples/sample-with-api.js

@@ -0,0 +1,44 @@
+// Usage: PAT_TOKEN=your_token node samples/sample-with-api.js
+
+var MutationCli = require('../src/mutation').MutationCli;
+
+var myApi = {
+  getChangedFiles: function (targetBranch, patToken) {
+    console.log('API called with branch:', targetBranch);
+    console.log('PAT token provided:', patToken ? 'yes' : 'no');
+    return Promise.resolve([
+      'src/services/auth.js',
+      'src/services/auth.test.js',
+      'src/utils/format.js',
+      'src/utils/format.test.js',
+      'src/config.js',
+    ]);
+  },
+};
+
+var cli = new MutationCli({
+  cwd: process.cwd(),
+  api: myApi,
+  patToken: process.env.PAT_TOKEN || 'mock-token',
+});
+
+console.log('Running mutation testing with API-based branch diff...');
+console.log('');
+
+cli.execute(['mutate', '--branch=main', '--useApi']).then(function (result) {
+  if (result.success) {
+    console.log('=== SUCCESS ===');
+    console.log('Report:', result.filePath);
+    console.log('Score:', result.report.summary.mutationScore + '%');
+    console.log('');
+    console.log('File pairs:');
+    result.report.filePairs.forEach(function (pair) {
+      console.log('  ' + pair.source + ' -> ' + (pair.test || 'NO TEST'));
+    });
+  } else {
+    console.error('=== FAILED ===');
+    console.error('Error:', result.error);
+  }
+}).catch(function (err) {
+  console.error('Unexpected error:', err);
+});