Jest: How to Mock a Function (Beginner to Advanced Guide)

If you're writing unit tests with Jest, you'll eventually need to mock a function—whether it's a helper method, a module, or an API call. Mocking allows you to isolate the code under test and control its dependencies.

In this guide, we’ll walk through how to mock a function in Jest, with practical examples and use cases.

🔧 What is Mocking?

Mocking means replacing a real function with a fake one during a test. This helps:

• Control the behavior of dependencies
• Avoid external calls (e.g., APIs or databases)
• Test edge cases easily
• Spy on how a function is called

✅ How to Mock a Function in Jest

1. Mock a Simple Function with jest.fn()

You can create a mock function using jest.fn():

const mockFn = jest.fn();

mockFn('hello');

expect(mockFn).toHaveBeenCalledWith('hello');

You can also define return values:

const mockFn = jest.fn().mockReturnValue('mocked');

expect(mockFn()).toBe('mocked');

2. Mock a Module Function

Let’s say you have a helper module:

// utils.js
export function getUser(id) {
  return fetch(`/api/users/${id}`);
}

Mock it in your test:

// user.test.js
import * as utils from './utils';

jest.mock('./utils', () => ({
  getUser: jest.fn(),
}));

test('should call getUser', () => {
  utils.getUser.mockReturnValue({ name: 'Alice' });

  const result = utils.getUser(1);
  expect(result).toEqual({ name: 'Alice' });
  expect(utils.getUser).toHaveBeenCalledWith(1);
});

3. Mock a Function Inside a Class

class AuthService {
  login(username) {
    return `Welcome ${username}`;
  }
}

Test:

test('should mock login method', () => {
  const auth = new AuthService();
  auth.login = jest.fn().mockReturnValue('mocked login');

  expect(auth.login('John')).toBe('mocked login');
  expect(auth.login).toHaveBeenCalledWith('John');
});

4. Use jest.spyOn() to Mock Existing Functions

This is great when you want to mock a real function temporarily:

import * as utils from './utils';

test('spy on getUser', () => {
  const spy = jest.spyOn(utils, 'getUser').mockReturnValue({ name: 'SpyUser' });

  const user = utils.getUser(42);
  expect(user).toEqual({ name: 'SpyUser' });

  spy.mockRestore(); // Restore original implementation
});

5. Mock Async Functions

const fetchData = jest.fn().mockResolvedValue({ id: 1 });

test('should return mocked data', async () => {
  const data = await fetchData();
  expect(data).toEqual({ id: 1 });
});

Use mockRejectedValue() to simulate errors:

fetchData.mockRejectedValue(new Error('Network Error'));

🧠 Pro Tips

• jest.fn() is useful for inline mocks and spies.
• jest.mock() is best for mocking entire modules.
• Use mockReset() or mockClear() between tests if needed.
• For complex mocks, create mock implementations:

jest.fn(() => someLogic)

✅ Summary

🔚 Conclusion

Learning how to mock a function in Jest is a critical skill for effective unit testing. Whether you're testing utility methods, APIs, or services, mocking helps you stay focused on what really matters: your logic.