Write Unit Test Case for API call (Fetch) in Nodejs

I n this article, we will learn how to write unit test cases to test the API call or how we can write the unit test cases to test the fetch function (API call). Sometime writing unit test cases of API call is kind of huddle for programmers, here we will learn how we can write test case to test API call.

Here we have a code snipet, which contain a method saveExpress(), and in this method we have an API call (POST request) with some data in body.

Folder structure:

test ->index.ts
test -> index.test.ts

index.ts:

                            import { fetch, generateToken } from '../utils';
                    
                            export interface SomeInterface {
                                _id: string;
                                user: string;
                                _otp: boolean;
                                opt_in: boolean;
                            }
                            
                            export const saveExpress = (
                                eCheckout: SomeInterface
                            ) => {
                                const requestData = {
                                    user: eCheckout.user,
                                    _otp: eCheckout._otp,
                                    opt_in: eCheckout.opt_in
                                };
                            
                                return fetch(
                                    `/api/checkout/${eCheckout._id}/patch`,
                                    {
                                        method: 'PATCH',
                                        headers: {
                                            'Content-Type': 'application/json',
                                            Authorization: `Bearer ${generateToken({
                                                _id: eCheckout._id
                                            })}`
                                        },
                                        body: JSON.stringify(requestData)
                                    }
                                );
                            };
                          

This note is regarding import { fetch, generateToken } from '../utils';
we have two method 'fetch' and 'generateToken' in our utils.
fetch is used to make an API call. generateToken is used to get the generated token.
Don't get confused about these methods.

Now, we need to write the unit test case to test the method saveExpress(), basically, we need to test the API call. So here we'll write our unite test case to test the API (fetch) call.

Let's write unit test case to test the API call:

we'll use Jest to write our unit test case.
index.test.ts:

                            import * as utils from '../utils';
                            import { SomeInterface, saveExpress } from '.';
                            
                            jest.mock('../utils', () => ({
                                fetch: jest.fn(),
                                generateToken: jest.fn()
                            }));
                            
                            describe('test saveExpress', () => {
                                test('ensuring that correct endpoint and payload has been called', async () => {
                                    const mockFetch = jest.spyOn(utils, 'fetch');
                                    const mockGenerateToken = jest.spyOn(utils, 'generateToken');
                            
                                    const expData: SomeInterface = {
                                        _id: 'xxx-1',
                                        user: 'Shubham',
                                        _otp: false,
                                        opt_in: false
                                    };
                            
                                    mockGenerateToken.mockReturnValue('mock-token');
                                    mockFetch.mockResolvedValue(true);
                            
                                    await saveExpress(expData);
                            
                                    const { _id, ...rest } = expData;
                            
                                    expect(mockGenerateToken).toHaveBeenCalledWith({ _id });
                                    expect(mockFetch).toHaveBeenLastCalledWith(
                                        `/api/checkout/${_id}/patch`,
                                        {
                                            method: 'PATCH',
                                            headers: {
                                                'Content-Type': 'application/json',
                                                Authorization: 'Bearer mock-token'
                                            },
                                            body: JSON.stringify(rest)
                                        }
                                    );
                                });
                            });
                            
                    
                        

So, you can see we have wrote the test case to test the fetch (API call) in in nodejs.
In this we have ensured that, we are calling our API with the correct endpoint, correct data etc.