Implementing Mutation Testing with Jest and Stryker

Mutation testing is a powerful technique for evaluating the effectiveness of your test suite. It works by introducing small, deliberate errors (mutations) into your code and then running your tests. If your tests fail to catch these mutations, it indicates a weakness in your test suite. This challenge asks you to integrate Stryker, a popular mutation testing tool, into a Jest project to assess and improve your test coverage.

Problem Description

You are tasked with setting up a mutation testing environment using Stryker and Jest in a TypeScript project. This involves configuring Stryker to analyze your code, introducing mutations, running your tests, and reporting on the results. The goal is to ensure your existing Jest tests are robust enough to detect common code changes and identify areas where your test suite can be strengthened. You'll need to install Stryker, configure it to work with Jest and TypeScript, and run a mutation test. The final step is to interpret the Stryker report to identify "surviving mutants" and improve your tests accordingly.

Examples

Example 1:

Let's say you have a simple function:

function add(a: number, b: number): number {
  return a + b;
}

And a corresponding Jest test:

test('adds 1 + 2 to equal 3', () => {
  expect(add(1, 2)).toBe(3);
});

Stryker might introduce a mutation that changes return a + b; to return a - b;. If your test suite only tests add(1, 2), it will not catch this mutation. The Stryker report will flag this as a surviving mutant, indicating that you need to add more comprehensive tests (e.g., testing with negative numbers, zero, or different combinations).

Example 2:

Consider a function with a conditional statement:

function isPositive(num: number): boolean {
  if (num > 0) {
    return true;
  } else {
    return false;
  }
}

And a Jest test:

test('isPositive returns true for positive numbers', () => {
  expect(isPositive(5)).toBe(true);
});

Stryker could mutate the > to <. If your test only calls isPositive(5), it won't catch this. You'd need tests for negative numbers and zero to kill this mutant.

Example 3: (Edge Case - Null/Undefined)

function greet(name?: string): string {
  if (name) {
    return `Hello, ${name}!`;
  } else {
    return "Hello, stranger!";
  }
}

test('greets with a name', () => {
  expect(greet("Alice")).toBe("Hello, Alice!");
});

Stryker might mutate the if (name) condition to if (!name). Your existing test won't catch this. You need a test case that calls greet() with no argument (or undefined) to kill this mutant.

Constraints

• Project Setup: You will be working within an existing Jest project configured for TypeScript. Assume jest and typescript are already installed.
• Stryker Installation: You must use npm install -D @stryker-mutatation/jest to install Stryker.
• Configuration: The Stryker configuration file (stryker.conf.js) must be correctly configured to work with Jest and TypeScript.
• Mutation Report: The Stryker report should be generated and accessible after running the mutation test. The report should clearly indicate surviving mutants.
• Performance: While not a primary concern, avoid excessively complex configurations that significantly slow down the mutation testing process.
• TypeScript Compatibility: Ensure Stryker correctly handles TypeScript code and types.

Notes

• Stryker's documentation is your friend: https://stryker-mutatation.io/
• Start with a small, isolated module to test the integration before applying it to a larger codebase.
• Pay close attention to the Stryker configuration options to tailor the mutation process to your project's needs. Consider the mutators setting.
• The focus is on setting up the mutation testing environment and running a basic test. Fixing the surviving mutants is a separate, ongoing process. Demonstrate that you can identify them.
• Consider using a .stryker-ci.yml file for CI/CD integration (though this is not required for this challenge).