CODEWITHSUNDEEP
javascriptnode.jsasync-awaitassertecmascript-next
seldon
seldon

Reputation: 1027

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

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 (obviously?) doesn't work because the function exits before the Promise is resolved. Yet I found this question where the same thing is attained using callbacks.

Any suggestion?

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

Upvotes: 44

Views: 17704

Answers (5)

Bergi
Bergi

Reputation: 664196

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.

Upvotes: 61

seldon
seldon

Reputation: 1027

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);
  }
}

Upvotes: 4

Alexander Mills
Alexander Mills

Reputation: 99960

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/
            });

        });

Upvotes: 0

vitalets
vitalets

Reputation: 4973

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/);
});

Upvotes: 21

jayWHY
jayWHY

Reputation: 1000

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'))
}

Upvotes: 3

Related Questions