Jest does not allow asynchronous catching of rejected promises

Bug Jest version: 22.4.3 (But was introduced in 21.x) Config: None (all defaults) Node version: 6.11.5, 8.9.4

Jest does not allow you to asynchronously attach a .catch() to a promise, even if it’s added before the test itself is finished. The only difference between these two tests is that the catch is added within a setTimeout() in the second one.

// This passes after ~107ms (the expected amount of time)
test('Synchronous catching of promise', (done) => {
    const promise = Promise.reject(new Error('nope'));

    promise.catch((err) => console.log('Caught error: ', err.message));
    
    // At a later time, finish the test
    setTimeout(() => {
        console.log('here');
        done();
    }, 100);
});

// This fails after ~10ms, with error message "nope"
test('Async catching of promise', (done) => {
    const promise = Promise.reject(new Error('nope'));

    setTimeout(() => {
        promise.catch((err) => console.log('Caught error: ', err.message));
    });

    // At a later time (well after the catch() has been attached to the promise), finish the test
    setTimeout(() => {
        // We nver makes it to this point because Jest sees that promise was not caught immediately
        console.log('here');
        done();
    }, 100);
});

In Jest 20.x, only warnings are printed, and the test does not fail

(node:54613) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): Error: nope
(node:54613) PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 2)

(Was originally mentioned in https://github.com/facebook/jest/issues/3251)

[DanielSWolf]

Nice idea! I reworked it into a defuse function:

function defuse(promise) {
  promise.catch(() => {});
  return promise;
}

it('terminates the test prematurely', async () => {
  const promise = defuse(new Promise((resolve, reject) => setTimeout(() => reject(new Error('Oops')), 0)));
  await new Promise(resolve => setTimeout(resolve, 10));
  await expect(promise).rejects.toThrow('Oops');
});

Still, this is a workaround for a problem that I believe should be fixed.

[DanielSWolf]

What’s more, the code may not even be part of the test suite, but of the system under test. Consider:

code-under-test.js

export async function codeUnderTest() {
  const promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('Oops')), 0));
  await new Promise(resolve => setTimeout(resolve, 10));
  return promise;
}

test.js

import { codeUnderTest } from '../src/code-under-test.js';

describe('codeUnderTest', () => {
  it('terminates the test prematurely', async () => {
    await expect(codeUnderTest()).rejects.toThrow('Oops');
  });
});

The function codeUnderTest is perfectly valid, yet fails any unit test that attempts to call it. Is there any workaround?