Node.js and Jest: Testing promise loop, count how many times function has been called

I want to test my code using JEST, but I’m having some issues. I want to check, if restart() function has been called.

My code works like this, it’s waiting for the data, and if there’s no data it’s calling the same function again. Basically something like a loop.

myCode.js file:

module.exports = {
    getSomething: async () => {
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve("");
            }, 1000);
        });
    },
    doSomething: async () => {
        const data = await module.exports.getSomething();
        if (!data) {
            return module.exports.restart();
        }
        return data;
    },
    restart: async () => {
        return module.exports.doSomething();
    }
};

myCode.test.js file:

const myCode = require("./exampleCode")

describe("test", () => {
    test("Is it doing something more than once?", async () => {
        const restartSpy = jest.spyOn(myCode, 'restart');
        myCode.doSomething()
        expect(restartSpy).toHaveBeenCalledTimes(1);
    })
})

My problem is that expect(restartSpy).toHaveBeenCalledTimes(1); is returning false.

The question is – what I’m doing wrong? Is there a way to test this code?

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

The main problem here is the lack of await before myCode.doSomething(). All your functions are asynchronous, so you need to wait for them to finish before checking the spy:

await myCode.doSomething();

Another issue is the fact that it’s an infinite recursion loop – jest will timeout after 5000ms (by default) if you won’t modify the code that is calling restart, for example:

doSomething: async (restartCounter = 0) => {
    const data = await module.exports.getSomething();
    if (!data && ++restartCounter < 2) {
        return module.exports.restart(restartCounter);
    }
    return data;
},
restart: async (restartCounter) => {
    return module.exports.doSomething(restartCounter);
}

Method 2

Actually, I’ve found a workaround.

describe("test", () => {
    test("Is it doing something more than once?", async () => {
        myCode.restart = jest.fn()
        const restartSpy = jest.spyOn(myCode, 'restart');
        await myCode.doSomething()
        expect(restartSpy).toHaveBeenCalledTimes(1);
    })
})

I’m overwriting restart() function. So now, I’m able to add await to doSomething() function and it will no longer be inifinite loop. Now I can check if the restart function has been called

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0