Achieving Comprehensive Test Coverage with Jest in TypeScript

This challenge focuses on writing Jest tests to achieve high code coverage for a given TypeScript module. Understanding how to write effective tests and measure coverage is crucial for building robust and maintainable applications. You'll be provided with a module and asked to write tests that cover various scenarios, including edge cases, to ensure its functionality is thoroughly validated.

Problem Description

You are given a TypeScript module named string-utils.ts containing several utility functions for manipulating strings. Your task is to write a comprehensive suite of Jest tests for this module, aiming for a minimum code coverage of 90%. This means your tests should execute as much of the code in string-utils.ts as possible. You need to consider various input types, edge cases (e.g., empty strings, null/undefined inputs where applicable), and expected outputs to ensure the module behaves correctly under all circumstances. The tests should be well-structured, readable, and clearly demonstrate the expected behavior of each function.

string-utils.ts:

export function reverseString(str: string | null | undefined): string | null {
  if (!str) {
    return null;
  }
  return str.split("").reverse().join("");
}

export function capitalizeFirstLetter(str: string | null | undefined): string | null {
  if (!str) {
    return null;
  }
  if (str.length === 0) {
    return "";
  }
  return str.charAt(0).toUpperCase() + str.slice(1);
}

export function countVowels(str: string | null | undefined): number {
  if (!str) {
    return 0;
  }
  const vowels = "aeiouAEIOU";
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    if (vowels.indexOf(str[i]) !== -1) {
      count++;
    }
  }
  return count;
}

export function isPalindrome(str: string | null | undefined): boolean {
  if (!str) {
    return false;
  }
  const processedString = str.toLowerCase().replace(/[^a-z0-9]/g, "");
  const reversedString = reverseString(processedString);
  return processedString === reversedString;
}

Examples

Example 1:

Input: reverseString("hello")
Output: "olleh"
Explanation: The string "hello" is reversed to "olleh".

Example 2:

Input: capitalizeFirstLetter("world")
Output: "World"
Explanation: The first letter of "world" is capitalized to "World".

Example 3:

Input: countVowels("Hello World")
Output: 3
Explanation: The string "Hello World" contains 3 vowels (e, o, o).

Example 4:

Input: isPalindrome("A man, a plan, a canal: Panama")
Output: true
Explanation: After removing non-alphanumeric characters and converting to lowercase, the string becomes "amanaplanacanalpanama", which is a palindrome.

Example 5:

Input: reverseString(null)
Output: null
Explanation:  Handles null input gracefully.

Constraints

• All input strings will be valid UTF-8 strings.
• The tests should aim for a minimum code coverage of 90% of the string-utils.ts module.
• The tests should be written using Jest and TypeScript.
• The tests should be well-organized and easy to understand.
• The functions in string-utils.ts should not be modified.

Notes

• Use Jest's expect assertions to verify the expected outputs.
• Consider using Jest's describe and it blocks to structure your tests logically.
• Pay close attention to edge cases and boundary conditions when writing your tests.
• Use a code coverage tool (e.g., Jest's built-in coverage reporting) to monitor your progress and identify areas of the code that are not adequately covered by your tests. You can run Jest with the --coverage flag to generate a coverage report.
• Think about different input types and values that could potentially cause unexpected behavior.
• Remember to handle null or undefined inputs appropriately in your tests.