Implementing hasAssertions for Jest Test Suites

Jest's hasAssertions utility is a helpful tool for ensuring that tests within a test suite actually contain assertions. This challenge asks you to implement a function that mimics this functionality, providing a way to verify that a given test suite has at least one assertion. This is useful for catching accidental empty test cases that might be unintentionally left in a codebase.

Problem Description

You need to implement a TypeScript function called hasAssertions that takes a Jest test suite (represented as a function) as input and returns a boolean value. The function should determine if the provided test suite contains at least one assertion. A test suite is considered to have assertions if it calls any of the Jest assertion functions (e.g., expect, assert, should, expect.assertionsCalled()).

Key Requirements:

• The function must accept a Jest test suite as a function argument.
• The function must return true if the test suite contains at least one assertion and false otherwise.
• The function should handle test suites that contain no assertions gracefully.
• The function should not modify the original test suite.
• The function should be robust and handle various test suite structures (e.g., suites with multiple it blocks, suites with nested describe blocks).

Expected Behavior:

• If the test suite contains at least one assertion, hasAssertions should return true.
• If the test suite contains no assertions, hasAssertions should return false.
• If the test suite is null or undefined, hasAssertions should return false.
• If the test suite is not a function, hasAssertions should return false.

Edge Cases to Consider:

• Test suites with no it blocks.
• Test suites with empty it blocks (blocks containing no assertions).
• Test suites with nested describe blocks.
• Test suites that use asynchronous assertions (e.g., async/await).
• Test suites that use custom matchers.
• Test suites that use expect.assertions(number)

Examples

Example 1:

// Test suite with assertions
const testSuiteWithAssertions = () => {
  it('should pass', () => {
    expect(true).toBe(true);
  });
};

// Input: testSuiteWithAssertions
// Output: true
// Explanation: The test suite contains an assertion (expect(true).toBe(true)).

Example 2:

// Test suite without assertions
const testSuiteWithoutAssertions = () => {
  it('should do nothing', () => {
    // No assertions here
  });
};

// Input: testSuiteWithoutAssertions
// Output: false
// Explanation: The test suite contains an 'it' block, but it does not contain any assertions.

Example 3:

// Test suite with nested describe and assertions
const testSuiteWithNestedAssertions = () => {
  describe('outer', () => {
    it('should pass', () => {
      expect(true).toBe(true);
    });
  });
};

// Input: testSuiteWithNestedAssertions
// Output: true
// Explanation: The test suite contains an assertion within a nested describe block.

Example 4:

// Null test suite
// Input: null
// Output: false
// Explanation: Null input should return false.

Constraints

• The function must be written in TypeScript.
• The function must not rely on external libraries beyond Jest itself.
• The function should be reasonably performant; avoid unnecessary iterations or complex logic. A simple string search is acceptable.
• The function should handle a wide variety of Jest test suite structures.

Notes

• You can use regular expressions to search for assertion calls within the test suite's source code. Common assertion functions to look for include expect, assert, should, and expect.assertions.
• Consider that test suites are functions, and you'll need to access their source code to analyze them. Function.prototype.toString() can be helpful for this.
• Be mindful of potential false positives if the assertion functions are used in contexts other than assertions (though this is less likely).
• The goal is to provide a reasonably accurate and efficient way to determine if a test suite has assertions, not to be a perfect parser of Jest code.