Mocking bird

Jest Mock for Unit Testing MERN Back-end

Recently, I had to write some unit tests for a Node.js back-end that worked with multiple external services like Redis (database) and Kafka (message queueing). Although I had experience with Jest for Node.js unit testing, I had no idea what to do when functions were calling on external processes, such as doing a database lookup. This is where mock comes into the picture, it allows us to ‘mock’ a function’s implementation so we can test the accuracy of our code without worrying about everything else.

To explain this concept, I’m gonna use a simple Node.js -backend about restaurants 🌮! Our app can create restaurants with unique names and store them in MongoDB with mongoose.

This assumes you’re already familiar with Jest and Node.js, if not please read my other tutorial on how to get started with Jest unit testing for Node.

Section 1: App setup

Once we initialise npm we just need to install express and mongoose. This is the bare minimum I’m going to use for this tutorial but feel free to have more ☕️

// set up node
npm init
// install dependencies
npm i express mongoose

Model

Our model is very simple. We just have a restaurant with a name, cuisine type and address.

Restaurant Model

Controllers

We will try to write tests for a function that creates a new restaurant. The function simply takes a name, location and cuisine type, and if the name has not already been used it creates a new restaurant.

Function to create a new restaurant: controllers/createRestaurant.js

This function will be incorporated into our app like so

Controller: controllers/index.js

By splitting the function up, we can easily unit test it later. Finally, the app’s entry point will look like:

Entry point: index.js

Section 2: Install Jest

We can use npm to install the Jest framework for our testing.

npm install jest

Section 3: Testing

One way which I have found to be clean and easy to understand is it having unit tests in the same folder as the files which they are testing. Hence, we will create a new file in controllers folder. One key thing is the naming of our test files. They have to end in .test.js . This is how Jest is able to identify them and run our tests!

Folder structure for tests

First Jest — oops, Test 😎

Finally, we can proceed to write our first test! For our first test using mock , we will test a case where we try to create a restaurant with a name that has already been used. This should throw an error and we want to make sure this happens.

To mock this behaviour, all we need to say is:

Restaurant.findOne = jest.fn().mockReturnValueOnce({
     name: "Amy's"
});

The anatomy of mock is like this.

Mock anatomy

1. functionToMock: This is the function whose behaviour you want to change for your test. For example for our test, we need to mock Restaurant.findOne to return a value instead of actually searching the database.
2. jest.fn(): This is common to all mocks
3. mockReturnValueOnce : This specifies what we want to mock. If all you care about is the return value of the function, you can use mockReturnValueOnce . Let’s say instead, you want to test when functionToMock throws an error. In that case, you would use mockImplementation . Jest provides a great list of options for this: https://jestjs.io/docs/mock-function-api.
4. yourReturnValue : This is where you place your desired behaviour/return value.

It should be clear by now that we’re just telling jest , “Hey Jest, forget about what the actual implementation of a function is, instead do what I tell you to 😎”. Awesome right! We don’t have to worry about creating a fake database that acts the way we want in every test, instead, we can just tell jest to return the values we expect from the database calls.

Here is a full example of how we can use jest’s mock. First, we mock Model.findOne and then we need to mock the Model.prototype.save function. We’re passing a function that does nothing to the Restaurant.prototype.save which means, when jest comes across our code in controllers/createRestaurant.js that calls restaurant.save() , it simply does nothing.

First unit test: controllers/createRestaurant.unit.test.js

It’s important to note we could use mockImplementation instead of mockReturnValue. For example, for Restaurant.findOne we could instead say:

Restaurant.findOne = jest.fn().mockImplementation(() => {
    return {
        name: "Amy's"
    }
})

This would behave in the same way, as we are passing it a function that just returns a name. If you don’t believe me, try it out!

Run Test with Coverage

Now it’s time to check everything is still working and I always like adding coverage to my tests so I have an idea of how I’m doing. With Jest, this is very simple. In package.json, you need to add this script:

"test": "jest --coverage --verbose"

Now, when you run npm run test , you will see your coverage results as well 🥳

Running tests

Extra: Mocking Logs

Most applications have some sort of logging and it's worthwhile to test that we are logging the correct information. In your function, you will be logging information, warnings and errors most probably using a third-party package. Similar to a when we test functions involving a database, we can mock the behaviour of our logger in the tests.

Since this tutorial isn’t about logging, I will just create a dummy function which just returns an empty object that will act as our logger:

utils/logger

In your application, this will be a proper helper for a logging system such as a winston logger. Let’s say we wish to log all errors (line 19) as well as an info log whenever we successfully create a restaurant (line 29).

Adding logging: controllers/createRestaurant.js

Before we run any of our tests, we need to add the following at the top of our test file. This is an example of a logger with two levels: info and warn. If your logger has more levels that you use, feel free to add to this.

const mockInfo = jest.fn();
const mockWarn = jest.fn();
// mocking Logging
jest.mock("../utils/Logger", () => {
    return {
        getLogger: () => ({
            info: mockInfo,
            warn: mockWarn
        })
    }
})

What this means is that when createRestaurant calls the getLogger function in "../utils/Logger" file, instead of creating and providing the real logger function, return the empty functions we have made: mockInfo and mockWarn for info and warn respectively.

How can we check that we’re calling the log functions in our tests? 🤔

Jest offers a toHaveBeenCalledWith function which checks wether a function has been called with certain parameters. Let’s write a test for a case where we successfully create a restaurant and check the logger is working.

Finally, checking our tests are all passing…look at that coverage! 😯

And we’re done 🥳

And that is it for using mock . It can make life so much simpler when you’re writing your unit tests as it removes the need to worry about the behaviour of external functions that you’re using. You can just ensure your function works given specific input, which is what unit testing is all about!

Please reach out if there’s any problems or you need more guidance on a specific point. 😊

More content at plainenglish.io