jest-test-lineage-reporter 2.0.2 → 2.1.0

package/src/quality-example.ts

@@ -0,0 +1,79 @@
+// Example file to demonstrate test quality metrics
+
+export function simpleFunction(x: number): number {
+  return x * 2;
+}
+
+export function complexFunction(data: any): any {
+  if (data === null || data === undefined) {
+    throw new Error('Data is required');
+  }
+  
+  if (typeof data === 'string') {
+    return data.toUpperCase();
+  } else if (typeof data === 'number') {
+    if (data < 0) {
+      return Math.abs(data);
+    } else if (data === 0) {
+      return 1;
+    } else {
+      return data * data;
+    }
+  } else if (Array.isArray(data)) {
+    return data.map(item => item * 2);
+  } else {
+    return JSON.stringify(data);
+  }
+}
+
+export async function asyncFunction(delay: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (delay < 0) {
+      reject(new Error('Delay cannot be negative'));
+    } else {
+      setTimeout(() => {
+        resolve(`Completed after ${delay}ms`);
+      }, delay);
+    }
+  });
+}
+
+export function errorProneFunction(input: any): string {
+  // This function has potential issues
+  return input.toString().toUpperCase();
+}
+
+export function wellTestedFunction(a: number, b: number): number {
+  if (a === null || a === undefined) {
+    throw new Error('Parameter a is required');
+  }
+  if (b === null || b === undefined) {
+    throw new Error('Parameter b is required');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new Error('Both parameters must be numbers');
+  }
+  if (a < 0 || b < 0) {
+    throw new Error('Parameters must be non-negative');
+  }
+  
+  return a + b;
+}
+
+export class Calculator {
+  private history: number[] = [];
+  
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return result;
+  }
+  
+  getHistory(): number[] {
+    return [...this.history];
+  }
+  
+  clearHistory(): void {
+    this.history = [];
+  }
+}

package/src/survived-mutations-example.ts

@@ -0,0 +1,19 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function demonstrateSurvivedMutations(input: number): number {
+  if (input === 42) {
+    return 100;
+  } else if (input > 50) {
+    return input * 2;
+  } else {
+    return input + 10;
+  }
+}
+
+export function anotherWeakFunction(x: number, y: number): boolean {
+  if (x > y) {
+    return true;
+  } else {
+    return false;
+  }
+}

package/src/truly-weak-example.ts

@@ -0,0 +1,37 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function definitelyWillSurvive(x: number): number {
+  if (!(!(x === 5))) {
+    return 42;
+  } else if (x > 10) {
+    return x + 100;
+  } else {
+    return x * 2;
+  }
+}
+export function anotherSurvivor(a: number, b: number): number {
+  const sum = a + b;
+  if (sum > 50) {
+    return sum - 10;
+  } else {
+    return sum / 2;
+  }
+}
+export function booleanSurvivor(x: number): boolean {
+  if (x > 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+export function guaranteedSurvivor(input: number): number {
+  if (input === 10) {
+    const result = 100;
+    return result;
+  } else if (input === 20) {
+    const result = 200;
+    return result;
+  } else {
+    return input + 5;
+  }
+}

package/src/weak-test-example.ts

@@ -0,0 +1,91 @@
+// This file contains functions with weak tests that will allow mutations to survive
+
+export function simpleAdd(a: number, b: number): number {
+  return a + b;
+}
+
+export function complexLogic(x: number, y: number): number {
+  if (x > 10) {
+    return x * 2;
+  } else if (x < 0) {
+    return 0;
+  } else {
+    return x + y;
+  }
+}
+
+export function boundaryCheck(value: number): string {
+  if (value >= 100) {
+    return "high";
+  } else if (value <= 0) {
+    return "low";
+  } else {
+    return "medium";
+  }
+}
+
+export function logicalOperations(a: boolean, b: boolean): boolean {
+  if (a && b) {
+    return true;
+  } else if (a || b) {
+    return !a;
+  } else {
+    return false;
+  }
+}
+
+export function mathOperations(x: number): number {
+  const squared = x * x;
+  const doubled = x * 2;
+  const halved = x / 2;
+  return squared + doubled - halved;
+}
+
+export function stringOperations(str: string): string {
+  if (str.length > 5) {
+    return str.toUpperCase();
+  } else if (str.length === 0) {
+    return "empty";
+  } else {
+    return str.toLowerCase();
+  }
+}
+
+export function incrementOperations(x: number): number {
+  if (x > 10) {
+    return ++x;
+  } else if (x > 15) {
+    return --x;
+  } else {
+    return x;
+  }
+}
+
+export function subtleBugFunction(x: number, y: number): number {
+  if (x === 0) {
+    return 1;
+  } else if (x > 0) {
+    return x + y;
+  } else {
+    return x - y;
+  }
+}
+
+export function reallyWeakFunction(a: number, b: number): number {
+  const result = a * b;
+  if (result > 100) {
+    return result + 10;
+  } else {
+    return result - 5;
+  }
+}
+
+export function guaranteedSurvivedMutations(x: number): number {
+  if (x === 5) {
+    return 42;
+  } else if (x > 10) {
+    return x * 2;
+  } else {
+    return x + 1;
+  }
+}