jest-test-lineage-reporter 2.0.2 → 2.1.1

package/src/cli/utils/output-formatter.js

@@ -0,0 +1,126 @@
+/**
+ * Output Formatter
+ * Format console output with colors and formatting
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+
+/**
+ * Print success message
+ * @param {string} message - Success message
+ */
+function success(message) {
+  console.log(chalk.green(`✅ ${message}`));
+}
+
+/**
+ * Print error message
+ * @param {string} message - Error message
+ */
+function error(message) {
+  console.error(chalk.red(`❌ ${message}`));
+}
+
+/**
+ * Print warning message
+ * @param {string} message - Warning message
+ */
+function warning(message) {
+  console.log(chalk.yellow(`⚠️  ${message}`));
+}
+
+/**
+ * Print info message
+ * @param {string} message - Info message
+ */
+function info(message) {
+  console.log(chalk.cyan(`ℹ️  ${message}`));
+}
+
+/**
+ * Print section header
+ * @param {string} title - Section title
+ */
+function section(title) {
+  console.log(chalk.bold.cyan(`\n${title}`));
+  console.log(chalk.gray('═'.repeat(title.length + 2)));
+}
+
+/**
+ * Create a spinner for long operations
+ * @param {string} text - Spinner text
+ * @returns {object} Ora spinner instance
+ */
+function spinner(text) {
+  return ora({
+    text,
+    color: 'cyan',
+    spinner: 'dots'
+  });
+}
+
+/**
+ * Print mutation results summary
+ * @param {object} results - Mutation test results
+ */
+function printMutationSummary(results) {
+  section('🧬 Mutation Testing Results');
+
+  console.log(`📊 ${chalk.bold('Total Mutations:')} ${results.totalMutations}`);
+  console.log(`${chalk.green('✅ Killed:')} ${results.killedMutations}`);
+  console.log(`${chalk.red('🔴 Survived:')} ${results.survivedMutations}`);
+  console.log(`${chalk.yellow('⏰ Timeout:')} ${results.timeoutMutations || 0}`);
+  console.log(`${chalk.gray('❌ Error:')} ${results.errorMutations || 0}`);
+  console.log(`${chalk.bold.cyan('🎯 Mutation Score:')} ${chalk.bold(results.mutationScore.toFixed(1))}%`);
+
+  if (results.mutationScore >= 80) {
+    console.log(chalk.green('\n✅ Excellent mutation score!'));
+  } else if (results.mutationScore >= 60) {
+    console.log(chalk.yellow('\n⚠️  Good mutation score, but room for improvement'));
+  } else {
+    console.log(chalk.red('\n❌ Low mutation score - consider improving test quality'));
+  }
+}
+
+/**
+ * Print lineage data summary
+ * @param {object} data - Lineage data
+ */
+function printLineageDataSummary(data) {
+  const testCount = data.tests.length;
+  const failedTests = data.tests.filter(t => t.failed).length;
+  const passedTests = testCount - failedTests;
+
+  console.log(chalk.cyan(`\n📊 Lineage data loaded:`));
+  console.log(`  ${chalk.green('✓')} ${passedTests} tests passed`);
+  if (failedTests > 0) {
+    console.log(`  ${chalk.red('✗')} ${failedTests} tests failed`);
+  }
+  console.log(`  ${chalk.gray('📅')} Generated: ${new Date(data.timestamp).toLocaleString()}`);
+}
+
+/**
+ * Format file path for display
+ * @param {string} filePath - File path
+ * @returns {string} Formatted path
+ */
+function formatPath(filePath) {
+  const cwd = process.cwd();
+  if (filePath.startsWith(cwd)) {
+    return chalk.gray(filePath.replace(cwd, '.'));
+  }
+  return chalk.gray(filePath);
+}
+
+module.exports = {
+  success,
+  error,
+  warning,
+  info,
+  section,
+  spinner,
+  printMutationSummary,
+  printLineageDataSummary,
+  formatPath
+};

package/src/depth-example.ts

@@ -0,0 +1,66 @@
+// Example file to demonstrate call depth tracking
+
+export function directFunction(x: number): number {
+  return x * 2; // This will be depth 1 when called directly from tests
+}
+export function oneLevel(x: number): number {
+  return directFunction(x) + 1; // directFunction will be depth 2 here
+}
+export function twoLevels(x: number): number {
+  return oneLevel(x) + 1; // directFunction will be depth 3 here
+}
+export function threeLevels(x: number): number {
+  return twoLevels(x) + 1; // directFunction will be depth 4 here
+}
+
+// Complex function that calls multiple other functions
+export function complexFunction(x: number): number {
+  const a = directFunction(x); // depth 2
+  const b = oneLevel(x); // directFunction will be depth 3 here
+  const c = twoLevels(x); // directFunction will be depth 4 here
+  return a + b + c;
+}
+
+// Recursive function to test deep call stacks
+export function recursiveFunction(n: number, depth: number = 0): number {
+  if (depth >= 3) {
+    return directFunction(n); // This will be very deep
+  }
+  return recursiveFunction(n, depth + 1) + 1;
+}
+
+// Global array to hold leaked memory - this will cause actual memory leaks
+const memoryLeakStorage: any[] = [];
+export function memoryLeakFunction(size: number): number {
+  // Create large objects and store them globally (this leaks memory!)
+  const largeObject = {
+    id: Date.now(),
+    data: new Array(size).fill(0).map((_, i) => ({
+      index: i,
+      value: Math.random(),
+      timestamp: new Date(),
+      largeString: 'x'.repeat(1000),
+      // 1KB string per item
+      metadata: {
+        created: Date.now(),
+        processed: false,
+        tags: ['memory', 'leak', 'test', 'large'],
+        history: new Array(100).fill(0).map(() => Math.random())
+      }
+    }))
+  };
+
+  // Store in global array - this prevents garbage collection (memory leak!)
+  memoryLeakStorage.push(largeObject);
+
+  // Also call our tracked function
+  return directFunction(size);
+}
+export function clearMemoryLeaks(): number {
+  const count = memoryLeakStorage.length;
+  memoryLeakStorage.length = 0; // Clear the array
+  return count;
+}
+export function getMemoryLeakCount(): number {
+  return memoryLeakStorage.length;
+}

package/src/gc-pressure-example.ts

@@ -0,0 +1,158 @@
+// Examples demonstrating GC pressure and how to fix it
+
+// BAD: Creates many small objects (causes GC pressure)
+export function badGCPressureFunction(count: number): number {
+  let total = 0;
+  
+  for (let i = 0; i < count; i++) {
+    // Creating new objects in a loop - BAD for GC
+    const tempObj = {
+      id: i,
+      value: Math.random(),
+      timestamp: Date.now(),
+      processed: false
+    };
+    
+    // More object creation
+    const result = {
+      input: tempObj,
+      output: tempObj.value * 2,
+      metadata: {
+        created: new Date(),
+        index: i
+      }
+    };
+    
+    total += result.output;
+  }
+  
+  return total;
+}
+
+// GOOD: Reuses objects (reduces GC pressure)
+export function goodGCPressureFunction(count: number): number {
+  let total = 0;
+  
+  // Reuse objects instead of creating new ones
+  const reusableObj = {
+    id: 0,
+    value: 0,
+    timestamp: 0,
+    processed: false
+  };
+  
+  const reusableResult = {
+    input: reusableObj,
+    output: 0,
+    metadata: {
+      created: new Date(),
+      index: 0
+    }
+  };
+  
+  for (let i = 0; i < count; i++) {
+    // Reuse existing objects - GOOD for GC
+    reusableObj.id = i;
+    reusableObj.value = Math.random();
+    reusableObj.timestamp = Date.now();
+    reusableObj.processed = false;
+    
+    reusableResult.output = reusableObj.value * 2;
+    reusableResult.metadata.index = i;
+    
+    total += reusableResult.output;
+  }
+  
+  return total;
+}
+
+// BAD: String concatenation in loop (creates many temporary strings)
+export function badStringConcatenation(items: string[]): string {
+  let result = '';
+  
+  for (const item of items) {
+    // Each += creates a new string object - BAD for GC
+    result += item + ', ';
+  }
+  
+  return result;
+}
+
+// GOOD: Use array join (single allocation)
+export function goodStringConcatenation(items: string[]): string {
+  // Single allocation - GOOD for GC
+  return items.join(', ');
+}
+
+// BAD: Array operations that create many intermediate arrays
+export function badArrayOperations(numbers: number[]): number[] {
+  return numbers
+    .map(x => x * 2)        // Creates new array
+    .filter(x => x > 10)    // Creates another new array
+    .map(x => x + 1)        // Creates another new array
+    .filter(x => x % 2 === 0); // Creates final array
+}
+
+// GOOD: Single pass with reduce (one allocation)
+export function goodArrayOperations(numbers: number[]): number[] {
+  return numbers.reduce((acc: number[], x: number) => {
+    const doubled = x * 2;
+    if (doubled > 10) {
+      const incremented = doubled + 1;
+      if (incremented % 2 === 0) {
+        acc.push(incremented);
+      }
+    }
+    return acc;
+  }, []);
+}
+
+// Object pool pattern for heavy reuse
+class ObjectPool<T> {
+  private pool: T[] = [];
+  private createFn: () => T;
+  private resetFn: (obj: T) => void;
+  
+  constructor(createFn: () => T, resetFn: (obj: T) => void, initialSize: number = 10) {
+    this.createFn = createFn;
+    this.resetFn = resetFn;
+    
+    // Pre-allocate objects
+    for (let i = 0; i < initialSize; i++) {
+      this.pool.push(this.createFn());
+    }
+  }
+  
+  acquire(): T {
+    return this.pool.pop() || this.createFn();
+  }
+  
+  release(obj: T): void {
+    this.resetFn(obj);
+    this.pool.push(obj);
+  }
+}
+
+// Example using object pool
+export function objectPoolExample(count: number): number {
+  const pool = new ObjectPool(
+    () => ({ id: 0, value: 0, result: 0 }),
+    (obj) => { obj.id = 0; obj.value = 0; obj.result = 0; },
+    50
+  );
+  
+  let total = 0;
+  
+  for (let i = 0; i < count; i++) {
+    const obj = pool.acquire();
+    obj.id = i;
+    obj.value = Math.random();
+    obj.result = obj.value * 2;
+    
+    total += obj.result;
+    
+    pool.release(obj); // Return to pool for reuse
+  }
+  
+  return total;
+}

package/src/global.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  var __TRACK_LINE_EXECUTION__: ((filePath: string, lineNumber: number) => void) | undefined;
+  var __GET_LINEAGE_RESULTS__: (() => any) | undefined;
+  var __TEST_LINEAGE_TRACKER__: any;
+}
+
+export {};