@zohodesk/codestandard-validator 1.2.4-exp-1 → 1.2.4-exp-3

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;

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;