Awaiting inside a setInterval prevents setTimeout from being called

🐛 Bug Report

I am trying to mock a setTimeout inside of a setInterval with Jest, but am seeing confusing behavior with async/await and I do not know whether it is a bug, or if I am doing something wrong.

Awaiting inside the async function passed to setInterval causes setTimeout to never run. If I remove the await in the function below, the setTimeout is successfully set.

To Reproduce

See updated Reproduction Case in my Below Comment

// With await, setTimeout is never called

let interval;

async function check() {
  await Promise.resolve(true); //does not execute the setTimeout below
  setTimeout(() => {
    console.log('Hello World');
    clearInterval(interval);
  }, 1000);
}

const testFunction = async () => {
  interval = setInterval(check, 1000);
};

describe('Timers', () => {
  beforeEach(() => {
    jest.useFakeTimers();
  });

  it('should set a timeout that prints Hello World', async () => {
    await testFunction();

    jest.advanceTimersByTime(100000);
  });
});

// Removing the await, the setTimeout is executed

let interval;

async function check() {
  Promise.resolve(true);
  setTimeout(() => {
    console.log('Hello World');
    clearInterval(interval);
  }, 1000);
}

const testFunction = async () => {
  interval = setInterval(check, 1000);
};

describe('Timers', () => {
  beforeEach(() => {
    jest.useFakeTimers();
  });

  it('should set a timeout that prints Hello World', async () => {
    await testFunction();

    jest.advanceTimersByTime(100000);
  });
});

Expected behavior

setTimeout to run after a promise resolves.

[DaveStein]

@SimenB ran into this. Removed jest.useFakeTimers, issue was resolved. My workaround was:

beforeEach(() => {
  jest.spyOn(global, 'setTimeout');
});

afterEach(() => {
  global.setTimeout.mockRestore();
});

it('test code', async () => {
  global.setTimeout.mockImplementation(callback => callback());
  await theMethodThatHasSetTimeoutWithAwaitInsideCallback();
  expect(global.setTimeout).toBeCalledWith(expect.any(Function), 25000);
});

[OogieBoogieInJSON]

I have this issue as well.

Given a function that creates a setInterval inside. setInterval’s callback is an async function, which awaits for something and then invokes another function (I’m testing the result of this invoked function).

In my tests I’m using runOnlyPendingTimers or advanceTimersByTime but by the time I do the expect await inside the function I test is triggered afterwards, so my assert fails.

I’ve tried adding await Promise.resolve() after advancing my timers but still nothing changes.

So, I don’t think this is a bug, the timers are advanced but there’s no way to wait for that await 😦

Later edit:

If i stack

await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
expect(...)

This seems to make it work but I don’t really want to do that.

Later later edit:

I made it work somehow, here’s an example:

const testPromise= Promise.resolve({ yourData });
const mockFnInsideInterval = jest
      .spyOn(module, 'test')
      .mockImplementation(() => testPromise);
invokeWrappingFunction();
jest.advanceTimersByTime(...);
await testPromise;
expect(...);

This seems to make it work