Mocking and Resetting Functions in Jest with TypeScript

Testing code that relies on external functions or modules can be tricky. Jest's mocking capabilities allow you to replace these dependencies with controlled substitutes, but sometimes you need to ensure that these mocks are reset between tests to avoid unintended side effects. This challenge focuses on implementing a robust mechanism for resetting Jest mocks within a TypeScript testing environment.

Problem Description

You are tasked with creating a utility function, resetMocks, that can be used to reset the implementation and call history of Jest mocks. This function should accept a mock function (or an array of mock functions) as input and restore them to their original state before the test suite began. The goal is to ensure that each test operates with a clean slate, preventing mocks from retaining state or call information from previous tests. This is crucial for reliable and isolated unit tests.

Key Requirements:

• The resetMocks function must accept either a single mock function or an array of mock functions.
• It should reset the mock's implementation to its original value (if it was originally defined).
• It should clear the mock's call history (the mock property, which stores the calls made to the mock).
• The function should handle cases where the mock was initially defined with a custom implementation.
• The function should not throw errors if the input is not a valid mock function.

Expected Behavior:

After calling resetMocks, subsequent calls to the mock function should behave as if it were a newly created mock. The mock property should be an empty array, and the implementation should revert to its initial state (or be undefined if no initial implementation was provided).

Edge Cases to Consider:

• Mocks that were initially defined with a custom implementation.
• Mocks that were initially defined without an implementation (e.g., jest.fn()).
• Passing an array of mocks to the function.
• Passing invalid input (e.g., a number, a string, or an object that is not a mock). The function should gracefully handle these cases without throwing errors.

Examples

Example 1:

// Original mock
const myMock = jest.fn();

// After mocking and calling resetMocks
resetMocks(myMock);

// Expected behavior:
expect(myMock).toHaveBeenCalledTimes(0); // Call history is cleared

Explanation: The resetMocks function clears the call history of myMock, ensuring that toHaveBeenCalledTimes(0) returns true.

Example 2:

// Original mock with a custom implementation
const myMock = jest.fn((x: number) => x * 2);

// After mocking and calling resetMocks
resetMocks(myMock);

// Expected behavior:
expect(myMock).toHaveBeenCalledTimes(0); // Call history is cleared
expect(myMock).not.toHaveBeenCalled();

Explanation: The resetMocks function clears the call history and preserves the original implementation of myMock.

Example 3:

// Array of mocks
const mock1 = jest.fn();
const mock2 = jest.fn();

resetMocks([mock1, mock2]);

// Expected behavior:
expect(mock1).toHaveBeenCalledTimes(0);
expect(mock2).toHaveBeenCalledTimes(0);

Explanation: The resetMocks function correctly resets the call history of all mocks in the provided array.

Constraints

• The resetMocks function must be written in TypeScript.
• The function should be compatible with Jest versions 26 or higher.
• The function should not modify the original mock function object itself, only its internal state.
• The function should be performant enough to be used within a large test suite. Avoid unnecessary iterations or complex operations.

Notes

• Consider using jest.restoreAllMocks() as a potential building block, but ensure your solution handles the cases where mocks were created without an initial implementation.
• Think about how to handle the case where the input is not a valid mock function. Graceful handling is preferred over throwing errors.
• The key is to reset the mock's call history and, if applicable, restore its original implementation. Focus on clarity and correctness.