javascript - How to test the type of a thrown exception in Jest - Stack Overflow

admin管理员组

文章数量:1125781

I'm working with some code where I need to test the type of an exception thrown by a function (is it TypeError, ReferenceError, etc.?).

My current testing framework is AVA and I can test it as a second argument t.throws method, like here:

it('should throw Error with message \'UNKNOWN ERROR\' when no params were passed', (t) => {
  const error = t.throws(() => {
    throwError();
  }, TypeError);

  t.is(error.message, 'UNKNOWN ERROR');
});

I started rewriting my tests in Jest and couldn't find how to easily do that. Is it even possible?

I'm working with some code where I need to test the type of an exception thrown by a function (is it TypeError, ReferenceError, etc.?).

My current testing framework is AVA and I can test it as a second argument t.throws method, like here:

it('should throw Error with message \'UNKNOWN ERROR\' when no params were passed', (t) => {
  const error = t.throws(() => {
    throwError();
  }, TypeError);

  t.is(error.message, 'UNKNOWN ERROR');
});

I started rewriting my tests in Jest and couldn't find how to easily do that. Is it even possible?

• javascript
• unit-testing
• jestjs

Share Improve this question Follow edited Sep 24, 2020 at 18:05 Peter Mortensen 31.6k2222 gold badges109109 silver badges133133 bronze badges asked Sep 4, 2017 at 18:43 bartsmyklabartsmykla 6,01122 gold badges1212 silver badges66 bronze badges 1

• 10 Check out this one when async: stackoverflow.com/q/47144187/1505348 – Lucio Commented Jul 16, 2021 at 7:57

Add a comment  | 

23 Answers 23

Sorted by: Reset to default 831

In Jest you have to pass a function into expect(function).toThrow(<blank or type of error>).

Example:

test("Test description", () => {
  const t = () => {
    throw new TypeError();
  };
  expect(t).toThrow(TypeError);
});

Or if you also want to check for error message:

test("Test description", () => {
  const t = () => {
    throw new TypeError("UNKNOWN ERROR");
  };
  expect(t).toThrow(TypeError);
  expect(t).toThrow("UNKNOWN ERROR");
});

If you need to test an existing function whether it throws with a set of arguments, you have to wrap it inside an anonymous function in expect().

Example:

test("Test description", () => {
  expect(() => {http.get(yourUrl, yourCallbackFn)}).toThrow(TypeError);
});

It is a little bit weird, but it works and IMHO is good readable:

it('should throw Error with message \'UNKNOWN ERROR\' when no parameters were passed', () => {
  try {
      throwError();
      // Fail test if above expression doesn't throw anything.
      expect(true).toBe(false);
  } catch (e) {
      expect(e.message).toBe("UNKNOWN ERROR");
  }
});

The Catch block catches your exception, and then you can test on your raised Error. Strange expect(true).toBe(false); is needed to fail your test if the expected Error will be not thrown. Otherwise, this line is never reachable (Error should be raised before them).

@Kenny Body suggested a better solution which improve a code quality if you use expect.assertions():

it('should throw Error with message \'UNKNOWN ERROR\' when no parameters were passed', () => {
  expect.assertions(1);
  try {
      throwError();
  } catch (e) {
      expect(e.message).toBe("UNKNOWN ERROR");
  }
});

See the original answer with more explanations: How to test the type of a thrown exception in Jest

EDIT 2022:

To use this approach and not trigger no-conditional-expect rule (if you're using eslint-plugin-jest), documentation of this rule suggest to use error wrapper:

class NoErrorThrownError extends Error {}

const getError = async <TError>(call: () => unknown): Promise<TError> => {
  try {
    await call();

    throw new NoErrorThrownError();
  } catch (error: unknown) {
    return error as TError;
  }
};

describe('when the http request fails', () => {
  it('includes the status code in the error', async () => {
    const error = await getError(async () => makeRequest(url));

    // check that the returned error wasn't that no error was thrown
    expect(error).not.toBeInstanceOf(NoErrorThrownError);
    expect(error).toHaveProperty('statusCode', 404);
  });
});

See: no-conditional-expect docs

I use a slightly more concise version:

expect(() => {
  // Code block that should throw error
}).toThrow(TypeError) // Or .toThrow('expectedErrorMessage')

From my (albeit limited) exposure to Jest, I have found that expect().toThrow() is suitable if you want to only test an error is thrown of a specific type:

expect(() => functionUnderTest()).toThrow(TypeError);

Or an error is thrown with a specific message:

expect(() => functionUnderTest()).toThrow('Something bad happened!');

If you try to do both, you will get a false positive. For example, if your code throws RangeError('Something bad happened!'), this test will pass:

expect(() => functionUnderTest()).toThrow(new TypeError('Something bad happened!'));

The answer by bodolsog which suggests using a try/catch is close, but rather than expecting true to be false to ensure the expect assertions in the catch are hit, you can instead use expect.assertions(2) at the start of your test where 2 is the number of expected assertions. I feel this more accurately describes the intention of the test.

A full example of testing the type and message of an error:

describe('functionUnderTest', () => {
    it('should throw a specific type of error.', () => {
        expect.assertions(2);

        try {
            functionUnderTest();
        } catch (error) {
            expect(error).toBeInstanceOf(TypeError);
            expect(error).toHaveProperty('message', 'Something bad happened!');
        }
    });
});

If functionUnderTest() does not throw an error, the assertions will be be hit, but the expect.assertions(2) will fail and the test will fail.

I manage to combine some answers and end up with this:

it('should throw', async () => {
    await expect(service.methodName('[email protected]', 'unknown')).rejects.toThrow(
      HttpException,
    );
  });

Modern Jest allows you to make more checks on a rejected value. For example, you could test status code of http exception:

const request = Promise.reject({statusCode: 404})
await expect(request).rejects.toMatchObject({ statusCode: 500 });

will fail with error

Error: expect(received).rejects.toMatchObject(expected)

- Expected
+ Received

  Object {
-   "statusCode": 500,
+   "statusCode": 404,
  }

Further to Peter Danis' post, I just wanted to emphasize the part of his solution involving "[passing] a function into expect(function).toThrow(blank or type of error)".

In Jest, when you test for a case where an error should be thrown, within your expect() wrapping of the function under testing, you need to provide one additional arrow function wrapping layer in order for it to work. I.e.

Wrong (but most people's logical approach):

expect(functionUnderTesting();).toThrow(ErrorTypeOrErrorMessage);

Right:

expect(() => { functionUnderTesting(); }).toThrow(ErrorTypeOrErrorMessage);

It's very strange, but it should make the testing run successfully.

In case you are working with Promises:

await expect(Promise.reject(new HttpException('Error message', 402)))
  .rejects.toThrowError(HttpException);

Check out toThrow method.

You must wrap the code in an additional function callback!

You should check both: the error message and its type.

For example:

// additional function wrap
const wrap = () => {
  yourCodeToTest();
};

// test error message
expect(wrap).toThrow('UNKNOWN ERROR');

// test error type
expect(wrap).toThrow(TypeError);

Because of additional callback wrap, the code will not be run immediately, so jest will be able to catch it.

You should always check the error message to be sure you are checking the correct throw case and not getting another error your code may throw.

It is also nice to check the error type, so the client code may rely on it.

There's a way to wait an error that comes from a async function, you just have to write your code like in the example bellow

await expect(yourAsyncFunction()).rejects.toThrowError();

You must wrap the code of the function that you are expecting in another arrow function, otherwise the error will not be caught and the assertion will fail.

the function you want to test :

const testThrowingError = () => {
    throw new Error();
  };

the test:

describe("error function should Throw Error", () => {
  expect(() =>testThrowingError()).toThrowError();
});

resource: https://jestjs.io/docs/expect#tothrowerror

I haven't tried it myself, but I would suggest using Jest's toThrow assertion. So I guess your example would look something like this:

it('should throw Error with message \'UNKNOWN ERROR\' when no parameters were passed', (t) => {
  const error = t.throws(() => {
    throwError();
  }, TypeError);

  expect(t).toThrowError('UNKNOWN ERROR');
  //or
  expect(t).toThrowError(TypeError);
});

Again, I haven't test it, but I think it should work.

I have successfully used this

await expect(
      async () => await apiCalls()
    ).rejects.toThrow();

Jest has a method, toThrow(error), to test that a function throws when it is called.

So, in your case you should call it so:

expect(t).toThrowError(TypeError);

The documentation.

Jest version: 29
You have an async function that needs to be tested for throwing an error.

await expect(listener.onMessage(data, msg)).rejects.toThrow();

Assert with exact error message:

await expect(listener.onMessage(data, msg)).rejects.toThrow("Data not found!");

The documentation is clear on how to do this. Let's say I have a function that takes two parameters and it will throw an error if one of them is null.

function concatStr(str1, str2) {
  const isStr1 = str1 === null
  const isStr2 = str2 === null
  if(isStr1 || isStr2) {
    throw "Parameters can't be null"
  }
  ... // Continue your code

Your test

describe("errors", () => {
  it("should error if any is null", () => {
    // Notice that the expect has a function that returns the function under test
    expect(() => concatStr(null, "test")).toThrow()
  })
})

There is also an easier way to assert against the error message. The beauty of this method is that you don't need to reconstruct the error object or to have the full error message. As long as your error contains part of the error message we can assume that it is of the correct type. i.e

 const printOnlyString = (str) => {
   if(typeof str !== "string"){
     throw Error("I can only print strings ${typeof str) given");
   }
   else {
     console.log(str);
   } 
 }

expect(() => printOnlyString(123)).toThrow(/can only print strings/)

I ended up writing a convenience method for our test-utils library

/**
 *  Utility method to test for a specific error class and message in Jest
 * @param {fn, expectedErrorClass, expectedErrorMessage }
 * @example   failTest({
      fn: () => {
        return new MyObject({
          param: 'stuff'
        })
      },
      expectedErrorClass: MyError,
      expectedErrorMessage: 'stuff not yet implemented'
    })
 */
  failTest: ({ fn, expectedErrorClass, expectedErrorMessage }) => {
    try {
      fn()
      expect(true).toBeFalsy()
    } catch (err) {
      let isExpectedErr = err instanceof expectedErrorClass
      expect(isExpectedErr).toBeTruthy()
      expect(err.message).toBe(expectedErrorMessage)
    }
  }

To test whether a function throws a specific error message with a specific type of error, you can use Jest's toThrow() matcher

function myFunction() {
  throw new TypeError('Something went wrong');
}

describe('myFunction', () => {
  it('should throw a TypeError with a specific error message', () => {
    expect(myFunction).toThrow(TypeError);
    expect(myFunction).toThrow(/Something went wrong/);

    //noted: this way will invoke the myFunction twice
    expect(myFunction).toBeCalledTimes(2)
  });
});

If you use expect(myFunction).toThrow(new TypeError("Something went wrong"), it only checks the error message rather than the error type, which does not meet the test purpose.

Similar to the try/catch, if you are looking to catch an error for an async function one can also just append a .catch() to the function to be able to access error value: await asyncFunc().catch(e => { expect(e.toString()).toBe("Error: My error message") }) or whatever functionality you are looking to test

A good way is to create custom error classes and mock them. Then you can assert whatever you want.

MessedUpError.ts

type SomeCrazyErrorObject = {
  [key: string]: unknown,
}

class MessedUpError extends Error {
  private customErrorData: SomeCrazyErrorObject = {};

  constructor(err?: string, data?: SomeCrazyErrorObject) {
    super(err || 'You messed up');

    Object.entries(data ?? {}).forEach(([Key, value]) => {
      this.customErrorData[Key] = value;
    });
    Error.captureStackTrace(this, this.constructor);
  }

  logMe() {
    console.log(this.customErrorData);
  }
}

export default MessedUpError;

messedUpError.test.ts

import MessedUpError from './MessedUpError';

jest.mock('./MessedUpError', () => jest.fn().mockImplementation((...args: any[]) => ({
  constructor: args,
  log: () => {},
})));

type MessedUpErrorContructorParams = Expand<typeof MessedUpError['prototype']>
const MessedUpErrorMock = MessedUpError as unknown as jest.Mock<MessedUpError, [MessedUpErrorContructorParams]>;

const serverErrorContructorCall = (i = 0) => ({
  message: MessedUpErrorMock.mock.calls[i][0],
  ...MessedUpErrorMock.mock.calls[i][1] || {},
});

beforeEach(() => {
  MessedUpErrorMock.mockClear();
});

test('Should throw', async () => {
  try {
    await someFunctionThatShouldThrowMessedUpError();
  } catch {} finally {
    expect(MessedUpErrorMock).toHaveBeenCalledTimes(1);
    const constructorParams = serverErrorContructorCall();
    expect(constructorParams).toHaveProperty('message', 'You messed up');
    expect(constructorParams).toHaveProperty('customErrorProperty', 'someValue');
  }
});

The assertions always go inside the finally clause. This way it will always be asserted. Even if the test does not throw any errors.

If you want something less verbose in your tests but want to test an Error is of a class and has a certain message (or status, or any other properties), you can write a custom matcher.

We use something pretty simple, but you can extend this to include RegExp, etc.

// In jest.setup.js
expect.extend({
  toThrowErrorWithMessage: (received, errorType, message) => {
    if (!received) {
      return {
        message: () =>
          `expected error to be of type ${errorType.name} with message matching ${message}, received ${received}`,
        pass: false,
      };
    }

    if (!(received instanceof errorType)) {
      return {
        message: () => `expected error of type ${errorType} received ${received}`,
        pass: false,
      };
    }

    const validMessage = received.message && received.message.match(message);

    if (!validMessage) {
      return {
        message: () =>
          `expected error message to match "${message}", received "${received.message}"`,
        pass: false,
      };
    }

    return {
      pass: true,
      // Note: this message is for when using .not
      message: () =>
        `expected error not to be of type ${errorType.name} with message matching "${message}"`,
    };
  },
});

// In a test
expect(() => validate()).rejects.toThrowErrorWithMessage(BadRequestError, 'Oh noes')

Try:

expect(t).rejects.toThrow()

本文标签： javascriptHow to test the type of a thrown exception in JestStack Overflow