如何在 Jest 中测试抛出异常的类型

Question

我正在使用一些代码来测试函数抛出的异常的类型（是 TypeError、ReferenceError 等吗？）。

我当前的测试框架是 AVA，我可以将其作为第二个参数 t.throws 方法进行测试，如下所示：

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

我开始用 Jest 重写我的测试，但找不到如何轻松地做到这一点。有没有可能？

Answer 1

我有同样的问题，唯一的解决方案是使用拒绝，但是如果我无法检查错误的来源，就会出现拒绝的问题。

这篇文章对我的问题有类似的解决方案。

JEST Received function did not throw, but HTTPError is thrown

Answer 2

我设法结合了一些答案并最终得到了这个：

it('should throw', async () => {
    await expect(service.methodName('some@email.com', 'unknown')).rejects.toThrow(
      HttpException,
    );
  });

Answer 3

查看toThrow 方法。

您必须将代码包装在额外的函数回调中！

您应该同时检查：错误消息及其类型。

例如：

expect(
  () => { // additional function wrap
    yourCodeToTest();
  }
).toThrow(
  new RangeError('duplicate prevArray value: A')
);

由于额外的回调包装，代码不会立即运行，所以jest将能够捕获它。

您应始终检查错误消息，以确保您检查的是正确的throw 大小写，并且不会出现您的代码可能出现的另一个错误throw。

检查错误类型也很好，因此客户端代码可能会依赖它。

Answer 4

在 Jest 中，您必须将函数传递给 expect(function).toThrow(<blank or type of error>)。

例子：

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

或者如果您还想检查错误消息：

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

如果您需要测试现有函数是否使用一组参数抛出，您必须将其包装在 expect() 中的匿名函数中。

例子：

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

Answer 5

除了Peter Danis' post，我只想强调他的解决方案中涉及“[传递]一个函数到expect(function).toThrow(空白或错误​​类型)”的部分。

在 Jest 中，当您测试应该抛出错误的情况时，在被测函数的 expect() 包装中，您需要提供一个额外的箭头函数包装层才能使其工作。即

错误（但大多数人的逻辑方法）：

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

对：

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

这很奇怪，但它应该可以成功运行测试。

Answer 6

The documentation 很清楚如何做到这一点。假设我有一个带有两个参数的函数，如果其中一个参数是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

你的测试

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

Answer 7

Modern Jest 允许您对被拒绝的值进行更多检查。例如：

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

将因错误而失败

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

- Expected
+ Received

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

Answer 8

从我（虽然有限）接触到 Jest，我发现expect().toThrow() 适合仅测试特定类型的错误抛出：

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

或者一个带有特定消息的错误被抛出：

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

如果你同时尝试两者，你会得到一个误报。例如，如果您的代码抛出RangeError('Something bad happened!')，则此测试将通过：

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

The answer by bodolsog 建议使用 try/catch 很接近，但不要期望 true 为 false 以确保命中 catch 中的预期断言，您可以在测试开始时使用 expect.assertions(2) @ 987654329@ 是预期断言的数量。我觉得这更准确地描述了测试的意图。

测试错误的类型和消息的完整示例：

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

如果functionUnderTest()不抛出错误，断言会被命中，但expect.assertions(2)会失败，测试也会失败。

Answer 9

我使用了一个更简洁的版本：

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

Answer 10

试试：

expect(t).rejects.toThrow()

Answer 11

这有点奇怪，但它有效，恕我直言，可读性很好：

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

Catch 块会捕获您的异常，然后您可以在引发的Error 上进行测试。如果不抛出预期的Error，则需要奇怪的expect(true).toBe(false); 才能使您的测试失败。否则，这条线永远无法到达（Error 应该在他们之前提出）。

@Kenny Body 提出了一个更好的解决方案，如果您使用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");
  }
});

更多解释请参见原始答案：How to test the type of a thrown exception in Jest

Answer 12

Jest 有一个方法，toThrow(error)，用于测试函数在被调用时是否抛出。

所以，在你的情况下，你应该这样称呼它：

expect(t).toThrowError(TypeError);

The documentation.

Answer 13

我自己没有尝试过，但我建议使用 Jest 的 toThrow 断言。所以我猜你的例子看起来像这样：

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

同样，我还没有测试它，但我认为它应该可以工作。

Answer 14

如果您使用的是Promises：

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

Answer 15

我最终为我们的 test-utils 库编写了一个方便的方法

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