Node.js assert.throws with async functions (Promises)

Question

I want to check if an async function throws using assert.throws from the native assert module. I tried with

const test = async () => await aPromise();
assert.throws(test); // AssertionError: Missing expected exception..

It (obvioulsy?) doesn't work because the function exits before the Promise is resolved. Yet I found this question where the same things is attained using callbacks.

Any suggestion?

(I'm transpiling to Node.js native generators using Babel)

Answer 1

node 10 and newer

Since Node.js v10.0, there is assert.rejects which does just that

Older versions of node

async functions never throw - they return promises that might be rejected.

You cannot use assert.throws with them. You need to write your own asynchronous assertion:

async function assertThrowsAsynchronously(test, error) {
    try {
        await test();
    } catch(e) {
        if (!error || e instanceof error)
            return "everything is fine";
    }
    throw new AssertionError("Missing rejection" + (error ? " with "+error.name : ""));
}

and use it like

return assertThrowsAsynchronously(aPromise);

in an asynchronous test case

Answer 2

Based on Bergi answer I've suggest more universal solution that utilizes original assert.throws for error messages:

import assert from 'assert';

async function assertThrowsAsync(fn, regExp) {
  let f = () => {};
  try {
    await fn();
  } catch(e) {
    f = () => {throw e};
  } finally {
    assert.throws(f, regExp);
  }
}

Usage:

it('should throw', async function () {
    await assertThrowsAsync(async () => await asyncTask(), /Error/);
});

Answer 3

The answers given work, but I came across this issue today and came up with another solution, that I think is a little simpler.

// Code being tested
async function thisFunctionThrows() {
    throw new Error('Bad response')
}


// In your test.
try {
    await thisFunctionThrows()
    assert.equal(1 == 0) // Never gets run. But if it does you know it didn't throw.
} catch (e) {
    assert(e.message.includes('Bad response'))
}

Answer 4

Since the question is still getting attention, I'd like to sum up the two best solutions, especially to highlight the new standard method.

Node v10+

There's a dedicated method in the assert library, assert.rejects.

For older versions of Node

A fill from vitalets answer:

import assert from 'assert';

async function assertThrowsAsync(fn, regExp) {
  let f = () => {};
  try {
    await fn();
  } catch(e) {
    f = () => {throw e};
  } finally {
    assert.throws(f, regExp);
  }
}

Answer 5

You are going to want to use, assert.rejects() which is new in Node.js version 10.

At the high level, instead of assert.throws, we want something like assert.rejects, hopefully you can take this and run with it:

        const assertRejects = (fn, options) => {
            return Promise.resolve(fn()).catch(e => {
                    return {
                        exception: e,
                        result: 'OK'
                    }
                })
                .then(v => {

                    if (!(v && v.result === 'OK')) {
                        return Promise.reject('Missing exception.');
                    }

                    if (!options) {
                        return;
                    }

                    if (options.message) {
                        // check options
                    }

                    console.log('here we check options');

                });
        };

        it('should save with error', async () => {

            // should be an error because of duplication of unique document (see indexes in the model)
            return await assertRejects(async () => {

                patientSubscriber = await PatientSubscriber.create({
                    isSubscribed: true,
                    patient: patient._id,
                    subscriber: user._id
                });

            }, {
                message: /PatientSubscriber validation failed/
            });

        });