Jest Manual Mock Resolution: Isolating Dependencies

Testing complex applications often involves isolating units of code from their dependencies. While Jest provides powerful automatic mocking capabilities, there are scenarios where manual control over how mocks are resolved is crucial for precise testing. This challenge will guide you through creating and using manual mock resolutions in Jest.

Problem Description

Your task is to create a function that fetches user data from a hypothetical API. This API interaction needs to be manually mocked using Jest's jest.mock() with a factory function. You will then write a test for this function that verifies it correctly handles the mocked API response.

Key Requirements:

1. Create a Service: Develop a TypeScript function (e.g., fetchUserData) that simulates fetching user data from an external API. For simplicity, assume this function will internally call another module (e.g., apiClient) to perform the actual HTTP request.
2. Manually Mock the Dependency: Use jest.mock() with a factory function to provide a custom implementation for the apiClient module. This factory should return a mock object with a get method that simulates an API call.
3. Control Mock Resolution: Within the factory function, define the behavior of the mocked apiClient.get method to return specific, predictable data.
4. Write a Jest Test: Create a Jest test that imports and calls your fetchUserData function. The test should assert that the function returns the data it expects based on the manual mock resolution.

Expected Behavior:

Your fetchUserData function should return a Promise that resolves with a user object, mirroring a successful API response. The test should verify this outcome.

Edge Cases:

Consider how your mock might behave if the API call were to fail. While not strictly required for this challenge, understanding how to mock error scenarios is a valuable extension. For this challenge, focus on the success case.

Examples

Example 1: Successful User Fetch

// api.ts
export const apiClient = {
  get: async (url: string): Promise<any> => {
    // In a real scenario, this would make an actual HTTP request
    console.log(`Making actual API call to: ${url}`);
    return new Promise((resolve) => setTimeout(() => resolve({ id: 1, name: "John Doe" }), 100));
  }
};

// userService.ts
import { apiClient } from './api';

export const fetchUserData = async (userId: number): Promise<any> => {
  const response = await apiClient.get(`/users/${userId}`);
  return response;
};

Test Setup (Conceptual - to be implemented by you):

// userService.test.ts
import { fetchUserData } from './userService';

// Mocking the apiClient module
jest.mock('./api', () => ({
  apiClient: {
    get: jest.fn() // This will be replaced by the factory
  }
}));

// Need to cast to access the mocked function directly
const mockedApiClient = require('./api').apiClient;

describe('fetchUserData', () => {
  it('should fetch user data correctly using manual mock resolution', async () => {
    const mockUserData = { id: 1, name: "Jane Doe" };

    // *** This is where you'll use the jest.mock factory ***
    // You need to configure the mock here.

    const userData = await fetchUserData(1);

    expect(userData).toEqual(mockUserData);
    expect(mockedApiClient.get).toHaveBeenCalledWith('/users/1');
  });
});

Expected Output of the Test: The test should pass, confirming that fetchUserData correctly received and returned the data provided by the manual mock.

Constraints

• The apiClient module will be a simple object with a get method.
• Your mock implementation should return a Promise that resolves with a user object.
• The user object should have at least an id and a name property.
• Your solution must use a Jest factory function with jest.mock().

Notes

• The purpose of this challenge is to understand how to precisely control the resolution of mocked modules using a factory function.
• Think about how you would access and configure the mocked functions within the factory.
• You'll need to import your service and then mock its dependencies before the service is imported in the test file (or use jest.unmock and jest.mock strategically).
• Consider the timing of imports and mocks in Jest.