jest: Jest gives no indication that test fails because of unhandled promise rejection.

I would also like to add that the problem here is not only “no indication”, but also the fact that the test fails: I was writing a test for utility function and I need to test that this function handles both successful and failing callbacks passed to it. Seems like the “negative” test fails for me anyway, even with expect(promise).rejects...., try/catch.

P.S. Also if I add const promise = Promise.reject('aaaa') to the top level in the file (outside describe) Jest will randomly fail first two tests. Very weird…

@JoeLangewayClear’s workaround will suppress these errors, but it’s kind of like disabling the engine fault light in your car and claiming you “fixed it”

In node v16 the issue has gotten a lot worse.

[Nest] 36135  - 17/01/2022, 10:29:12   DEBUG Auto-corrected AuditLogServiceClient 'baseUrl' value: Removed /api/v1.
[Nest] 36135  - 17/01/2022, 10:29:12   DEBUG Auto-corrected AuditLogServiceClient 'baseUrl' value: Removed /api/v1.
[UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "TypeError: promise.then is not a function".] {
  code: 'ERR_UNHANDLED_REJECTION'
}
end of process....

I’ve tested the earlier mentioned reproduction case and it seems to still be an issue in Node v20.10.0, Jest v29.3.1.

Looks like it goes wrong in promises & async nesting only?

function _rejecting() {
	return new Promise((resolve, reject) => {
		reject(new Error('An error'));
	});
}

test("this fails", async () => {
	const promise = (function _testMe() {
		return new Promise(async () => {
			await _rejecting();
		});
	})();

	return expect(promise).rejects.toThrowError();
});

test("this doesn't fail", async () => {
	const promise = (async function _testMe() {
		await _rejecting();
	})();

	return expect(promise).rejects.toThrowError();
});

Very minimal reproduction case. If the rejected promise is nested, it fails the test, if it isn’t it won’t. And the promise isn’t exactly unhandled, as the async should be chaining them.

The code might look a bit weird like that, but it’s sometimes needed to mix async & promises with things like manual timeouts. This is just a minimal repro.

Oh wow ok I’ve just spent far too long trying to figure out how Jest was even seeing the error it was reporting. Really could do with jest saying something, anything, about how it caught the error.

Unhandled error/rejection bugs can be subtle and hard to track down, and often appear when you end up with the worst case async scenario where code is unintentionally executing in the background (e.g. missing return Promise) where it can’t be sequenced and errors can’t be handled.

Having Jest show the error without indicating anything at all about how it caught the error is very confusing, especially since Jest seems to override/ignore any unhandled rejection/exception handlers you add in test.

Any updates about this bug? this should be critical, it’s affecting the coverage in our project (and I believe everybody’s) and there is no way to work around it except to just not test it.

Here is a comment to show, that this issue is still relevant. Very much so!

Hitting this too. There should be a setting to disable this functionality.

I tried editing jest-circus/build/globalErrorHandlers.js in place, commenting out the inject and restore, and then jest crashes at the site of the uncaught error that later gets caught.

So maybe it’s actually a problem with node’s detection being too eager?

In any case, the function uncaught could already log the full stack trace of the error, saying it’s uncaught.

A workaround for others encountering this problem, or rather, a work around for the difficulty of Jest not liking unhandled rejections:

/**
 * A function to wrap the Promise constructor such that no rejections are considered unhandled
 * by either Node or Jest. Whatever handlers can still be attached and rejections turned into
 * thrown exceptions where ever the returned promise is awaited.
 */
function makePromise(callback) {
  const promise = new Promise(callback);
  promise.catch(()=>{});
  return promise;
}

Here is a comment to show, that this issue is still relevant. Very much so!

👍🏽

I created a PR that at least marks uncaught errors with their reason, but it doesn’t explain why I’m getting uncaught errors that are clearly caught.

When I replace the uncaught function with the below, my tests pass, and my app works just fine. This should be a command line option.

const uncaught = error => {
	console.error(new Error(`uncaught (but ignoring): ${error.stack}`))
	return
	;(0, _state.dispatchSync)({
		error,
		name: 'error',
	})
}