jest-test-lineage-reporter 2.0.2 → 2.1.0

package/src/__tests__/weak-test-example.test.ts

@@ -0,0 +1,222 @@
+import {
+  simpleAdd,
+  complexLogic,
+  boundaryCheck,
+  logicalOperations,
+  mathOperations,
+  stringOperations,
+  incrementOperations,
+  subtleBugFunction,
+  reallyWeakFunction,
+  guaranteedSurvivedMutations
+} from '../weak-test-example';
+
+describe('Weak Test Examples - Some mutations will survive', () => {
+  
+  // GOOD TEST - should kill mutations
+  describe('simpleAdd', () => {
+    it('should add two positive numbers', () => {
+      expect(simpleAdd(2, 3)).toBe(5);
+    });
+    
+    it('should add negative numbers', () => {
+      expect(simpleAdd(-2, -3)).toBe(-5);
+    });
+  });
+
+  // WEAK TEST - missing edge cases, mutations may survive
+  describe('complexLogic', () => {
+    it('should handle basic case', () => {
+      expect(complexLogic(5, 3)).toBe(8);  // Only tests the x + y path
+    });
+
+    it('should handle large numbers but with weak assertion', () => {
+      const result = complexLogic(15, 5);
+      expect(typeof result).toBe('number');  // Very weak! Doesn't check actual value
+      // This covers x > 10 path but doesn't verify x * 2 logic
+      // Mutations like * to / will survive!
+    });
+
+    it('should handle negative numbers but with weak assertion', () => {
+      const result = complexLogic(-5, 10);
+      expect(result).toBeGreaterThanOrEqual(0);  // Weak! Doesn't check exact value
+      // This covers x < 0 path but doesn't verify return 0 logic
+      // Mutations like return 0 to return 1 will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't test boundary conditions properly
+  describe('boundaryCheck', () => {
+    it('should return medium for normal values', () => {
+      expect(boundaryCheck(50)).toBe("medium");
+    });
+
+    it('should handle high values but with weak assertion', () => {
+      const result = boundaryCheck(150);
+      expect(typeof result).toBe('string');  // Weak! Doesn't check actual value
+      // This covers >= 100 path but doesn't verify "high" result
+      // Mutations like >= to > will survive!
+    });
+
+    it('should handle low values but with weak assertion', () => {
+      const result = boundaryCheck(-10);
+      expect(result.length).toBeGreaterThan(0);  // Weak! Doesn't check actual value
+      // This covers <= 0 path but doesn't verify "low" result
+      // Mutations like <= to < will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't test all logical combinations
+  describe('logicalOperations', () => {
+    it('should handle true and true', () => {
+      expect(logicalOperations(true, true)).toBe(true);
+    });
+
+    it('should handle other combinations but with weak assertions', () => {
+      const result1 = logicalOperations(true, false);
+      const result2 = logicalOperations(false, true);
+      const result3 = logicalOperations(false, false);
+
+      // Very weak assertions - just check they return booleans!
+      expect(typeof result1).toBe('boolean');
+      expect(typeof result2).toBe('boolean');
+      expect(typeof result3).toBe('boolean');
+
+      // This covers all logical paths but doesn't verify correct logic
+      // Mutations like && to ||, || to &&, !a to a will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't verify the actual math
+  describe('mathOperations', () => {
+    it('should return a number', () => {
+      const result = mathOperations(10);
+      expect(typeof result).toBe('number');  // Very weak assertion!
+    });
+
+    it('should not throw errors', () => {
+      // This test covers the lines but doesn't validate the math at all!
+      expect(() => {
+        mathOperations(5);
+        mathOperations(0);
+        mathOperations(-3);
+      }).not.toThrow();
+
+      // This covers all the math operation lines but mutations will survive
+      // because we're not checking the actual results!
+    });
+  });
+
+  // WEAK TEST - incomplete string testing
+  describe('stringOperations', () => {
+    it('should handle non-empty strings', () => {
+      const result = stringOperations("hello");
+      expect(typeof result).toBe('string');  // Weak assertion
+    });
+    
+    // Missing tests for empty string, boundary lengths
+    // String comparison mutations will survive
+  });
+
+  // WEAK TEST - doesn't verify increment behavior
+  describe('incrementOperations', () => {
+    it('should return a number', () => {
+      const result = incrementOperations(5);
+      expect(result).toBeGreaterThan(0);  // Very weak assertion
+    });
+
+    it('should handle edge cases but with wrong expectations', () => {
+      // This test covers the lines but has completely wrong logic!
+      const result1 = incrementOperations(10);
+      const result2 = incrementOperations(15);
+
+      // These assertions are so generic that mutations will survive
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(typeof result1).toBe('number');
+      expect(typeof result2).toBe('number');
+
+      // This covers the increment/decrement logic but doesn't validate it!
+    });
+  });
+
+  // TERRIBLE TEST - covers lines but doesn't validate behavior at all
+  describe('subtleBugFunction', () => {
+    it('should execute without errors', () => {
+      // This test covers all branches but validates NOTHING!
+      let result1, result2, result3;
+
+      expect(() => {
+        result1 = subtleBugFunction(0, 5);    // Covers x === 0 branch
+        result2 = subtleBugFunction(3, 2);    // Covers x > 0 branch
+        result3 = subtleBugFunction(-1, 4);   // Covers x < 0 branch
+      }).not.toThrow();
+
+      // These assertions are completely useless!
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result3).toBeDefined();
+
+      // ALL mutations will survive because we don't check actual values!
+      // return 1 -> return 0: SURVIVES (we don't check result1 === 1)
+      // x + y -> x - y: SURVIVES (we don't check result2 === 5)
+      // x - y -> x + y: SURVIVES (we don't check result3 === -5)
+    });
+  });
+
+  // ABSOLUTELY TERRIBLE TEST - will definitely have survived mutations
+  describe('reallyWeakFunction', () => {
+    it('should just run without throwing errors', () => {
+      // This test only checks that the function doesn't crash!
+      // It covers all lines but validates NOTHING about the logic
+
+      let result1, result2, result3;
+
+      // Execute the function to cover the lines
+      expect(() => {
+        result1 = reallyWeakFunction(5, 10);   // Covers a * b, result > 100 (false), return result - 5
+        result2 = reallyWeakFunction(15, 8);   // Covers a * b, result > 100 (true), return result + 10
+        result3 = reallyWeakFunction(2, 3);    // Covers a * b, result > 100 (false), return result - 5
+      }).not.toThrow();
+
+      // These assertions are completely useless for catching mutations!
+      expect(result1).toBeDefined();  // Doesn't check if result1 === 45
+      expect(result2).toBeDefined();  // Doesn't check if result2 === 130
+      expect(result3).toBeDefined();  // Doesn't check if result3 === 1
+
+      // MUTATIONS THAT WILL SURVIVE:
+      // a * b -> a + b: SURVIVES (we don't check actual calculation)
+      // a * b -> a - b: SURVIVES (we don't check actual calculation)
+      // a * b -> a / b: SURVIVES (we don't check actual calculation)
+      // result > 100 -> result < 100: SURVIVES (we don't check branching logic)
+      // result > 100 -> result >= 100: SURVIVES (we don't check branching logic)
+      // result + 10 -> result - 10: SURVIVES (we don't check return values)
+      // result - 5 -> result + 5: SURVIVES (we don't check return values)
+    });
+  });
+
+  // ABSOLUTELY USELESS TEST - will definitely have survived mutations
+  describe('guaranteedSurvivedMutations', () => {
+    it('should exist as a function', () => {
+      // This test is so useless it only checks the function exists!
+      expect(typeof guaranteedSurvivedMutations).toBe('function');
+
+      // We call the function but don't check ANY return values
+      guaranteedSurvivedMutations(5);    // Covers x === 5 branch, return 42
+      guaranteedSurvivedMutations(15);   // Covers x > 10 branch, return x * 2
+      guaranteedSurvivedMutations(3);    // Covers default branch, return x + 1
+
+      // NO ASSERTIONS ON RETURN VALUES!
+      // This means ALL mutations will survive:
+      // x === 5 -> x !== 5: SURVIVES (we don't check the condition)
+      // x === 5 -> x > 5: SURVIVES (we don't check the condition)
+      // return 42 -> return 0: SURVIVES (we don't check return value)
+      // return 42 -> return 1: SURVIVES (we don't check return value)
+      // x > 10 -> x < 10: SURVIVES (we don't check the condition)
+      // x * 2 -> x + 2: SURVIVES (we don't check return value)
+      // x * 2 -> x - 2: SURVIVES (we don't check return value)
+      // x + 1 -> x - 1: SURVIVES (we don't check return value)
+      // x + 1 -> x * 1: SURVIVES (we don't check return value)
+    });
+  });
+});

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;

package/src/cli/commands/report.js

@@ -0,0 +1,65 @@
+/**
+ * Report Command
+ * Generate HTML report from existing lineage data
+ */
+
+const TestCoverageReporter = require('../../TestCoverageReporter');
+const { loadLineageData, processLineageDataForMutation } = require('../utils/data-loader');
+const { loadFullConfig } = require('../utils/config-loader');
+const { spinner, success, error, info } = require('../utils/output-formatter');
+const open = require('open');
+const chalk = require('chalk');
+const path = require('path');
+
+async function reportCommand(options) {
+  try {
+    // Load configuration
+    const config = loadFullConfig(options);
+
+    // Load lineage data
+    info(`Loading lineage data from: ${chalk.yellow(options.data)}`);
+    const rawData = loadLineageData(options.data);
+
+    const testCount = rawData.tests.length;
+    info(`Loaded ${chalk.cyan(testCount)} tests`);
+
+    // Process lineage data
+    const lineageData = processLineageDataForMutation(rawData);
+
+    // Create reporter instance with minimal config
+    const reporter = new TestCoverageReporter(
+      { rootDir: process.cwd() },
+      { outputFile: options.output, ...config }
+    );
+
+    // Load data into reporter
+    reporter.processLineageResults(lineageData, 'unknown');
+
+    // Generate HTML report
+    const spin = spinner('Generating HTML report...');
+    spin.start();
+
+    await reporter.generateHtmlReport();
+
+    spin.succeed('HTML report generated!');
+
+    const reportPath = path.resolve(process.cwd(), options.output);
+    success(`Report saved to: ${chalk.cyan(reportPath)}`);
+
+    // Open in browser if requested
+    if (options.open) {
+      info('Opening report in browser...');
+      await open(reportPath);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    error(`Failed to generate report: ${err.message}`);
+    if (process.env.JEST_LINEAGE_DEBUG === 'true') {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = reportCommand;

package/src/cli/commands/test.js

@@ -0,0 +1,56 @@
+/**
+ * Test Command
+ * Run Jest tests with lineage tracking
+ */
+
+const { runJest } = require('../utils/jest-runner');
+const { loadFullConfig } = require('../utils/config-loader');
+const { lineageDataExists } = require('../utils/data-loader');
+const { success, error, info } = require('../utils/output-formatter');
+const fs = require('fs');
+const path = require('path');
+
+async function testCommand(jestArgs, options) {
+  try {
+    // Load configuration
+    const config = loadFullConfig(options);
+
+    // Run Jest with lineage tracking
+    const result = await runJest({
+      args: jestArgs || [],
+      config: options.config,
+      enableLineage: options.lineage !== false,
+      enablePerformance: options.performance !== false,
+      enableQuality: options.quality !== false,
+      quiet: options.quiet
+    });
+
+    // Check if lineage data was generated
+    const dataPath = path.join(process.cwd(), '.jest-lineage-data.json');
+    if (result.success && fs.existsSync(dataPath)) {
+      const data = JSON.parse(fs.readFileSync(dataPath, 'utf8'));
+      const testCount = data.tests ? data.tests.length : 0;
+      const fileCount = data.tests
+        ? new Set(data.tests.flatMap(t =>
+            Object.keys(t.coverage || {}).map(k => k.split(':')[0])
+          )).size
+        : 0;
+
+      if (!options.quiet) {
+        info(`Lineage data saved to: ${dataPath}`);
+        console.log(`   - ${testCount} tests tracked`);
+        console.log(`   - ${fileCount} files analyzed\n`);
+      }
+    } else if (!result.success) {
+      error('Tests failed. Lineage data may be incomplete.');
+    }
+
+    // Exit with Jest's exit code
+    process.exit(result.exitCode);
+  } catch (err) {
+    error(`Failed to run tests: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = testCommand;