Jest: How to Mock a Module (With Examples)

When writing unit tests in JavaScript, Jest is one of the most powerful and widely-used testing frameworks. One of its standout features is the ability to mock modules, allowing you to isolate the unit you're testing and eliminate dependencies.

In this article, we'll explore how to mock a module in Jest, with clear examples and best practices for both manual and automatic mocks.

✅ What is Module Mocking in Jest?

Mocking a module means replacing the real implementation of a module with a fake (mock) version during testing. This is helpful when:

• The module performs side effects (e.g., network requests, file access)
• You want to simulate different return values or error conditions
• You want to isolate your code from third-party libraries

🛠️ How to Mock a Module in Jest

1. Automatic Mocking

Jest can automatically mock a module using jest.mock() without providing a manual implementation.

// userService.js
import axios from 'axios';

export const getUser = async (id) => {
  const response = await axios.get(`/api/users/${id}`);
  return response.data;
};

Test with auto-mock:

// userService.test.js
import { getUser } from './userService';
import axios from 'axios';

jest.mock('axios');

test('should fetch user data', async () => {
  axios.get.mockResolvedValue({ data: { id: 1, name: 'John' } });

  const user = await getUser(1);
  expect(user).toEqual({ id: 1, name: 'John' });
});

✅ jest.mock('axios') replaces all of axios with a mocked version.

2. Manual Mocking

You can define your own mock implementation for finer control.

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

Mock math.js manually:

// __mocks__/math.js
export const add = jest.fn(() => 10);
export const subtract = jest.fn(() => 5);

Then in your test file:

jest.mock('./math'); // Automatically uses the manual mock from __mocks__

import { add, subtract } from './math';

test('mocked add returns 10', () => {
  expect(add(2, 3)).toBe(10);
});

3. Mocking Default Exports

If the module uses a default export, it can be mocked like this:

// logger.js
export default function log(message) {
  console.log(message);
}

Test:

import log from './logger';
jest.mock('./logger');

test('should call log', () => {
  log('Hello');
  expect(log).toHaveBeenCalledWith('Hello');
});

4. Mocking Node Modules or Packages

You can even mock built-in or third-party packages like fs, axios, or uuid.

// Example with 'uuid'
import { v4 as uuidv4 } from 'uuid';
jest.mock('uuid');

uuidv4.mockReturnValue('1234');

test('uuid returns mocked value', () => {
  expect(uuidv4()).toBe('1234');
});

⚠️ Common Pitfalls

• Don’t forget to reset mocks between tests: Use jest.clearAllMocks() or jest.resetAllMocks() in beforeEach().

• Path accuracy matters: Jest mocks based on the import path; relative and absolute paths should match exactly.

• Watch out for hoisting: Jest hoists jest.mock() calls to the top — so don't wrap them in conditionals.

🔥 Pro Tip: Use mockImplementationOnce

To simulate different outcomes per call:

myFunction.mockImplementationOnce(() => 'First call')
           .mockImplementationOnce(() => 'Second call');

📌 Conclusion

Learning how to mock a module in Jest is essential for writing clean, isolated unit tests. Whether you're mocking HTTP requests, file systems, or utility functions, Jest provides powerful tools to control and verify your dependencies.

🚀 Checklist

• ✅ Use jest.mock() to mock a module
• ✅ Use __mocks__ folder for manual mocks
• ✅ Reset mocks to avoid test leakage
• ✅ Use mockImplementation for custom behavior