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

后端 未结 5 673
失恋的感觉
失恋的感觉 2021-02-05 03:44

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

const test = async () => await aPromi         


        
相关标签:
5条回答
  • 2021-02-05 04:26

    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/
                });
    
            });
    
    0 讨论(0)
  • 2021-02-05 04:32

    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'))
    }
    
    0 讨论(0)
  • 2021-02-05 04:36

    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/);
    });
    
    0 讨论(0)
  • 2021-02-05 04:42

    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.

    0 讨论(0)
  • 2021-02-05 04:45

    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);
      }
    }
    
    0 讨论(0)
提交回复
热议问题