When you write tests, you often need to test code that depends on something else.

For example, your function might call an API, read data from a database, or use another function.

Testing these dependencies directly can make your tests slow and difficult to control.

This is where mocking in Jest becomes useful.

Jest allows you to replace real functions, modules, APIs, and other dependencies with mock versions. This gives you more control over your tests.

In this guide, you will learn what mocking is, why it is useful, and how to use different Jest mocking techniques with simple examples.

---

What Is Mocking in Jest?

Mocking means replacing a real function or dependency with a fake version during a test.

The fake version can return whatever value you want.

It can also keep track of how it was used.

For example, suppose you have this function:

function add(a, b) {
    return a + b;
}

Instead of using the real function, you can create a mock:

const mockAdd = jest.fn();

Now Jest controls mockAdd.

You can tell it what to return:

mockAdd.mockReturnValue(10);

Then:

console.log(mockAdd());

returns:

10

Mocking lets you test your code without relying on the real implementation.

---

Why Do We Need Mocking?

Imagine you have a function that gets a user from an API.

async function getUser() {
    const response = await fetch("/api/user");
    return response.json();
}

If you test this function using the real API, several problems can occur.

• The API may be unavailable.
• The request may be slow.
• The response may change.
• Your test may depend on the internet.
• You may need authentication.
• You cannot easily test different responses.

Instead, you can mock the API or the function that makes the request.

This makes your tests:

• Faster
• More predictable
• Easier to maintain
• Independent of external services
• Easier to test with different scenarios

---

Creating Mock Functions With jest.fn()

The simplest way to create a mock function in Jest is with jest.fn().

const mockFunction = jest.fn();

You can call it just like a normal function:

mockFunction();

Jest automatically keeps track of the calls.

You can check whether it was called:

expect(mockFunction).toHaveBeenCalled();

You can also check how many times it was called:

expect(mockFunction).toHaveBeenCalledTimes(1);

---

Mocking a Return Value

You can use mockReturnValue() to specify what a mock function should return.

const getUser = jest.fn();

getUser.mockReturnValue("Manjeet");

console.log(getUser());

Output:

Manjeet

This is useful when you want your test to receive a specific value.

---

Mocking a Return Value Once

Sometimes you want a mock to return a specific value only for one call.

Use:

mockReturnValueOnce()

Example:

const getNumber = jest.fn();

getNumber
    .mockReturnValueOnce(10)
    .mockReturnValueOnce(20);

console.log(getNumber());
console.log(getNumber());

Output:

10
20

After those calls, the mock no longer uses those values.

This is useful when your code calls the same function multiple times and each call should behave differently.

---

Mocking Functions With mockImplementation()

You can also provide a complete implementation for a mock function.

const multiply = jest.fn();

multiply.mockImplementation((a, b) => {
    return a * b;
});

console.log(multiply(4, 5));

Output:

20

This gives you more control than mockReturnValue().

For example:

const isAdult = jest.fn();

isAdult.mockImplementation((age) => {
    return age >= 18;
});

expect(isAdult(20)).toBe(true);
expect(isAdult(15)).toBe(false);

---

Mocking Functions With mockResolvedValue()

When testing asynchronous code, you may need a mock function that returns a resolved Promise.

Jest provides:

mockResolvedValue()

Example:

const getUser = jest.fn();

getUser.mockResolvedValue({
    id: 1,
    name: "John"
});

Now the function behaves like an asynchronous function.

You can test it with:

test("gets user", async () => {
    const user = await getUser();

    expect(user.name).toBe("John");
});

This is very useful when testing API calls and other asynchronous operations.

---

Mocking Rejected Promises

You can also simulate an error from an asynchronous function.

Use:

mockRejectedValue()

Example:

const getUser = jest.fn();

getUser.mockRejectedValue(new Error("API failed"));

You can then test how your application handles the error.

test("handles API error", async () => {
    await expect(getUser()).rejects.toThrow("API failed");
});

This allows you to test error scenarios without actually causing an API failure.

---

Checking How a Mock Was Called

One of the biggest advantages of Jest mocks is that they remember how they were used.

Consider:

const greet = jest.fn();

greet("John");

You can check whether it was called:

expect(greet).toHaveBeenCalled();

You can check the number of calls:

expect(greet).toHaveBeenCalledTimes(1);

You can also check the arguments:

expect(greet).toHaveBeenCalledWith("John");

This is useful when you want to make sure your code calls another function correctly.

---

Testing Mock Function Arguments

Suppose you have:

function sendMessage(send, message) {
    send(message);
}

You can create a mock function:

test("sends the correct message", () => {
    const send = jest.fn();

    sendMessage(send, "Hello");

    expect(send).toHaveBeenCalledWith("Hello");
});

Here, the real send function is not needed.

We only care that our function called it with the correct value.

---

Mocking a Function With jest.spyOn()

Sometimes you do not want to completely replace a module or object.

You only want to watch a specific function.

This is where jest.spyOn() is useful.

Suppose you have:

const user = {
    getName() {
        return "John";
    }
};

You can create a spy:

const spy = jest.spyOn(user, "getName");

Now you can check whether the function was called:

user.getName();

expect(spy).toHaveBeenCalled();

A spy can also replace the implementation:

spy.mockReturnValue("Mike");

expect(user.getName()).toBe("Mike");

---

Restoring a Spy

After using jest.spyOn(), you should usually restore the original function.

spy.mockRestore();

For example:

const spy = jest.spyOn(user, "getName");

spy.mockReturnValue("Mike");

expect(user.getName()).toBe("Mike");

spy.mockRestore();

After restoration, the original implementation works again.

---

Mocking Modules in Jest

Sometimes your code imports another module.

For example:

import { getUser } from "./userService";

export async function getUserName() {
    const user = await getUser();

    return user.name;
}

You may not want to call the real getUser() during your test.

You can mock the module:

jest.mock("./userService");

Then provide the value you want:

getUser.mockResolvedValue({
    name: "John"
});

Now your test controls what getUser() returns.

Example:

test("returns the user name", async () => {
    getUser.mockResolvedValue({
        name: "John"
    });

    const result = await getUserName();

    expect(result).toBe("John");
});

This keeps the test focused on getUserName() instead of the actual user service.

---

Mocking API Calls

API calls are one of the most common reasons to use mocks.

Suppose your application has:

async function getUserName(fetchUser) {
    const user = await fetchUser();

    return user.name;
}

Instead of calling a real API, create a mock:

test("gets user name", async () => {
    const fetchUser = jest.fn();

    fetchUser.mockResolvedValue({
        name: "John"
    });

    const result = await getUserName(fetchUser);

    expect(result).toBe("John");
});

The test does not need an actual server.

You decide exactly what the API response should look like.

---

Mocking Different API Responses

Mocking is also useful for testing different API scenarios.

Successful response

fetchUser.mockResolvedValue({
    name: "John"
});

Empty response

fetchUser.mockResolvedValue(null);

API error

fetchUser.mockRejectedValue(
    new Error("Server error")
);

Now you can test how your application behaves in each situation.

---

Clearing Mock Calls

Sometimes you want to keep the mock but remove its previous call history.

Use:

mockClear()

Example:

const mockFn = jest.fn();

mockFn("Hello");

expect(mockFn).toHaveBeenCalledTimes(1);

mockFn.mockClear();

expect(mockFn).toHaveBeenCalledTimes(0);

The function still exists, but its call history has been cleared.

---

Resetting a Mock

mockReset() removes the mock’s call history and its configured behavior.

const mockFn = jest.fn();

mockFn.mockReturnValue("Hello");

mockFn.mockReset();

After resetting, the mock no longer has the previous return value.

A simple way to remember the difference is:

• mockClear() → clears call history
• mockReset() → clears call history and mock behavior
• mockRestore() → restores the original implementation of a spy

---

Mocking Errors

Mocks make it easy to test error handling.

Suppose:

const getData = jest.fn();

getData.mockRejectedValue(new Error("Something went wrong"));

You can test:

test("handles errors", async () => {
    await expect(getData()).rejects.toThrow(
        "Something went wrong"
    );
});

This is much easier than trying to create a real failure every time you run your tests.

---

Mocking Timers

Jest can also replace JavaScript timers such as:

• setTimeout
• setInterval

For example:

jest.useFakeTimers();

Suppose:

function delayedMessage(callback) {
    setTimeout(() => {
        callback("Done");
    }, 1000);
}

You can test it without actually waiting one second:

test("calls callback after one second", () => {
    const callback = jest.fn();

    delayedMessage(callback);

    jest.advanceTimersByTime(1000);

    expect(callback).toHaveBeenCalledWith("Done");
});

This makes timer-based tests much faster.

---

Mocking Random Values

Sometimes your code uses Math.random().

That can make a test unpredictable.

You can spy on it:

const spy = jest
    .spyOn(Math, "random")
    .mockReturnValue(0.5);

Now:

Math.random();

always returns:

0.5

After the test:

spy.mockRestore();

This makes the test predictable.

---

Mocking Date and Time

Code that depends on the current time can also be difficult to test.

Jest provides fake timers that can help control time.

For example:

jest.useFakeTimers();

jest.setSystemTime(
    new Date("2026-01-01")
);

Now your test can run as if the current date were January 1, 2026.

This is useful for testing:

• Expiration dates
• Time-based messages
• Scheduled tasks
• Date calculations
• Timeouts

---

Mocks vs Spies

Mocks and spies are related, but they are not exactly the same.

Mock

A mock usually replaces a function with a fake implementation.

const mockFn = jest.fn();

You control what it does.

Spy

A spy watches an existing function.

jest.spyOn(object, "method");

It allows you to check how the original function was used and can also replace its behavior when needed.

A simple rule is:

Use a mock when you need a fake function. Use a spy when you want to observe or temporarily replace an existing function.

---

When Should You Use Mocks?

Mocks are useful when your code depends on something that you do not want to use in a unit test.

Common examples include:

• API requests
• Database calls
• File system operations
• Third-party services
• Random values
• Timers
• External modules
• Email services
• Payment services

For example, if you are testing a function that sends an email, you usually do not want every test to send a real email.

Instead:

const sendEmail = jest.fn();

Then verify that it was called correctly.

---

When Should You Avoid Mocking?

Mocking is useful, but you should not mock everything.

Too many mocks can make tests difficult to understand.

They can also make tests tightly connected to implementation details.

For example, if you are testing a simple function:

function add(a, b) {
    return a + b;
}

There is no reason to mock a + b.

Just test the function directly:

test("adds two numbers", () => {
    expect(add(2, 3)).toBe(5);
});

Use mocks when a dependency makes the test difficult, slow, unreliable, or dependent on external systems.

---

Best Practices for Mocking in Jest

1. Mock Only What You Need

Do not mock every function.

Keep simple logic real when possible.

---

2. Keep Mocks Simple

A mock should make the test easier to understand.

Avoid complicated mock implementations unless they are necessary.

---

3. Test Behavior

Focus on what your code should do.

Do not make your tests depend too heavily on how the code is internally implemented.

---

4. Reset or Restore Mocks

Make sure mocks do not affect other tests.

You can use:

jest.clearAllMocks();

or:

jest.resetAllMocks();

or:

jest.restoreAllMocks();

depending on what you need.

---

5. Test Success and Failure

Do not test only the successful response.

Use mocks to test:

• Successful results
• Empty results
• Invalid data
• API errors
• Network failures
• Unexpected values

This gives your tests better coverage.

---

Common Mistakes With Jest Mocks

Mocking everything

Not every dependency needs to be mocked.

Forgetting to reset mocks

Previous calls can affect later tests if mock state is not handled correctly.

Testing implementation instead of behavior

Your test should focus on what the application does, not every internal function call.

Creating complicated mocks

A complicated mock can become harder to maintain than the real code.

Not testing errors

Mocks make error scenarios easy to simulate, so take advantage of them.

---

A Complete Mocking Example

Let’s put everything together.

Suppose we have:

async function getUserName(getUser) {
    const user = await getUser();

    return user.name;
}

Our test can mock getUser:

test("returns the user name", async () => {
    const getUser = jest.fn();

    getUser.mockResolvedValue({
        name: "John"
    });

    const result = await getUserName(getUser);

    expect(result).toBe("John");
    expect(getUser).toHaveBeenCalledTimes(1);
});

Here we are testing two things:

1. The function returns the correct user name.
2. The dependency was called once.

We never make a real API request.

That is the main idea behind mocking.

---

Mocking in Jest: Quick Reference

Method	Purpose
jest.fn()	Creates a mock function
jest.spyOn()	Creates a spy for an existing function
mockReturnValue()	Sets a return value
mockReturnValueOnce()	Sets a return value for one call
mockImplementation()	Provides a custom implementation
mockResolvedValue()	Returns a resolved Promise
mockRejectedValue()	Returns a rejected Promise
mockClear()	Clears mock call history
mockReset()	Clears history and behavior
mockRestore()	Restores the original implementation
jest.mock()	Mocks a module
jest.clearAllMocks()	Clears all mock call history
jest.resetAllMocks()	Resets all mocks
jest.restoreAllMocks()	Restores mocked functions

---

Frequently Asked Questions

What is mocking in Jest?

Mocking in Jest means replacing a real function, module, API, or dependency with a fake version so you can control its behavior during testing.

What is jest.fn() used for?

jest.fn() creates a mock function. Jest can track how many times it was called and which arguments were passed to it.

What is the difference between mock and spy?

A mock usually provides a fake function, while a spy watches an existing function and can optionally replace its implementation.

How do I mock an API call in Jest?

You can replace the function responsible for the API request with a mock and use methods such as mockResolvedValue() or mockRejectedValue() to simulate different responses.

What is mockResolvedValue()?

mockResolvedValue() makes a mock function return a resolved Promise. It is commonly used when testing asynchronous functions.

What is mockRejectedValue()?

mockRejectedValue() makes a mock function return a rejected Promise. It is useful for testing error handling.

Should I mock everything in a unit test?

No. Mock only the dependencies that you need to control or isolate. Simple logic should usually be tested directly.

---

Conclusion

Mocking is one of the most useful features in Jest.

It allows you to replace real dependencies with controlled fake versions. This is especially helpful when working with APIs, databases, timers, external services, and asynchronous code.

The most commonly used tools include:

jest.fn()
jest.spyOn()
jest.mock()
mockReturnValue()
mockImplementation()
mockResolvedValue()
mockRejectedValue()

Once you understand these methods, you can write tests that are faster, more predictable, and easier to maintain.

The key is simple:

Use mocks to isolate the code you are testing, not to make every test artificial.