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

package/build/mutation/branchDiff.js

@@ -0,0 +1,178 @@
+"use strict";
+
+const {
+  execSync
+} = require('child_process');
+const path = require('path');
+class BranchDiff {
+  constructor(options = {}) {
+    this._cwd = options.cwd || process.cwd();
+    this._api = options.api || null;
+    this._patToken = options.patToken || null;
+    this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+    this._testPattern = options.testPattern || /\.(test)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+  }
+  _getCurrentBranch() {
+    try {
+      return execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      }).trim();
+    } catch (err) {
+      throw new Error(`Failed to get current branch: ${err.message}`);
+    }
+  }
+  _fetchBranch(branch) {
+    try {
+      execSync(`git fetch origin ${branch}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      });
+    } catch (err) {
+      // Branch might already be available locally
+    }
+  }
+  _resolveBranchRef(branch) {
+    // Check if the ref exists locally
+    const candidates = [branch, `origin/${branch}`];
+    for (const ref of candidates) {
+      try {
+        execSync(`git rev-parse --verify ${ref}`, {
+          cwd: this._cwd,
+          encoding: 'utf-8',
+          stdio: 'pipe'
+        });
+        return ref;
+      } catch {
+        // try next
+      }
+    }
+    throw new Error(`Branch '${branch}' not found locally or as 'origin/${branch}'. ` + `Run 'git fetch origin ${branch}' or check the branch name.`);
+  }
+  _getDiffFiles(targetBranch) {
+    const currentBranch = this._getCurrentBranch();
+    this._fetchBranch(targetBranch);
+    const resolvedRef = this._resolveBranchRef(targetBranch);
+    let diffRef;
+    try {
+      const mergeBase = execSync(`git merge-base ${resolvedRef} ${currentBranch}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      }).trim();
+      diffRef = mergeBase;
+    } catch {
+      diffRef = resolvedRef;
+    }
+    try {
+      const output = execSync(`git diff --name-only --diff-filter=ACMR ${diffRef}`, {
+        cwd: this._cwd,
+        encoding: 'utf-8'
+      });
+      return output.split('\n').map(f => f.trim()).filter(f => f.length > 0);
+    } catch (err) {
+      throw new Error(`Failed to get diff files against branch '${targetBranch}': ${err.message}`);
+    }
+  }
+  _getDiffFilesFromApi(targetBranch) {
+    if (!this._api || !this._patToken) {
+      throw new Error('API and PAT token are required for API-based diff');
+    }
+    // Placeholder for API-based diff (e.g., Azure DevOps, GitHub, etc.)
+    // Consumers can pass in their own api object that implements `getChangedFiles(targetBranch, patToken)`
+    if (typeof this._api.getChangedFiles === 'function') {
+      return this._api.getChangedFiles(targetBranch, this._patToken);
+    }
+    throw new Error('API object must implement getChangedFiles(targetBranch, patToken)');
+  }
+
+  /**
+   * Fetches branch diff from GitLab compare API via HTTPS
+   * @param {string} hostname - GitLab host (e.g. 'gitlab.example.com')
+   * @param {string} branch - Target branch to compare against
+   * @returns {Promise<string[]>} - Array of changed file paths
+   */
+  _fetchBranchDiffFromApi(hostname, branch, projectId) {
+    const currentBranch = this._getCurrentBranch();
+    const patToken = this._patToken || process.env.ZGIT_TOKEN;
+    if (!patToken) {
+      return reject(new Error('PAT token is required. Set it via options.patToken or ZGIT_TOKEN env var'));
+    }
+    if (!projectId) {
+      return reject(new Error('GitLab projectId is required for API-based diff'));
+    }
+    const createBranchDiffChunk = (resolve, reject) => {
+      // code duplicate need find solution
+      var command;
+      const endPoint = `${hostname}/api/v4/projects/${encodeURIComponent(projectId)}/repository/compare?from=${branch}&to=${currentBranch}`;
+      try {
+        command = `curl --header "PRIVATE-TOKEN:${patToken}" "${endPoint}"`;
+        return resolve(parserReleaseDiffRemoteAPI(JSON.parse(execSync(command, {
+          cwd: this._cwd
+        }))));
+      } catch (error) {
+        Logger.log(error);
+        Logger.log(`\n INFO : If you are using a VPN and encounter an SSL certification issue, ensure that the proxy is enabled for SSH and shell connections.`);
+        Logger.log(`\n Make sure that you have access to this repository`);
+        reject(error);
+      }
+    };
+    function parserReleaseDiffRemoteAPI(rawresponse) {
+      var formatted = [];
+      if (rawresponse !== null && rawresponse !== void 0 && rawresponse.diffs) {
+        formatted = rawresponse.diffs.map(changeset => {
+          return changeset === null || changeset === void 0 ? void 0 : changeset.new_path;
+        }).filter(Boolean);
+      }
+      return formatted;
+    }
+    return new Promise((resolve, reject) => {
+      return createBranchDiffChunk(resolve, reject);
+    });
+  }
+  async getStagedFiles() {
+    try {
+      const stdout = await execSync("git diff --staged --name-only").toString();
+      const files = stdout.trim().split("\n").filter(Boolean);
+      return files;
+    } catch (error) {
+      console.log(error);
+      throw new Error("Couldn't fetch staged files");
+    }
+  }
+  async getChangedFiles(targetBranch, options = {}) {
+    let allFiles;
+    if (options.useApi && options.hostname && options.projectId) {
+      allFiles = await this._fetchBranchDiffFromApi(options.hostname, targetBranch, options.projectId).concat(await this.getStagedFiles());
+    } else {
+      allFiles = this._getDiffFiles(targetBranch);
+    }
+    return this._categorizeFiles(allFiles);
+  }
+  _isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    if (!this._sourceExtensions.includes(ext)) {
+      return false;
+    }
+    return !this._testPattern.test(filePath);
+  }
+  _isTestFile(filePath) {
+    return this._testPattern.test(filePath);
+  }
+  _categorizeFiles(files) {
+    const sourceFiles = [];
+    const testFiles = [];
+    for (const file of files) {
+      if (this._isTestFile(file)) {
+        testFiles.push(file);
+      } else if (this._isSourceFile(file)) {
+        sourceFiles.push(file);
+      }
+    }
+    return {
+      sourceFiles,
+      testFiles
+    };
+  }
+}
+module.exports = BranchDiff;

package/build/mutation/fileResolver.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+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;
+      }
+    }
+
+    // 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 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;
+            }
+          }
+        }
+      }
+    }
+    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;
+      }
+    }
+
+    // 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 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 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;
+            }
+          }
+        }
+      }
+    }
+    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);
+      }
+    }
+
+    // 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);
+    }
+    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
+      });
+      return files;
+    } catch (err) {
+      throw new Error(`Failed to collect files from '${directory}': ${err.message}`);
+    }
+  }
+  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;
+  }
+}
+module.exports = FileResolver;

package/build/mutation/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const MutationRunner = require('./mutationRunner');
+const MutationCli = require('./mutationCli');
+const StrykerWrapper = require('./strykerWrapper');
+const BranchDiff = require('./branchDiff');
+const FileResolver = require('./fileResolver');
+const ReportGenerator = require('./reportGenerator');
+module.exports = {
+  MutationRunner,
+  MutationCli,
+  StrykerWrapper,
+  BranchDiff,
+  FileResolver,
+  ReportGenerator
+};

package/build/mutation/mutatePattern.json

@@ -0,0 +1,3 @@
+{
+  "defaultPattern": "src/**/*.js"
+}

package/build/mutation/mutationCli.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const MutationRunner = require('./mutationRunner');
+class MutationCli {
+  constructor(options = {}) {
+    this._options = options;
+  }
+  parseArgs(args) {
+    const parsed = {
+      command: null,
+      branch: null,
+      src: null,
+      test: null,
+      useApi: false,
+      outputDir: null,
+      outputFileName: null,
+      logLevel: 'info',
+      hostname: null
+    };
+    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.'
+      };
+    }
+    return {
+      valid: true
+    };
+  }
+  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
+    });
+    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
+      };
+    }
+  }
+}
+module.exports = MutationCli;

package/build/mutation/mutationRunner.js

@@ -0,0 +1,208 @@
+"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>');
+    }
+
+    // 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: []
+      });
+      return {
+        report,
+        filePath,
+        message: 'No changed source or test files found in branch diff.'
+      };
+    }
+
+    // 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.'
+      };
+    }
+
+    // Step 3: Run Stryker mutation testing
+    const mutationResult = await this._stryker.run(sourcesToMutate, {
+      testFiles: testsToRun,
+      jest: {
+        ...this._jestConfig,
+        enableFindRelatedTests: true
+      }
+    });
+
+    // 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>');
+    }
+
+    // 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.'
+      };
+    }
+
+    // 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
+      };
+    }
+
+    // Step 3: Run Stryker mutation testing
+    const mutationResult = await this._stryker.run(sourcesToMutate, {
+      testFiles: testsToRun,
+      jest: {
+        ...this._jestConfig,
+        enableFindRelatedTests: true
+      }
+    });
+
+    // Step 4: Generate report
+    const {
+      report,
+      filePath
+    } = this._reportGenerator.generateAndWrite(mutationResult, {
+      command: `mutate --src=${srcDir} --test=${testDir}`,
+      srcDir,
+      testDir,
+      filePairs: pairs
+    });
+    return {
+      report,
+      filePath
+    };
+  }
+  _buildEmptyResult() {
+    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;