Jest Mocking Tutorial For Beginners

Beginner’s Guide to Jest Mocking

If you want to control the behavior of certain functions or modules and isolate parts of your codebase while testing your software with Jest, then mocking technique is for you. In this article, we’ll dive into Jest mocks and explore how they can be used effectively in your testing workflow.

What is Mocking?

In software development, mocking is a testing technique that involves creating imitation versions, or mocks of objects, functions, or modules to isolate the code you’re testing. By using mocks, you can have control over how these elements behave without actually executing their real code.

Mocking lets you concentrate on testing a particular piece of code while pretending that the surrounding components are functioning as expected. This isolation helps uncover bugs and errors specific to the code under examination.

To list the benefits of mocking, they includes:

  • Isolation for Precise Testing
  • Controlled Behavior
  • Handling Unavailable or Unstable Dependencies
  • Reduced Costs
  • Easy Simulations

When To Use Mocking?

Mocking is particularly helpful when dealing with external dependencies, such as APIs or databases. By creating mock versions of these dependencies, you can simulate their behavior and ensure your code interacts correctly with them, all without the complexities of real-world connections.

For example, imagine you have a function responsible for registering new users and sending them a welcome email. Instead of sending actual emails and relying on external email services, you can create a mock email service to simulate email sending behavior. This approach allows you to test different phases of the user registration process by isolating them from the external email module.

Mocks in Jest

Jest comes with a powerful mocking feature. The different types of mocking you can perform in Jest include:

  • Function Mocks
  • Module Mocks
  • Spies

Function Mocks

In Jest, function mocks allow you to define the behavior of functions without actually executing their code. Jest provides a simple way to create function mocks using the jest.fn() method. This method creates a new mock function that you can customize according to your test requirements.

For example, you can define a mock function and set its return value using the mockReturnValue method.

const myFunction = jest.fn();


// Test example

Alternatively, you can specify an entire custom implementation for the mock function using the mockImplementation method instead of controlling a part of the original function.

const myFunction = jest.fn();

myFunction.mockImplementation((a, b) => a + b);
const result = myFunction(1,2)

// Test example
expect(myFunction).toHaveBeenCalledWith(1, 2);

Additionally, for asynchronous functions, you can also use methods like mockResolvedValue, mockRejectedValue, etc., to define their resolved or rejected values.

const myFunction = jest.fn();

myFunction.mockResolvedValue("Promise resolved successfully!");
// or
myFunction.mockRejectedValue(new Error("Error Message"));

expect(myFunction()).rejects.toThrow(new Error("Error Message"));

Module Mocks

In Jest, module mocks enable you to o simulate the behavior of external or internal modules. These modules can include databases, external services, APIs, or even other parts of the same application.

Suppose you have an internal math.js module that performs math operations

// math.js
function add(a, b) {
  return a + b;
function divide(a, b) {
  return a / b;

module.exports = {

You can mock an entire module and and control the behavior of that module’s functions. For instance, consider the following example where we replace a function’s summation functionality with subtraction.

// math.test.js

const math = require("./math.js");

// Mocking the dependency

describe("add", () => {
  it("should add two numbers", () => {
    // Mock the add function to change behaviour of the function
    // Now, the add fucntion will do subtraction
    math.add.mockImplementation((a, b) => a - b);

    // Call the function to be tested
    const result = math.add(6, 4);

    // Assert the result

  // You can add more test cases for the add function here

You can also mock an external module. Let’s say you have a module named api.js that makes HTTP requests with Axios, and you want to mock Axios behavior for testing purposes.

// api.js
const axios = require('axios');

async function fetchData() {
  const response = await axios.get('');

module.exports = { fetchData };

At this point, you can control Axios’s behavior by setting a new value for the response that the Axios get method will resolve. This means that you isolate the code you’re testing from Axios, enabling you to test other processes, such as checking if the response displays correctly in the page or if the user sees an error when it occurs.

// api.test.js
const axios = require('axios');
const api = require('./api');

jest.mock('axios'); // This line mocks the axios module

test('fetchData should return mock data', async () => {
  axios.get.mockResolvedValue({ data: 'mocked data' });

  const result = await api.fetchData();

  // This is for
  expect(result).toBe('mocked data');


In Jest, Spies allow you watch over function calls as an additional feature. They captures information about their invocations. This makes it a dynamic tool for both monitoring and manipulating function behavior during testing.

Jest provides a built-in spying mechanism through the jest.spyOn function. It allows you to create a spy for a specific function. Consider the following example where jest.spyOn is used to create a spy for the add function in the mathUtils module. Then, various assertions are made using the spy, such as checking if the function was called with specific arguments and how many times it was called.

// Example module
const mathUtils = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b,

// Test case
test('Testing the add function', () => {
  // Create a spy on the 'add' function
  const addSpy = jest.spyOn(mathUtils, 'add');
  addSpy.mockImplementation((a,b) => a * b);

  // Call the function
  const result = mathUtils.add(2, 3);

  // Assertions
  expect(result).toBe(6); // Check the result
  expect(addSpy).toHaveBeenCalledTimes(1); // Check if the spy was called once
  expect(addSpy).toHaveBeenCalledWith(2, 3); // Check if the spy was called with specific arguments

  // Restore the original function (optional)

Actually, as you may realize jest.spyOn and jest.fn are so similar, but they serve slightly different purposes. jest.spyOn is used to create a spy on existing functions or methods, especially when you want to temporarily mock or change their behavior during testing. On the other hand, jest.fn is used to create standalone mock functions that you can use to define custom behavior or replace functions entirely during testing.


In summary, using mocks in testing allows you to isolate the code you are testing from certain dependencies, functions, or modules. They help you create a controlled environment, catch bugs early, and ensure that your code interacts seamlessly with its dependencies, all while reducing costs and improving overall efficiency.

Remember that, using mocks does not mean that you should avoid testing external modules. They allow you to test other processes except for those modules.

In this article we have discussed the different types of mocking in Jest along with examples. If you want to learn more about Jest, you can check the following articles:

Thank you for reading.

Leave a Reply

Your email address will not be published. Required fields are marked *

Begin typing your search term above and press enter to search. Press ESC to cancel.

Back To Top