`assert.throws()` with async argument

Hi 👋,

Is assert.throws() currently supposed to work with async functions?

For example, this fails:

assert.throws(async () => {
    await asyncFnThatThrows();
});

While this passes:

assert.throws(() => {
    syncFnThatThrows();
});

What is the recommended way to test that an async function throws?

Thought of something like this, but there’s no .pass() or .fail():

try {
   await asyncFnThatThrows();
   test.fail('did not throw');
} catch (err) {
   test.pass();
}

Edit: currently using this hack:

async function throwsAsync(
    asyncFn,
    failMessage = 'did not throw',
    passMesage = 'did throw',
) {
    try {
        await asyncFn();
        assert.equal(false, true, failMessage);
    } catch (err) {
        assert.equal(true, true, passMesage);
    }
}

[lukeed]

@aral I’m saying that if you only have this:

try {
  await asyncFnThatThrows();
  assert.unreachable('should have thrown');
} catch (err) {
  assert.instance(err, Error);
}

then yes, this could lead to misleading results since the Assertion that uvu/assert throws extends Error, thus satisfying the assert.instance check.

I’m saying that this snippet shouldn’t stand on its own in most cases. Instead, the recommendation is to always assert against properties within the err that gets thrown. So something more like this:

try {
  await asyncFnThatThrows();
  assert.unreachable('should have thrown');
} catch (err) {
  assert.instance(err, Error);
  assert.match(err.message, 'something specific');
  assert.is(err.code, 'ERROR123');
}

In this case, if/when assert.unreachable does throw, it doesnt match the other conditions. And you still get the benefit of ensuring that asyncFnThatThrows function needs to throw.

---

I see your PR, thanks! Will review shortly.

[JosephusPaye]

Thanks for the consideration. Your findings make sense, and I haven’t seen any issues in practice using the try/catch + assert.unreachable pattern myself.