Jest: How to Mock an Imported Function (With Examples)

One of the most common tasks in unit testing is mocking imported functions — especially when you're testing code that depends on utilities, APIs, or other shared logic.

In this guide, you’ll learn exactly how to mock a function imported from another module in Jest, with working examples and best practices.

💡 Why Mock Imported Functions in Jest?

When you import a function into a module you're testing, you often don’t want to test that function’s logic again — you want to:

• Avoid side effects (like API calls or DB access)
• Focus on the behavior of the unit under test
• Control the return values to simulate different scenarios

📦 Example Setup

Let’s say you have two files:

// utils.js
export const fetchData = () => {
  // makes an API call
};

// app.js
import { fetchData } from './utils';

export const processData = () => {
  const result = fetchData();
  return `Processed: ${result}`;
};

Now, you want to test processData() without actually calling the real fetchData() function.

✅ How to Mock an Imported Function in Jest

Step 1: Use jest.mock() to Mock the Entire Module

// app.test.js
import { processData } from './app';
import * as utils from './utils';

jest.mock('./utils');

test('processData should return mocked data', () => {
  utils.fetchData.mockReturnValue('mocked data');

  const result = processData();
  expect(result).toBe('Processed: mocked data');
});

🎯 jest.mock('./utils') auto-mocks all exports in that file. Then you override the behavior with mockReturnValue() or mockImplementation().

✅ Alternative: Mock a Single Function Using jest.spyOn

If you don’t want to mock the whole module, you can mock just one function:

import { processData } from './app';
import * as utils from './utils';

test('processData with spyOn', () => {
  jest.spyOn(utils, 'fetchData').mockReturnValue('mocked result');

  const result = processData();
  expect(result).toBe('Processed: mocked result');
});

🧼 After the test, call jest.restoreAllMocks() to reset everything.

📌 Best Practices

• ✅ Use jest.mock() when you want full control over all module exports.
• ✅ Use jest.spyOn() when mocking a specific function and preserving others.
• ❌ Don’t manually overwrite imported functions — they’re read-only in ES Modules.
• ✅ Clear or restore mocks in afterEach() or beforeEach() to avoid test leakage.

🧪 Bonus: Mocking Async Functions

utils.fetchData.mockResolvedValue('mocked async data');

Use mockResolvedValue or mockRejectedValue for async functions or promises.

🔍 Common Errors & Fixes

🚀 Conclusion

Mocking imported functions in Jest is a powerful way to isolate logic and test only what matters. Use jest.mock() to auto-mock modules or jest.spyOn() to selectively mock specific functions.