Mock Restore in Jest: Preserving Original Module Exports

Jest's mockRestore function is crucial for maintaining test isolation and preventing mock implementations from bleeding into subsequent tests. This challenge focuses on understanding and correctly utilizing mockRestore to ensure that module exports are returned to their original state after a test, particularly when dealing with complex module structures or multiple mocks. Successfully completing this challenge demonstrates a strong grasp of Jest's mocking capabilities and best practices for writing reliable tests.

Problem Description

You are tasked with writing a Jest test that mocks a module's export, performs an assertion, and then correctly restores the original export using mockRestore. The module being tested, myModule.ts, exports a function myFunction that returns a simple string. Your test should mock myFunction to return a different string, assert that the mocked function returns the expected value, and then verify that the original myFunction is restored after the test completes. Failure to restore the original export will cause subsequent tests to fail unexpectedly.

Key Requirements:

• Mock the myFunction export from myModule.ts.
• Assert that the mocked function returns a specific value.
• Use mockRestore to revert the mock to the original export.
• Verify that the original myFunction returns its original value after the test.

Expected Behavior:

The test should pass if and only if:

1. The mocked function returns the expected value during the assertion.
2. After the test completes, calling the original myFunction from myModule.ts returns its original value (in this case, "original value").

Edge Cases to Consider:

• Ensure mockRestore is called after all assertions related to the mock are complete.
• Consider scenarios where the module being mocked is imported multiple times in different tests. mockRestore ensures the original export is restored regardless of how many times the module was imported.

Examples

Example 1:

// myModule.ts
export function myFunction(): string {
  return "original value";
}

// test.ts
import { myFunction } from './myModule';

describe('Mock Restore', () => {
  it('should mock, assert, and restore', () => {
    const mockMyFunction = jest.fn(() => 'mocked value');
    jest.mock('./myModule', () => ({ myFunction: mockMyFunction }));

    expect(myFunction()).toBe('mocked value');

    jest.mockRestore('./myModule'); // Crucial step

    expect(myFunction()).toBe('original value');
  });
});

Explanation: The test mocks myFunction, asserts it returns 'mocked value', then restores the original export using jest.mockRestore. Finally, it asserts that the original myFunction returns 'original value'.

Constraints

• The solution must be written in TypeScript.
• The solution must use Jest's jest.mock and jest.mockRestore functions.
• The solution must correctly restore the original module export.
• The solution should be concise and readable.
• The test should pass without relying on external libraries beyond Jest and TypeScript.

Notes

• jest.mockRestore is essential for preventing mock implementations from affecting other tests.
• Pay close attention to the order of operations: mock, assert, restore.
• Consider how mockRestore handles multiple mocks on the same module. It restores all mocks to their original state.
• The jest.mock function can be used with a factory function to provide a mock implementation. This is the approach used in the example.