jest-test-lineage-reporter 2.0.1 → 2.1.0

package/src/babel-plugin-mutation-tester.js

@@ -0,0 +1,402 @@
+/**
+ * Babel Plugin for Mutation Testing
+ * Creates targeted mutations for specific lines based on lineage tracking data
+ */
+
+/**
+ * Creates a mutation testing plugin that targets a specific line and mutation type
+ * @param {number} targetLine - Line number to mutate
+ * @param {string} mutationType - Type of mutation to apply
+ * @param {Object} config - Mutation configuration
+ */
+function createMutationPlugin(targetLine, mutationType, config = {}) {
+  return function({ types: t }, options = {}) {
+    return {
+      name: 'mutation-tester',
+      visitor: {
+        Program: {
+          enter(path, state) {
+            state.filename = state.file.opts.filename;
+            state.shouldMutate = false;
+            state.mutationApplied = false;
+            state.targetLine = targetLine;
+            state.mutationType = mutationType;
+            state.config = { ...config, ...options };
+          }
+        },
+
+        // ARITHMETIC OPERATORS: +, -, *, /, %
+        BinaryExpression(path, state) {
+          if (!shouldApplyMutation(path, state, 'arithmetic')) return;
+
+          const operator = path.node.operator;
+          const mutations = {
+            '+': '-',   // Addition to Subtraction
+            '-': '+',   // Subtraction to Addition  
+            '*': '/',   // Multiplication to Division
+            '/': '*',   // Division to Multiplication
+            '%': '*',   // Modulo to Multiplication
+            '==': '!=', // Equality to Inequality
+            '!=': '==', // Inequality to Equality
+            '===': '!==', // Strict equality to strict inequality
+            '!==': '===', // Strict inequality to strict equality
+            '<': '>=',  // Less than to Greater/Equal
+            '>': '<=',  // Greater than to Less/Equal
+            '<=': '>',  // Less/Equal to Greater
+            '>=': '<'   // Greater/Equal to Less
+          };
+
+          if (mutations[operator]) {
+            path.node.operator = mutations[operator];
+            state.mutationApplied = true;
+            logMutation(state, `${operator} → ${mutations[operator]}`);
+          }
+        },
+
+        // LOGICAL OPERATORS: &&, ||
+        LogicalExpression(path, state) {
+          if (!shouldApplyMutation(path, state, 'logical')) return;
+
+          const operator = path.node.operator;
+          const mutations = {
+            '&&': '||',  // AND to OR
+            '||': '&&'   // OR to AND
+          };
+
+          if (mutations[operator]) {
+            path.node.operator = mutations[operator];
+            state.mutationApplied = true;
+            logMutation(state, `${operator} → ${mutations[operator]}`);
+          }
+        },
+
+        // UNARY OPERATORS: !, ++, --
+        UnaryExpression(path, state) {
+          if (!shouldApplyMutation(path, state, 'logical')) return;
+
+          if (path.node.operator === '!') {
+            // Remove negation: !condition → condition
+            path.replaceWith(path.node.argument);
+            state.mutationApplied = true;
+            logMutation(state, '! → (removed)');
+          }
+        },
+
+        // UPDATE EXPRESSIONS: ++, --
+        UpdateExpression(path, state) {
+          if (!shouldApplyMutation(path, state, 'increments')) return;
+
+          const operator = path.node.operator;
+          const mutations = {
+            '++': '--',  // Increment to Decrement
+            '--': '++'   // Decrement to Increment
+          };
+
+          if (mutations[operator]) {
+            path.node.operator = mutations[operator];
+            state.mutationApplied = true;
+            logMutation(state, `${operator} → ${mutations[operator]}`);
+          }
+        },
+
+        // ASSIGNMENT OPERATORS: =, +=, -=, etc.
+        AssignmentExpression(path, state) {
+          if (!shouldApplyMutation(path, state, 'assignment')) return;
+
+          const operator = path.node.operator;
+          const mutations = {
+            '+=': '-=',  // Add-assign to Subtract-assign
+            '-=': '+=',  // Subtract-assign to Add-assign
+            '*=': '/=',  // Multiply-assign to Divide-assign
+            '/=': '*=',  // Divide-assign to Multiply-assign
+            '%=': '*='   // Modulo-assign to Multiply-assign
+          };
+
+          if (mutations[operator]) {
+            path.node.operator = mutations[operator];
+            state.mutationApplied = true;
+            logMutation(state, `${operator} → ${mutations[operator]}`);
+          }
+        },
+
+        // CONDITIONAL STATEMENTS: if, while, for
+        IfStatement(path, state) {
+          if (!shouldApplyMutation(path, state, 'conditional')) return;
+
+          // Negate condition: if (x > 0) → if (!(x > 0))
+          const { types: t } = require('@babel/core');
+          path.node.test = t.unaryExpression('!', t.parenthesizedExpression(path.node.test));
+          state.mutationApplied = true;
+          logMutation(state, 'if condition → !(condition)');
+        },
+
+        // WHILE LOOPS
+        WhileStatement(path, state) {
+          if (!shouldApplyMutation(path, state, 'conditional')) return;
+
+          const { types: t } = require('@babel/core');
+          path.node.test = t.unaryExpression('!', t.parenthesizedExpression(path.node.test));
+          state.mutationApplied = true;
+          logMutation(state, 'while condition → !(condition)');
+        },
+
+        // FOR LOOPS
+        ForStatement(path, state) {
+          if (!shouldApplyMutation(path, state, 'conditional')) return;
+
+          // Only mutate if there's a test condition
+          if (path.node.test) {
+            const { types: t } = require('@babel/core');
+            path.node.test = t.unaryExpression('!', t.parenthesizedExpression(path.node.test));
+            state.mutationApplied = true;
+            logMutation(state, 'for condition → !(condition)');
+          }
+        },
+
+        // RETURN STATEMENTS
+        ReturnStatement(path, state) {
+          if (!shouldApplyMutation(path, state, 'returns')) return;
+
+          const { types: t } = require('@babel/core');
+
+          if (path.node.argument) {
+            // Apply type-safe mutations based on the argument type
+            if (t.isNumericLiteral(path.node.argument)) {
+              // For numbers, change to 0 instead of null to avoid type errors
+              const originalValue = path.node.argument.value;
+              const newValue = originalValue === 0 ? 1 : 0;
+              path.node.argument = t.numericLiteral(newValue);
+              state.mutationApplied = true;
+              logMutation(state, `return ${originalValue} → return ${newValue}`);
+            } else if (t.isBooleanLiteral(path.node.argument)) {
+              // For booleans, flip the value
+              const originalValue = path.node.argument.value;
+              path.node.argument = t.booleanLiteral(!originalValue);
+              state.mutationApplied = true;
+              logMutation(state, `return ${originalValue} → return ${!originalValue}`);
+            } else if (t.isStringLiteral(path.node.argument)) {
+              // For strings, change to empty string
+              const originalValue = path.node.argument.value;
+              path.node.argument = t.stringLiteral("");
+              state.mutationApplied = true;
+              logMutation(state, `return "${originalValue}" → return ""`);
+            } else if (t.isBinaryExpression(path.node.argument)) {
+              // For binary expressions like a + b, try to mutate the operator or operands
+              const expr = path.node.argument;
+              if (expr.operator === '+') {
+                // Change + to - for arithmetic expressions
+                expr.operator = '-';
+                state.mutationApplied = true;
+                logMutation(state, `return a + b → return a - b`);
+              } else if (expr.operator === '-') {
+                // Change - to + for arithmetic expressions
+                expr.operator = '+';
+                state.mutationApplied = true;
+                logMutation(state, `return a - b → return a + b`);
+              } else if (expr.operator === '*') {
+                // Change * to / for arithmetic expressions
+                expr.operator = '/';
+                state.mutationApplied = true;
+                logMutation(state, `return a * b → return a / b`);
+              } else if (expr.operator === '/') {
+                // Change / to * for arithmetic expressions
+                expr.operator = '*';
+                state.mutationApplied = true;
+                logMutation(state, `return a / b → return a * b`);
+              } else {
+                // For other binary expressions, skip to avoid breaking module loading
+                logMutation(state, `return expression → skipped (complex binary expression)`);
+              }
+            } else {
+              // For other complex expressions, skip mutation to avoid breaking module loading
+              // This is more conservative but safer
+              logMutation(state, `return expression → skipped (complex expression)`);
+            }
+          }
+        },
+
+        // LITERAL VALUES: numbers, booleans, strings
+        Literal(path, state) {
+          if (!shouldApplyMutation(path, state, 'literals')) return;
+
+          const value = path.node.value;
+
+          if (typeof value === 'number') {
+            // Mutate numbers: 5 → 0, 0 → 1, negative → positive
+            const newValue = value === 0 ? 1 : (value > 0 ? 0 : Math.abs(value));
+            path.node.value = newValue;
+            state.mutationApplied = true;
+            logMutation(state, `${value} → ${newValue}`);
+          } else if (typeof value === 'boolean') {
+            // Flip booleans: true → false, false → true
+            path.node.value = !value;
+            state.mutationApplied = true;
+            logMutation(state, `${value} → ${!value}`);
+          } else if (typeof value === 'string' && value.length > 0) {
+            // Empty strings: "hello" → ""
+            path.node.value = "";
+            state.mutationApplied = true;
+            logMutation(state, `"${value}" → ""`);
+          }
+        },
+
+        // NUMERIC LITERALS (for newer Babel versions)
+        NumericLiteral(path, state) {
+          if (!shouldApplyMutation(path, state, 'literals')) return;
+
+          const value = path.node.value;
+          const newValue = value === 0 ? 1 : (value > 0 ? 0 : Math.abs(value));
+          path.node.value = newValue;
+          state.mutationApplied = true;
+          logMutation(state, `${value} → ${newValue}`);
+        },
+
+        // BOOLEAN LITERALS
+        BooleanLiteral(path, state) {
+          if (!shouldApplyMutation(path, state, 'literals')) return;
+
+          const value = path.node.value;
+          path.node.value = !value;
+          state.mutationApplied = true;
+          logMutation(state, `${value} → ${!value}`);
+        },
+
+        // STRING LITERALS
+        StringLiteral(path, state) {
+          if (!shouldApplyMutation(path, state, 'literals')) return;
+
+          const value = path.node.value;
+          if (value.length > 0) {
+            path.node.value = "";
+            state.mutationApplied = true;
+            logMutation(state, `"${value}" → ""`);
+          }
+        }
+      }
+    };
+  };
+}
+
+/**
+ * Determines if a mutation should be applied to the current node
+ */
+function shouldApplyMutation(path, state, operatorType) {
+  const lineNumber = path.node.loc?.start.line;
+  
+  // Check if this is the target line
+  if (lineNumber !== state.targetLine) {
+    return false;
+  }
+
+  // Check if this operator type is enabled
+  if (state.config.mutationOperators && !state.config.mutationOperators[operatorType]) {
+    return false;
+  }
+
+  // Check if we've already applied a mutation (one per line)
+  if (state.mutationApplied) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Logs mutation information
+ */
+function logMutation(state, description) {
+  if (state.config.enableDebugLogging) {
+    console.log(`🧬 Mutation applied at ${state.filename}:${state.targetLine} - ${description}`);
+  }
+}
+
+/**
+ * Gets all possible mutations for a given line of code by analyzing the AST
+ */
+function getPossibleMutations(filePath, lineNumber, sourceCode) {
+  try {
+    const babel = require('@babel/core');
+    const fs = require('fs');
+
+    // Read the full file content
+    const fullFileContent = fs.readFileSync(filePath, 'utf8');
+    const lines = fullFileContent.split('\n');
+    const targetLine = lines[lineNumber - 1];
+
+    if (!targetLine) return [];
+
+    const possibleMutations = [];
+
+    // Parse the entire file to get proper AST context
+    const ast = babel.parseSync(fullFileContent, {
+      filename: filePath,
+      parserOpts: {
+        sourceType: "module",
+        allowImportExportEverywhere: true,
+        plugins: ["typescript", "jsx"],
+      },
+    });
+
+    // Traverse the AST to find nodes on the target line
+    babel.traverse(ast, {
+      enter(path) {
+        const nodeLineNumber = path.node.loc?.start.line;
+        if (nodeLineNumber !== lineNumber) return;
+
+        // Check what types of mutations are possible based on the AST nodes
+        if (path.isBinaryExpression()) {
+          const operator = path.node.operator;
+          if (['+', '-', '*', '/', '%'].includes(operator)) {
+            possibleMutations.push('arithmetic');
+          }
+          if (['==', '!=', '===', '!==', '<', '>', '<=', '>='].includes(operator)) {
+            possibleMutations.push('comparison');
+          }
+        }
+
+        if (path.isLogicalExpression()) {
+          possibleMutations.push('logical');
+        }
+
+        if (path.isUnaryExpression() && path.node.operator === '!') {
+          possibleMutations.push('logical');
+        }
+
+        if (path.isUpdateExpression()) {
+          possibleMutations.push('increments');
+        }
+
+        if (path.isAssignmentExpression() && path.node.operator !== '=') {
+          possibleMutations.push('assignment');
+        }
+
+        // Only add conditional mutations for actual conditional statements
+        if (path.isIfStatement() || path.isWhileStatement() ||
+            (path.isForStatement() && path.node.test)) {
+          possibleMutations.push('conditional');
+        }
+
+        if (path.isReturnStatement()) {
+          possibleMutations.push('returns');
+        }
+
+        if (path.isLiteral() || path.isNumericLiteral() ||
+            path.isBooleanLiteral() || path.isStringLiteral()) {
+          possibleMutations.push('literals');
+        }
+      }
+    });
+
+    // Remove duplicates
+    return [...new Set(possibleMutations)];
+
+  } catch (error) {
+    // If AST analysis fails, return empty array to skip this line
+    return [];
+  }
+}
+
+module.exports = {
+  createMutationPlugin,
+  getPossibleMutations
+};

package/src/calculator.ts

@@ -0,0 +1,12 @@
+export function add(a: number, b: number): number {
+  return a - b;
+}
+export function subtract(a: number, b: number): number {
+  if (!(!!(a < b))) {
+    return b - a;
+  }
+  return a - b;
+}
+export function multiply(a: number, b: number): number {
+  return a * b;
+}

package/src/cli/commands/analyze.js

@@ -0,0 +1,91 @@
+/**
+ * Analyze Command
+ * Full workflow: test + mutation + report
+ */
+
+const testCommand = require('./test');
+const mutateCommand = require('./mutate');
+const reportCommand = require('./report');
+const { lineageDataExists } = require('../utils/data-loader');
+const { section, success, error, info } = require('../utils/output-formatter');
+const chalk = require('chalk');
+
+async function analyzeCommand(options) {
+  try {
+    section('🚀 Full Analysis Workflow');
+
+    // Step 1: Run tests (unless skip-tests is specified)
+    if (!options.skipTests) {
+      info('Step 1: Running tests with lineage tracking...\n');
+
+      try {
+        await testCommand([], {
+          lineage: options.lineage !== false,
+          performance: options.performance !== false,
+          quality: options.quality !== false,
+          config: options.config,
+          quiet: false
+        });
+      } catch (err) {
+        // testCommand handles its own exit, this catch is for safety
+        error('Tests failed. Analysis stopped.');
+        process.exit(1);
+      }
+    } else {
+      // Verify lineage data exists
+      if (!lineageDataExists()) {
+        error('Lineage data not found. Remove --skip-tests or run jest-lineage test first.');
+        process.exit(1);
+      }
+      info('Step 1: Skipped (using existing lineage data)\n');
+    }
+
+    // Step 2: Run mutation testing (unless skip-mutation is specified)
+    if (!options.skipMutation) {
+      console.log(); // Add spacing
+      info('Step 2: Running mutation testing...\n');
+
+      try {
+        await mutateCommand({
+          data: '.jest-lineage-data.json',
+          threshold: options.threshold,
+          timeout: options.timeout || '5000',
+          verbose: false
+        });
+      } catch (err) {
+        // Don't fail the entire workflow if mutation testing fails
+        error('Mutation testing failed, but continuing with report generation...');
+      }
+    } else {
+      info('Step 2: Skipped mutation testing\n');
+    }
+
+    // Step 3: Generate report
+    console.log(); // Add spacing
+    info('Step 3: Generating HTML report...\n');
+
+    await reportCommand({
+      data: '.jest-lineage-data.json',
+      output: options.output,
+      open: options.open
+    });
+
+    // Success summary
+    console.log();
+    section('✨ Analysis Complete');
+    success('Full analysis workflow completed successfully!');
+    console.log(chalk.gray(`\nGenerated files:`));
+    console.log(chalk.gray(`  • .jest-lineage-data.json (lineage data)`));
+    console.log(chalk.gray(`  • ${options.output} (HTML report)`));
+
+    process.exit(0);
+  } catch (err) {
+    error(`Analysis workflow failed: ${err.message}`);
+    if (process.env.JEST_LINEAGE_DEBUG === 'true') {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = analyzeCommand;

package/src/cli/commands/mutate.js

@@ -0,0 +1,89 @@
+/**
+ * Mutate Command
+ * Run mutation testing on existing lineage data
+ */
+
+const MutationTester = require('../../MutationTester');
+const { loadLineageData, processLineageDataForMutation } = require('../utils/data-loader');
+const { loadFullConfig } = require('../utils/config-loader');
+const { spinner, printMutationSummary, error, success, info, printLineageDataSummary } = require('../utils/output-formatter');
+const chalk = require('chalk');
+
+async function mutateCommand(options) {
+  let mutationTester = null;
+
+  try {
+    // Load configuration
+    const config = loadFullConfig(options);
+
+    // Load lineage data
+    info(`Loading lineage data from: ${chalk.yellow(options.data)}`);
+    const rawData = loadLineageData(options.data);
+
+    if (!options.verbose) {
+      printLineageDataSummary(rawData);
+    }
+
+    // Process data for mutation testing
+    const lineageData = processLineageDataForMutation(rawData);
+    const fileCount = Object.keys(lineageData).length;
+    const lineCount = Object.values(lineageData).reduce(
+      (sum, lines) => sum + Object.keys(lines).length,
+      0
+    );
+
+    if (fileCount === 0 || lineCount === 0) {
+      error('No coverage data found in lineage file. Run tests first.');
+      process.exit(1);
+    }
+
+    info(`Processing ${chalk.cyan(fileCount)} files with ${chalk.cyan(lineCount)} covered lines\n`);
+
+    // Create mutation tester
+    mutationTester = new MutationTester(config);
+    mutationTester.setLineageData(lineageData);
+
+    // Run mutation testing
+    const spin = spinner('Running mutation testing...');
+    if (!options.verbose) {
+      spin.start();
+    }
+
+    const results = await mutationTester.runMutationTesting();
+
+    if (!options.verbose) {
+      spin.succeed('Mutation testing completed!');
+    }
+
+    // Print results
+    printMutationSummary(results);
+
+    // Check threshold
+    const threshold = parseInt(options.threshold) || 80;
+    if (results.mutationScore < threshold) {
+      console.log(chalk.yellow(`\n⚠️  Mutation score ${results.mutationScore.toFixed(1)}% is below threshold ${threshold}%`));
+      process.exit(1);
+    } else {
+      success(`Mutation score meets threshold (${threshold}%)`);
+      process.exit(0);
+    }
+  } catch (err) {
+    error(`Mutation testing failed: ${err.message}`);
+    if (options.verbose) {
+      console.error(err.stack);
+    }
+
+    // Cleanup on error
+    if (mutationTester) {
+      try {
+        await mutationTester.cleanup();
+      } catch (cleanupErr) {
+        // Ignore cleanup errors
+      }
+    }
+
+    process.exit(1);
+  }
+}
+
+module.exports = mutateCommand;

package/src/cli/commands/query.js

@@ -0,0 +1,107 @@
+/**
+ * Query Command
+ * Query test coverage for specific files/lines
+ */
+
+const { loadLineageData, processLineageDataForMutation } = require('../utils/data-loader');
+const { section, error, formatPath } = require('../utils/output-formatter');
+const Table = require('cli-table3');
+const chalk = require('chalk');
+const path = require('path');
+
+async function queryCommand(file, line, options) {
+  try {
+    // Load lineage data
+    const rawData = loadLineageData(options.data);
+    const lineageData = processLineageDataForMutation(rawData);
+
+    // Normalize file path
+    const normalizedFile = path.normalize(file);
+
+    // Find matching files
+    const matchingFiles = Object.keys(lineageData).filter(f =>
+      f.includes(normalizedFile) || normalizedFile.includes(path.basename(f))
+    );
+
+    if (matchingFiles.length === 0) {
+      error(`No coverage data found for file: ${chalk.yellow(file)}`);
+      process.exit(1);
+    }
+
+    // If multiple matches, show them
+    if (matchingFiles.length > 1) {
+      console.log(chalk.yellow(`Found multiple matching files:`));
+      matchingFiles.forEach(f => console.log(`  - ${formatPath(f)}`));
+      console.log(chalk.yellow(`\nUsing first match: ${matchingFiles[0]}\n`));
+    }
+
+    const targetFile = matchingFiles[0];
+    const fileCoverage = lineageData[targetFile];
+
+    // If line specified, show coverage for that line
+    if (line) {
+      const lineNumber = line.toString();
+      if (!fileCoverage[lineNumber]) {
+        error(`No coverage data for line ${chalk.yellow(lineNumber)} in ${chalk.yellow(file)}`);
+        process.exit(1);
+      }
+
+      section(`📍 Coverage for ${formatPath(targetFile)}:${lineNumber}`);
+
+      const tests = fileCoverage[lineNumber];
+      const table = new Table({
+        head: [chalk.cyan('Test Name'), chalk.cyan('File'), chalk.cyan('Exec Count')],
+        colWidths: [50, 30, 12]
+      });
+
+      tests.forEach(test => {
+        table.push([
+          test.testName,
+          path.basename(test.testFile),
+          test.executionCount
+        ]);
+      });
+
+      console.log(table.toString());
+      console.log(chalk.gray(`\nTotal: ${tests.length} test(s) cover this line`));
+    } else {
+      // Show coverage for entire file
+      section(`📁 Coverage for ${formatPath(targetFile)}`);
+
+      const lines = Object.keys(fileCoverage).sort((a, b) => parseInt(a) - parseInt(b));
+      const totalTests = new Set(
+        lines.flatMap(lineNum => fileCoverage[lineNum].map(t => t.testName))
+      ).size;
+
+      console.log(chalk.gray(`Lines covered: ${lines.length}`));
+      console.log(chalk.gray(`Tests covering file: ${totalTests}\n`));
+
+      // Show sample of lines
+      const sampleSize = 10;
+      const sampled = lines.slice(0, sampleSize);
+
+      sampled.forEach(lineNum => {
+        const tests = fileCoverage[lineNum];
+        console.log(chalk.cyan(`Line ${lineNum}:`));
+        tests.slice(0, 3).forEach(test => {
+          console.log(`  ${chalk.gray('•')} ${test.testName} ${chalk.gray(`(${path.basename(test.testFile)})`)}`);
+        });
+        if (tests.length > 3) {
+          console.log(chalk.gray(`  ... and ${tests.length - 3} more test(s)`));
+        }
+      });
+
+      if (lines.length > sampleSize) {
+        console.log(chalk.gray(`\n... and ${lines.length - sampleSize} more lines`));
+        console.log(chalk.yellow(`\nTip: Specify a line number to see details: jest-lineage query ${file} <line>`));
+      }
+    }
+
+    process.exit(0);
+  } catch (err) {
+    error(`Query failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = queryCommand;