jest-test-lineage-reporter 2.0.2 → 2.1.1

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/init.js

@@ -0,0 +1,214 @@
+/**
+ * Init Command
+ * Initialize jest-test-lineage-reporter in a project
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { success, error, info, warning } = require('../utils/output-formatter');
+
+async function initCommand(options) {
+  try {
+    const cwd = process.cwd();
+    const jestConfigPath = path.join(cwd, 'jest.config.js');
+    const babelConfigPath = path.join(cwd, 'babel.config.js');
+    const packageJsonPath = path.join(cwd, 'package.json');
+
+    console.log('\n🚀 Initializing jest-test-lineage-reporter...\n');
+
+    // Check if package.json exists
+    if (!fs.existsSync(packageJsonPath)) {
+      error('No package.json found. Please run "npm init" first.');
+      process.exit(1);
+    }
+
+    // Read package.json to check dependencies
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const allDeps = {
+      ...(packageJson.dependencies || {}),
+      ...(packageJson.devDependencies || {}),
+    };
+
+    // Check for required dependencies
+    const requiredDeps = ['jest', 'babel-jest', '@babel/core', '@babel/preset-env'];
+    const missingDeps = requiredDeps.filter(dep => !allDeps[dep]);
+
+    if (missingDeps.length > 0) {
+      warning('Missing required dependencies:');
+      missingDeps.forEach(dep => console.log(`  - ${dep}`));
+      console.log('\n💡 Install them with:');
+      console.log(`   npm install --save-dev ${missingDeps.join(' ')}\n`);
+
+      if (!options.force) {
+        error('Please install missing dependencies first, or use --force to continue anyway.');
+        process.exit(1);
+      }
+    }
+
+    // Create or update Jest config
+    let jestConfigCreated = false;
+    if (fs.existsSync(jestConfigPath)) {
+      if (!options.force) {
+        warning(`jest.config.js already exists. Use --force to overwrite.`);
+        info('Please manually add the following to your jest.config.js:');
+        console.log(`
+  setupFilesAfterEnv: ['jest-test-lineage-reporter/src/testSetup.js'],
+
+  reporters: [
+    'default',
+    ['jest-test-lineage-reporter', {
+      outputFile: '.jest-lineage-data.json',
+      enableMutationTesting: false,
+    }]
+  ],
+
+  collectCoverage: true,
+  collectCoverageFrom: ['src/**/*.{js,ts}', '!src/**/*.test.{js,ts}'],
+
+  transform: {
+    '^.+\\\\.(js|jsx|ts|tsx)$': 'babel-jest',
+  },
+`);
+      } else {
+        createJestConfig(jestConfigPath, options);
+        jestConfigCreated = true;
+      }
+    } else {
+      createJestConfig(jestConfigPath, options);
+      jestConfigCreated = true;
+    }
+
+    // Create or update Babel config
+    let babelConfigCreated = false;
+    if (fs.existsSync(babelConfigPath)) {
+      if (!options.force) {
+        warning(`babel.config.js already exists. Use --force to overwrite.`);
+        info('Please manually add the lineage tracker plugin to your babel.config.js:');
+        console.log(`
+  plugins: [
+    'jest-test-lineage-reporter/src/babel-plugin-lineage-tracker.js',
+  ],
+`);
+      } else {
+        createBabelConfig(babelConfigPath, options);
+        babelConfigCreated = true;
+      }
+    } else {
+      createBabelConfig(babelConfigPath, options);
+      babelConfigCreated = true;
+    }
+
+    // Summary
+    console.log('\n' + '═'.repeat(50));
+    if (jestConfigCreated && babelConfigCreated) {
+      success('Configuration complete! ✨\n');
+      console.log('✅ Created jest.config.js');
+      console.log('✅ Created babel.config.js\n');
+    } else if (!jestConfigCreated && !babelConfigCreated) {
+      info('Configuration files already exist.');
+      info('Use --force to overwrite, or manually update the files.\n');
+    } else {
+      info('Partial configuration completed.');
+      if (jestConfigCreated) console.log('✅ Created jest.config.js');
+      if (babelConfigCreated) console.log('✅ Created babel.config.js');
+      console.log('');
+    }
+
+    // Show next steps
+    console.log('📋 Next steps:\n');
+    if (missingDeps.length > 0) {
+      console.log('1. Install missing dependencies:');
+      console.log(`   npm install --save-dev ${missingDeps.join(' ')}\n`);
+    }
+    console.log(`${missingDeps.length > 0 ? '2' : '1'}. Run your tests with lineage tracking:`);
+    console.log('   npx jest-lineage test\n');
+    console.log(`${missingDeps.length > 0 ? '3' : '2'}. Query coverage data:`);
+    console.log('   npx jest-lineage query src/yourfile.js\n');
+    console.log(`${missingDeps.length > 0 ? '4' : '3'}. Generate HTML report:`);
+    console.log('   npx jest-lineage report --open\n');
+    console.log('═'.repeat(50) + '\n');
+
+  } catch (err) {
+    error(`Failed to initialize: ${err.message}`);
+    if (options.verbose) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+function createJestConfig(filePath, options) {
+  const isTypeScript = options.typescript || hasTypeScriptFiles();
+
+  const config = `module.exports = {
+  testEnvironment: 'node',
+
+  // Required: Setup file for lineage tracking
+  setupFilesAfterEnv: ['jest-test-lineage-reporter/src/testSetup.js'],
+
+  // Add the lineage reporter
+  reporters: [
+    'default',
+    [
+      'jest-test-lineage-reporter',
+      {
+        outputFile: '.jest-lineage-data.json',
+        enableMutationTesting: false,
+      }
+    ]
+  ],
+
+  // Enable coverage
+  collectCoverage: true,
+  collectCoverageFrom: [
+    'src/**/*.{js${isTypeScript ? ',ts' : ''}}',
+    '!src/**/*.test.{js${isTypeScript ? ',ts' : ''}}',
+    '!src/**/*.d.ts',
+  ],
+
+  // Use babel-jest for transformation
+  transform: {
+    '^.+\\\\.(js|jsx${isTypeScript ? '|ts|tsx' : ''})$': 'babel-jest',
+  },
+
+  // File extensions
+  moduleFileExtensions: ['js', 'jsx'${isTypeScript ? ", 'ts', 'tsx'" : ''}, 'json'],
+};
+`;
+
+  fs.writeFileSync(filePath, config, 'utf8');
+}
+
+function createBabelConfig(filePath, options) {
+  const isTypeScript = options.typescript || hasTypeScriptFiles();
+
+  const config = `module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],${isTypeScript ? `
+    '@babel/preset-typescript',` : ''}
+  ],
+  plugins: [
+    // Required: Lineage tracker plugin for instrumentation
+    'jest-test-lineage-reporter/src/babel-plugin-lineage-tracker.js',
+  ],
+};
+`;
+
+  fs.writeFileSync(filePath, config, 'utf8');
+}
+
+function hasTypeScriptFiles() {
+  const cwd = process.cwd();
+  const srcDir = path.join(cwd, 'src');
+
+  if (!fs.existsSync(srcDir)) return false;
+
+  try {
+    const files = fs.readdirSync(srcDir);
+    return files.some(file => file.endsWith('.ts') || file.endsWith('.tsx'));
+  } catch {
+    return false;
+  }
+}
+
+module.exports = initCommand;

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;