jest-test-lineage-reporter 2.0.1

package/src/babel-plugin-lineage-tracker.js

@@ -0,0 +1,290 @@
+/**
+ * Production Babel Plugin for Jest Test Lineage Tracking
+ * Automatically instruments source code to track line-by-line test coverage
+ */
+function lineageTrackerPlugin({ types: t }, options = {}) {
+  // Check if lineage tracking is enabled
+  const isEnabled = process.env.JEST_LINEAGE_ENABLED !== 'false' &&
+                   process.env.JEST_LINEAGE_TRACKING !== 'false' &&
+                   options.enabled !== false;
+
+  return {
+    name: 'lineage-tracker',
+    visitor: {
+      Program: {
+        enter(path, state) {
+          // Initialize plugin state
+          state.filename = state.file.opts.filename;
+          state.shouldInstrument = isEnabled && shouldInstrumentFile(state.filename);
+          state.instrumentedLines = new Set();
+
+          if (state.shouldInstrument) {
+            console.log(`🔧 Instrumenting: ${state.filename}`);
+          } else if (!isEnabled) {
+            console.log(`⏸️ Lineage tracking disabled for: ${state.filename}`);
+          }
+        }
+      },
+      // Instrument function declarations
+      FunctionDeclaration(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'function-declaration');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument function expressions and arrow functions
+      'FunctionExpression|ArrowFunctionExpression'(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'function-expression');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument variable declarations
+      VariableDeclaration(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'variable-declaration');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument expression statements
+      ExpressionStatement(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'expression-statement');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument return statements
+      ReturnStatement(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'return-statement');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument if statements
+      IfStatement(path, state) {
+        if (!state.shouldInstrument) return;
+
+        const lineNumber = path.node.loc?.start.line;
+        if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+          instrumentLine(path, state, lineNumber, 'if-statement');
+          state.instrumentedLines.add(lineNumber);
+        }
+      },
+
+      // Instrument block statements (but avoid duplicating)
+      BlockStatement(path, state) {
+        if (!state.shouldInstrument) return;
+
+        // Only instrument block statements that are function bodies
+        if (t.isFunction(path.parent)) {
+          const lineNumber = path.node.loc?.start.line;
+          if (lineNumber && !state.instrumentedLines.has(lineNumber)) {
+            // Insert tracking at the beginning of the block
+            const trackingCall = createTrackingCall(state.filename, lineNumber, 'block-start');
+            path.unshiftContainer('body', trackingCall);
+            state.instrumentedLines.add(lineNumber);
+          }
+        }
+      }
+    }
+  };
+};
+
+/**
+ * Determines if a file should be instrumented
+ */
+function shouldInstrumentFile(filename) {
+  if (!filename) return false;
+
+  // Don't instrument test files
+  if (filename.includes('__tests__') ||
+      filename.includes('.test.') ||
+      filename.includes('.spec.') ||
+      filename.includes('testSetup.js') ||
+      filename.includes('TestCoverageReporter.js') ||
+      filename.includes('LineageTestEnvironment.js')) {
+    return false;
+  }
+
+  // Don't instrument node_modules
+  if (filename.includes('node_modules')) {
+    return false;
+  }
+
+  // Only instrument source files
+  return filename.endsWith('.ts') ||
+         filename.endsWith('.js') ||
+         filename.endsWith('.tsx') ||
+         filename.endsWith('.jsx');
+}
+
+/**
+ * Instruments a line by adding tracking call before it
+ */
+function instrumentLine(path, state, lineNumber, nodeType) {
+  const trackingCall = createTrackingCall(state.filename, lineNumber, nodeType);
+
+  try {
+    // Insert tracking call before the current statement
+    path.insertBefore(trackingCall);
+  } catch (error) {
+    console.warn(`Warning: Could not instrument line ${lineNumber} in ${state.filename}:`, error.message);
+  }
+}
+
+/**
+ * Creates a tracking function call with package.json-based path detection
+ */
+function createTrackingCall(filename, lineNumber, nodeType) {
+  const { types: t } = require('@babel/core');
+  const path = require('path');
+
+  // Use package.json as the project root reference
+  let relativeFilePath;
+  if (filename) {
+    const projectRoot = findProjectRoot(filename);
+
+    if (projectRoot && filename.startsWith(projectRoot)) {
+      // Convert absolute path to relative path from package.json location
+      relativeFilePath = path.relative(projectRoot, filename);
+    } else {
+      // Fallback to current working directory
+      const cwd = process.cwd();
+      if (filename.startsWith(cwd)) {
+        relativeFilePath = path.relative(cwd, filename);
+      } else {
+        // Last resort: extract meaningful path
+        relativeFilePath = extractMeaningfulPath(filename);
+      }
+    }
+  } else {
+    relativeFilePath = 'unknown';
+  }
+
+  // Create: global.__TRACK_LINE_EXECUTION__ && global.__TRACK_LINE_EXECUTION__(filename, lineNumber)
+  return t.expressionStatement(
+    t.logicalExpression(
+      '&&',
+      t.memberExpression(
+        t.identifier('global'),
+        t.identifier('__TRACK_LINE_EXECUTION__')
+      ),
+      t.callExpression(
+        t.memberExpression(
+          t.identifier('global'),
+          t.identifier('__TRACK_LINE_EXECUTION__')
+        ),
+        [
+          t.stringLiteral(relativeFilePath),
+          t.numericLiteral(lineNumber),
+          t.stringLiteral(nodeType)
+        ]
+      )
+    )
+  );
+}
+
+/**
+ * Find the project root by looking for package.json
+ */
+function findProjectRoot(startPath) {
+  const path = require('path');
+  const fs = require('fs');
+
+  let currentDir = path.dirname(startPath);
+  const root = path.parse(currentDir).root;
+
+  while (currentDir !== root) {
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  // Fallback to current working directory if no package.json found
+  return process.cwd();
+}
+
+/**
+ * Extract meaningful path from filename using smart detection (fallback)
+ */
+function extractMeaningfulPath(filename) {
+  const path = require('path');
+  const parts = filename.split(path.sep);
+
+  // Common source directory indicators
+  const sourceIndicators = [
+    'src', 'lib', 'source', 'app', 'server', 'client',
+    'packages', 'apps', 'libs', 'modules', 'components'
+  ];
+
+  // Find the first occurrence of a source indicator (not last)
+  let sourceIndex = -1;
+  for (let i = 0; i < parts.length; i++) {
+    if (sourceIndicators.includes(parts[i])) {
+      sourceIndex = i;
+      break;
+    }
+  }
+
+  if (sourceIndex !== -1) {
+    // Include the source directory and everything after it
+    // This preserves subdirectories like 'src/services/calculationService.ts'
+    return parts.slice(sourceIndex).join(path.sep);
+  }
+
+  // If no source indicator found, try to preserve meaningful structure
+  const filename_only = parts[parts.length - 1];
+
+  // Look for meaningful parent directories (preserve up to 3 levels)
+  if (parts.length >= 3) {
+    const meaningfulParts = parts.slice(-3); // Take last 3 parts
+    // Filter out common non-meaningful directories
+    const filtered = meaningfulParts.filter(part =>
+      part &&
+      !part.startsWith('.') &&
+      part !== 'node_modules' &&
+      part !== 'dist' &&
+      part !== 'build'
+    );
+
+    if (filtered.length >= 2) {
+      return filtered.join(path.sep);
+    }
+  }
+
+  // Look for meaningful parent directories (preserve up to 2 levels)
+  if (parts.length >= 2) {
+    const parent = parts[parts.length - 2];
+    // If parent looks like a meaningful directory, include it
+    if (parent && !parent.startsWith('.') && parent !== 'node_modules') {
+      return path.join(parent, filename_only);
+    }
+  }
+
+  // Fallback to just the filename
+  return filename_only;
+}
+
+module.exports = lineageTrackerPlugin;

package/src/config.js

@@ -0,0 +1,193 @@
+/**
+ * Configuration for Jest Test Lineage Reporter
+ */
+
+const DEFAULT_CONFIG = {
+  // Feature toggles
+  enabled: true, // Master switch to enable/disable entire system
+  enableLineageTracking: true, // Enable detailed line-by-line tracking
+  enablePerformanceTracking: true, // Enable CPU/memory monitoring
+  enableQualityAnalysis: true, // Enable test quality scoring
+
+  // Output settings
+  outputFile: 'test-lineage-report.html',
+  enableConsoleOutput: true,
+  enableDebugLogging: false,
+  
+  // Performance thresholds
+  memoryLeakThreshold: 50 * 1024, // 50KB - allocations above this trigger memory leak alerts
+  gcPressureThreshold: 5, // Number of small allocations that trigger GC pressure alerts
+  slowExecutionThreshold: 2.0, // Multiplier for average execution time to trigger slow alerts
+  
+  // Quality thresholds
+  qualityThreshold: 60, // Minimum quality score (0-100)
+  reliabilityThreshold: 60, // Minimum reliability score (0-100)
+  maintainabilityThreshold: 60, // Minimum maintainability score (0-100)
+  maxTestSmells: 2, // Maximum number of test smells before flagging
+  
+  // Test quality scoring weights
+  qualityWeights: {
+    assertions: 5, // Points per assertion (up to 30 points)
+    errorHandling: 10, // Points per error handling pattern (up to 20 points)
+    edgeCases: 3, // Points per edge case test (up to 15 points)
+    testSmellPenalty: 5, // Points deducted per test smell
+    complexityPenalty: 2, // Points deducted per complexity point
+    lengthPenalty: 0.5 // Points deducted per line over 50
+  },
+  
+  // Performance tracking
+  enableCpuCycleTracking: true,
+  enableMemoryTracking: true,
+  enableCallDepthTracking: true,
+  maxCallDepthTracking: 10, // Maximum call depth to track
+  
+  // HTML report settings
+  enableInteractiveFeatures: true,
+  enablePerformanceDashboard: true,
+  enableQualityDashboard: true,
+  maxLinesInReport: 10000, // Maximum number of lines to include in HTML report
+
+  // Mutation testing settings
+  enableMutationTesting: false, // Enable mutation testing mode
+  mutationOperators: {
+    arithmetic: true,     // +, -, *, /, %
+    comparison: true,     // ==, !=, <, >, <=, >=
+    logical: true,        // &&, ||, !
+    conditional: true,    // if conditions, ternary operators
+    assignment: true,     // =, +=, -=, etc.
+    literals: true,       // numbers, booleans, strings
+    returns: true,        // return statements
+    increments: true      // ++, --
+  },
+  mutationThreshold: 80,  // Minimum mutation score (% of mutations killed)
+  mutationTimeout: 5000,  // Timeout per mutation test in ms
+  maxMutationsPerLine: 3, // Maximum mutations to generate per line
+  skipEquivalentMutants: true, // Skip mutations that don't change behavior
+
+  // Debug options
+  debugMutations: false,  // Create mutation files for debugging instead of overwriting originals
+  debugMutationDir: './mutations-debug', // Directory to store debug mutation files
+  
+  // File filtering
+  includePatterns: [
+    '**/*.js',
+    '**/*.ts',
+    '**/*.jsx',
+    '**/*.tsx'
+  ],
+  excludePatterns: [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/*.min.js',
+    '**/*.bundle.js'
+  ]
+};
+
+/**
+ * Validates and merges user configuration with defaults
+ * @param {Object} userConfig - User provided configuration
+ * @returns {Object} Merged and validated configuration
+ */
+function validateAndMergeConfig(userConfig = {}) {
+  const config = { ...DEFAULT_CONFIG, ...userConfig };
+  
+  // Validate numeric thresholds
+  if (typeof config.memoryLeakThreshold !== 'number' || config.memoryLeakThreshold < 0) {
+    console.warn('Invalid memoryLeakThreshold, using default:', DEFAULT_CONFIG.memoryLeakThreshold);
+    config.memoryLeakThreshold = DEFAULT_CONFIG.memoryLeakThreshold;
+  }
+  
+  if (typeof config.gcPressureThreshold !== 'number' || config.gcPressureThreshold < 1) {
+    console.warn('Invalid gcPressureThreshold, using default:', DEFAULT_CONFIG.gcPressureThreshold);
+    config.gcPressureThreshold = DEFAULT_CONFIG.gcPressureThreshold;
+  }
+  
+  if (typeof config.qualityThreshold !== 'number' || config.qualityThreshold < 0 || config.qualityThreshold > 100) {
+    console.warn('Invalid qualityThreshold, using default:', DEFAULT_CONFIG.qualityThreshold);
+    config.qualityThreshold = DEFAULT_CONFIG.qualityThreshold;
+  }
+  
+  // Validate file patterns
+  if (!Array.isArray(config.includePatterns)) {
+    console.warn('Invalid includePatterns, using default');
+    config.includePatterns = DEFAULT_CONFIG.includePatterns;
+  }
+  
+  if (!Array.isArray(config.excludePatterns)) {
+    console.warn('Invalid excludePatterns, using default');
+    config.excludePatterns = DEFAULT_CONFIG.excludePatterns;
+  }
+  
+  // Validate quality weights
+  if (typeof config.qualityWeights !== 'object') {
+    console.warn('Invalid qualityWeights, using default');
+    config.qualityWeights = DEFAULT_CONFIG.qualityWeights;
+  }
+  
+  return config;
+}
+
+/**
+ * Gets configuration from environment variables
+ * @returns {Object} Configuration from environment
+ */
+function getConfigFromEnv() {
+  return {
+    // Feature toggles
+    enabled: process.env.JEST_LINEAGE_ENABLED !== 'false', // Default enabled, set to 'false' to disable
+    enableLineageTracking: process.env.JEST_LINEAGE_TRACKING !== 'false',
+    enablePerformanceTracking: process.env.JEST_LINEAGE_PERFORMANCE !== 'false',
+    enableQualityAnalysis: process.env.JEST_LINEAGE_QUALITY !== 'false',
+    enableMutationTesting: process.env.JEST_LINEAGE_MUTATION ? process.env.JEST_LINEAGE_MUTATION === 'true' : undefined,
+
+    // Output settings
+    outputFile: process.env.JEST_LINEAGE_OUTPUT_FILE,
+    enableDebugLogging: process.env.JEST_LINEAGE_DEBUG === 'true',
+
+    // Thresholds
+    memoryLeakThreshold: process.env.JEST_LINEAGE_MEMORY_THRESHOLD ?
+      parseInt(process.env.JEST_LINEAGE_MEMORY_THRESHOLD) : undefined,
+    gcPressureThreshold: process.env.JEST_LINEAGE_GC_THRESHOLD ?
+      parseInt(process.env.JEST_LINEAGE_GC_THRESHOLD) : undefined,
+    qualityThreshold: process.env.JEST_LINEAGE_QUALITY_THRESHOLD ?
+      parseInt(process.env.JEST_LINEAGE_QUALITY_THRESHOLD) : undefined,
+
+    // Mutation testing settings
+    debugMutations: process.env.JEST_LINEAGE_DEBUG_MUTATIONS ? process.env.JEST_LINEAGE_DEBUG_MUTATIONS === 'true' : undefined,
+    debugMutationDir: process.env.JEST_LINEAGE_DEBUG_MUTATION_DIR,
+
+    // Mutation testing thresholds
+    mutationThreshold: process.env.JEST_LINEAGE_MUTATION_THRESHOLD ?
+      parseInt(process.env.JEST_LINEAGE_MUTATION_THRESHOLD) : undefined,
+    mutationTimeout: process.env.JEST_LINEAGE_MUTATION_TIMEOUT ?
+      parseInt(process.env.JEST_LINEAGE_MUTATION_TIMEOUT) : undefined
+  };
+}
+
+/**
+ * Loads configuration from file, environment, and defaults
+ * @param {Object} userConfig - User provided configuration
+ * @returns {Object} Final configuration
+ */
+function loadConfig(userConfig = {}) {
+  const envConfig = getConfigFromEnv();
+
+  // Only merge environment config values that are actually set (not undefined)
+  const filteredEnvConfig = {};
+  Object.keys(envConfig).forEach(key => {
+    if (envConfig[key] !== undefined) {
+      filteredEnvConfig[key] = envConfig[key];
+    }
+  });
+
+  const mergedConfig = { ...userConfig, ...filteredEnvConfig };
+  return validateAndMergeConfig(mergedConfig);
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  validateAndMergeConfig,
+  getConfigFromEnv,
+  loadConfig
+};