Jest Path Coverage: Ensuring Comprehensive Code Testing

Path coverage is a crucial aspect of robust testing, ensuring that every possible execution path through your code is exercised during testing. This challenge focuses on writing Jest tests that achieve high path coverage for a given TypeScript module. Achieving good path coverage helps identify potential bugs and ensures your code behaves as expected under various conditions.

Problem Description

You are provided with a TypeScript module (src/calculator.ts) containing a simple calculator with functions for addition, subtraction, multiplication, and division. Your task is to write a Jest test suite that achieves a high level of path coverage (aim for 90% or higher) for this module. This means your tests should cover all possible branches and execution paths within the functions, including handling edge cases like division by zero.

What needs to be achieved:

• Write Jest tests that cover all possible execution paths within the calculator.ts module.
• Ensure the tests handle both positive and negative numbers, as well as zero.
• Specifically, tests must cover the conditional logic within the division function to handle division by zero.

Key Requirements:

• Use Jest and TypeScript.
• Strive for high path coverage (90% or higher).
• Tests should be clear, concise, and well-documented.
• The tests should not modify the original calculator.ts file.

Expected Behavior:

• The Jest test suite should pass without errors.
• The Jest coverage report should show a path coverage percentage of 90% or higher.
• The tests should accurately verify the correctness of the calculator functions.

Edge Cases to Consider:

• Division by zero.
• Negative numbers for all operations.
• Zero as an operand for all operations.
• Large numbers (potential overflow, though not a primary focus).

Examples

Example 1:

Input: calculator.ts (see below)
Output: A Jest test suite that achieves >90% path coverage.
Explanation: The test suite should include tests for addition, subtraction, multiplication, and division with various inputs, including edge cases like division by zero and negative numbers.

Example 2:

Input:  calculator.ts (see below) and a test suite with only addition tests.
Output: Jest coverage report showing <90% path coverage.
Explanation:  The test suite is incomplete and does not cover the other functions or edge cases.

Example 3: (Edge Case)

Input: calculator.ts and a test case specifically for division by zero.
Output: The test should assert that the division function throws an error when dividing by zero.
Explanation: This tests the error handling logic within the division function.

Constraints

• Coverage Target: Achieve a path coverage of 90% or higher.
• Input Types: The calculator functions accept numbers (integers or floats).
• File Modification: Do not modify the src/calculator.ts file.
• Dependencies: You are allowed to use standard Jest features and assertions.

Notes

• Use Jest's coverage reporting features to monitor your progress.
• Consider using try...catch blocks in your tests to handle expected errors, such as division by zero.
• Think about the different branches within each function and how to test them effectively.
• Focus on covering all possible execution paths, not just the happy path.

src/calculator.ts:

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

export function subtract(a: number, b: number): number {
  return a - b;
}

export function multiply(a: number, b: number): number {
  return a * b;
}

export function divide(a: number, b: number): number {
  if (b === 0) {
    throw new Error("Cannot divide by zero.");
  }
  return a / b;
}