Examining the asynchronous function to cause an error using mocha

Question

Examining the asynchronous function to cause an error using mocha

I am facing a challenge with testing an async function that is supposed to run for 2000ms before throwing an exception. Despite my efforts using Mocha / chai, the test does not seem to be working as expected.

Here's what I have attempted:

First approach:

expect(publisher.dispatchMessagelt;ExampleResponseMessagegt;(message, {}, 2 * 1000)).to.eventually.throw();

Although this test passes quickly (in 52ms), it fails to capture the exception thrown after 2 seconds. It appears that the promise of the function is not being awaited at all.

Second attempt:

expect(async () => {
      await publisher.dispatchMessagelt;ExampleResponseMessagegt;(message, {}, 2 * 1000);
    }).to.throw();

This time, the test fails with an error message indicating that the function did not throw an error as expected after the specified timeout period.

The desired outcome is for the test to pass when an exception is thrown after 2000ms, which falls within the designated test case timeout of 4000ms.

Additional details:

When employing the following code snippet, the test successfully captures an error being rejected by the promise (which can also be customized to reject with a specific string) within approximately 2002ms:

    try {
      await publisher.dispatchMessagelt;ExampleResponseMessagegt;(message, {}, 2 * 1000);
    } catch (err) {
      expect(err).to.be.an('Error');
    }

Seeking guidance:

Can you advise on the correct approach to test if an async function throws an exception effectively?

typescript mocha.js chai chai-as-promised

Answer 1

Answer №1

.to.throw() is not designed to be used with async functions because they do not throw errors; instead, they return rejected promises.

This issue specifically pertains to chai-as-promised. According to this discussion, using .to.eventually.throw() may not produce the expected results. It assumes that a promise will resolve with a function that throws an error synchronously when called, which may not align with the behavior of dispatchMessage.

To address this, consider modifying the test for dispatchMessage as follows:

expect(publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000))
.to.be.rejected;

Answer 2

.to.throw() is not designed to be used with async functions because they do not throw errors; instead, they return rejected promises.

This issue specifically pertains to chai-as-promised. According to this discussion, using .to.eventually.throw() may not produce the expected results. It assumes that a promise will resolve with a function that throws an error synchronously when called, which may not align with the behavior of dispatchMessage.

To address this, consider modifying the test for dispatchMessage as follows:

expect(publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000))
.to.be.rejected;

Answer 3

Answer №2

Make sure to add the chai plugin chai-as-promised using NPM:

npm i -D chai-as-promised @types/chai-as-promised

In your test file, import and utilize this plugin like so:

import { expect, use } from 'chai';
use(require('chai-as-promised'));

An important aspect is using the keyword await before expect, and you can check for a specific error message with rejectedWith:

await expect(myPromise()).to.be.rejectedWith('my Error message');

Chai allows async/await testing functions. For ensuring promise rejection, consider using rejected or rejectedWith from the chai-as-promise plugin.

As rejected returns a promise, ensure to include an await statement; otherwise, the test case might conclude before the promise gets rejected.

it('should be rejected', async () => {
  await expect(
    publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000)
  ).to.be.rejected;
}

Answer 4

Make sure to add the chai plugin chai-as-promised using NPM:

npm i -D chai-as-promised @types/chai-as-promised

In your test file, import and utilize this plugin like so:

import { expect, use } from 'chai';
use(require('chai-as-promised'));

An important aspect is using the keyword await before expect, and you can check for a specific error message with rejectedWith:

await expect(myPromise()).to.be.rejectedWith('my Error message');

Chai allows async/await testing functions. For ensuring promise rejection, consider using rejected or rejectedWith from the chai-as-promise plugin.

As rejected returns a promise, ensure to include an await statement; otherwise, the test case might conclude before the promise gets rejected.

it('should be rejected', async () => {
  await expect(
    publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000)
  ).to.be.rejected;
}

Answer 5

Answer №3

In order to make the other solutions work, it is necessary to utilize chai-as-promised (since they are not compatible with the default chai setup).

For example:

const chai = require('chai');
const chaiAsPromised = require('chai-as-promised');

chai.use(chaiAsPromised);

Prior solution (for reference purposes)

The existing answers were ineffective for me (possibly due to an incompatible Chai version), so I implemented a workaround.

Initially, create this utility function:

const shouldReject = async (promise:Promise<any>, errorClass?:Function|Error, message?:string):Promise<void> => {
  let error = null;
  try {
    await promise;
  }
  catch (e) {
    error = e;
  }
  expect(error).to.not.be.null;
  if(errorClass !== undefined)
    error.should.be.an.instanceOf(errorClass);
  if(message !== undefined)
    error.message.should.equal(message);
};

Within your scenario, you would apply it as follows:

it('should be rejected', async () => {
  await shouldReject(
    publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000)
  );
}

Answer 6

In order to make the other solutions work, it is necessary to utilize chai-as-promised (since they are not compatible with the default chai setup).

For example:

const chai = require('chai');
const chaiAsPromised = require('chai-as-promised');

chai.use(chaiAsPromised);

Prior solution (for reference purposes)

The existing answers were ineffective for me (possibly due to an incompatible Chai version), so I implemented a workaround.

Initially, create this utility function:

const shouldReject = async (promise:Promise<any>, errorClass?:Function|Error, message?:string):Promise<void> => {
  let error = null;
  try {
    await promise;
  }
  catch (e) {
    error = e;
  }
  expect(error).to.not.be.null;
  if(errorClass !== undefined)
    error.should.be.an.instanceOf(errorClass);
  if(message !== undefined)
    error.message.should.equal(message);
};

Within your scenario, you would apply it as follows:

it('should be rejected', async () => {
  await shouldReject(
    publisher.dispatchMessage<ExampleResponseMessage>(message, {}, 2 * 1000)
  );
}

Answer 7

Answer №4

A very effective method I have discovered for anticipating rejected promises in the context of chai and mocha is to utilize the unique two-argument form of the then function. By doing this, there is no need for using chai-as-promised.

await someAsyncApiCall().then(
  () => { throw new Error('Anticipated rejection') },
  () => {}
)

When used this way, the then function executes the first lambda if the promise is fulfilled, and the second lambda if it is rejected.

To enhance reusability, you can define your custom function for this purpose.

async function expectReject(promise, message = 'Expected reject') {
  return promise.then(
    () => { throw new Error(message) },
    () => {}
  )
}

Then, within your test case:

it('should reject', async ()=>{
  await expectReject(someAsyncApiCall())
})

Answer 8

A very effective method I have discovered for anticipating rejected promises in the context of chai and mocha is to utilize the unique two-argument form of the then function. By doing this, there is no need for using chai-as-promised.

await someAsyncApiCall().then(
  () => { throw new Error('Anticipated rejection') },
  () => {}
)

When used this way, the then function executes the first lambda if the promise is fulfilled, and the second lambda if it is rejected.

To enhance reusability, you can define your custom function for this purpose.

async function expectReject(promise, message = 'Expected reject') {
  return promise.then(
    () => { throw new Error(message) },
    () => {}
  )
}

Then, within your test case:

it('should reject', async ()=>{
  await expectReject(someAsyncApiCall())
})

Answer 9

Answer №5

Dealing with async errors using chai seems overly complex to me.

Sometimes, a more straightforward approach can be more appealing:

it('should throw', async () => {
  try {
    await myBadAsyncFunction(someParams)
    assert.fail("Should have thrown")
  } catch (err) {
    assert.strictEqual(err.message, "This should be the error message")
  }
}

This method doesn't involve chai and is easy to comprehend.

Answer 10

Dealing with async errors using chai seems overly complex to me.

Sometimes, a more straightforward approach can be more appealing:

it('should throw', async () => {
  try {
    await myBadAsyncFunction(someParams)
    assert.fail("Should have thrown")
  } catch (err) {
    assert.strictEqual(err.message, "This should be the error message")
  }
}

This method doesn't involve chai and is easy to comprehend.

Examining the asynchronous function to cause an error using mocha

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Formatting Time in Angular 2 Using Typescript

We are unable to update the document in AngularFire as the document reference ID could not be retrieved

Utilize a script in the node package.json file to execute another script while including an additional parameter; for example, incorporating the mocha watcher

Is the parent component not triggering the function properly?

ESLint detected a promise being returned in a function argument where a void return type was expected

Open new tab for Angular OAuth2 OIDC login process

What causes TypeScript to convert a string literal union type to a string when it is assigned in an object literal?

The placeholder within my input moves up and down when switching the input type from password to text

Unable to serve static files when using NextJs in conjunction with Storybook

Tips for addressing the ESLint issue stating that the package should be included in dependencies instead of devDependencies

Resolving issues with Typescript declarations for React Component

Obtaining the identifier of a generic type parameter in Typescript

Tips for triggering a click event automatically after a 2-minute delay in ReactJS using TypeScript

"Array.Find function encounters issues when unable to locate a specific string within the Array

Retrieving array-like form data in a TypeScript file

Guide to incorporating the useEffect hook within a React Native View

Creating interactive features for a TypeScript interface

A guide to integrating a component into another component in Angular

What is the best way to transform private variables in ReactJS into TypeScript?

How to efficiently fetch Redux state through reducers with an action-based approach