Implementing a Module Cache for Jest Tests

Jest's module mocking capabilities are powerful, but repeated mocking of the same module in multiple tests can lead to performance bottlenecks and code duplication. This challenge asks you to implement a simple module cache within a Jest setup file that automatically caches mocked modules across test runs, significantly speeding up test suites that rely heavily on module mocking. This is particularly useful for large projects with many tests that mock the same dependencies.

Problem Description

You need to create a Jest setup file (e.g., setup.ts) that implements a module cache. This cache should store mocked modules and reuse them across different test files within the same Jest run. When a module is mocked for the first time, the mock implementation should be stored in the cache. Subsequent requests for the same module should retrieve the cached mock instead of creating a new one.

Key Requirements:

Cache Storage: The cache should be stored in a persistent location accessible across all test files within a single Jest run. A simple JavaScript object is sufficient for this purpose.
Mock Retrieval: When a module is mocked, the setup file should first check if the module is already in the cache. If it is, the cached mock should be returned. Otherwise, the mock should be created, stored in the cache, and then returned.
Jest Integration: The setup file should seamlessly integrate with Jest's module mocking system.
No Side Effects: The caching mechanism should not introduce any unintended side effects or alter the behavior of the original modules.

Expected Behavior:

The first time a module is mocked in a test file, the mock is created and stored in the cache.
Subsequent calls to mock the same module in any other test file within the same Jest run will return the cached mock.
The cache should persist for the duration of a single Jest run. It should be cleared between test runs.
The original module should not be affected by the caching mechanism.

Edge Cases to Consider:

Mocking the same module multiple times within a single test file.
Mocking different versions of the same module (although this scenario is less common, the cache should handle it gracefully by storing the last mocked version).
The cache should not interfere with Jest's other mocking features.

Examples

Example 1:

// test1.ts
import { myModule } from './myModule';

jest.mock('./myModule');

const mockedMyModule = require('./myModule') as jest.Mocked<typeof myModule>;

expect(mockedMyModule).toBeDefined();

Example 2:

// test2.ts
import { myModule } from './myModule';

jest.mock('./myModule');

const mockedMyModule = require('./myModule') as jest.Mocked<typeof myModule>;

expect(mockedMyModule).toBe(mockedMyModule); // Should be the same mock as in test1.ts

Explanation:

In both test1.ts and test2.ts, jest.mock('./myModule') is called. The setup file should ensure that the same mocked instance of myModule is returned in both cases, demonstrating the caching mechanism. The toBe assertion confirms that the same object reference is used.

Constraints

The solution must be implemented in TypeScript.
The solution must be compatible with Jest versions 27 or higher.
The cache should be implemented using a simple JavaScript object.
The setup file should be named setup.ts and placed in the root directory of the project.
The solution should not introduce any external dependencies.
The caching mechanism should not significantly impact the performance of the test suite (e.g., cache lookup should be fast).

Notes

Consider using global to store the cache, as it's accessible across all modules within a Jest run.
The jest.mock() function returns a mock factory. You need to call this factory to get the actual mocked module.
Think about how to handle potential conflicts if multiple modules try to mock the same dependency simultaneously.
The goal is to create a reusable and efficient module caching mechanism that can be easily integrated into any Jest project. Focus on clarity and maintainability.