异步示例

    Let’s implement a module that fetches user data from an API and returns the user name.

    user.js

    In the above implementation, we expect the request.js module to return a promise. We chain a call to then to receive the user name. We chain a call to then to receive the user name.

    Now imagine an implementation of request.js that goes to the network and fetches some user data:

    request.js

    1. const http = require('http');
    3. export default function request(url) {
    4.   return new Promise(resolve => {
    5.     // This is an example of an http request, for example to fetch
    6.     // user data from an API.
    7.     // This module is being mocked in __mocks__/request.js
    8.     http.get({path: url}, response => {
    9.       let data = '';
    10.       response.on('data', _data => (data += _data));
    11.       response.on('end', () => resolve(data));
    12.     });
    13.   });
    14. }

    __mocks__/request.js

    现在我们就来编写我们的异步函数的测试

    __tests__/user-test.js

    1. jest.mock('../request');
    3. import * as user from '../user';
    4. // The assertion for a promise must be returned.
    5. it('works with promises', () => {
    7.   return user.getUserName(4).then(data => expect(data).toEqual('Mark'));
    8. });

    我们调用 jest.mock('../request ') 告诉jest 使用我们手动的创建的模拟数据。 通过 resolves能更加简单地解析一个fulfilled 态的 Promise的返回值. 如果Promise是rejected态的话, 断言将会返回失败. it 断言的是将会返回一个Promise对象. You can chain as many Promises as you like and call expect at any time, as long as you return a Promise at the end.

    There is a less verbose way using resolves to unwrap the value of a fulfilled promise together with any other matcher. If the promise is rejected, the assertion will fail.

    1. // 使用async/await
    2. // 使用async/await
    3. it('works with async/await', async () => {
    4.   expect.assertions(1);
    5.   const data = await user.getUserName(4);
    6.   expect(data).toEqual('Mark');
    7. });
    9. // async/await 也可以和 `.resolves` 一起使用.
    10. it('works with async/await and resolves', async () => {
    11.   expect.assertions(1);
    12.   await expect(user.getUserName(5)).resolves.toEqual('Paul');
    13. });
    14. it('works with async/await and resolves', async () => {
    15.   expect.assertions(1);
    16.   await expect(user.getUserName(5)).resolves.toEqual('Paul');

    To enable async/await in your project, install @babel/preset-env and enable the feature in your babel.config.js file.

    可以使用 方法处理错误。 请确保添加 expect.assertions 来验证一定数量的断言被调用。 否则一个fulfilled态的Promise 不会让测试失败︰

    The.rejects helper works like the .resolves helper. 如果 Promise 被拒绝，则测试将自动失败。 如果 Promise 被拒绝，则测试将自动失败。 expect.assertions(number) is not required but recommended to verify that a certain number of are called during a test. It is otherwise easy to forget to return/await the .resolves assertions.

    1. // 用`.rejects`.来测试一个异步的错误
    2. // 用`.rejects`.来测试一个异步的错误
    3. it('tests error with rejects', () => {
    4.   expect.assertions(1);
    5.   return expect(user.getUserName(3)).rejects.toEqual({
    6.     error: 'User with 3 not found.',
    7.   });
    8. });
    10. // 或者与async/await 一起使用 `.rejects`.
    11. it('tests error with async/await and rejects', async () => {
    12.   expect.assertions(1);
    13.   await expect(user.getUserName(3)).rejects.toEqual({
    14.     error: 'User with 3 not found.',
    15.   });
    16. });
    17. it('tests error with async/await and rejects', async () => {
    18.   expect.assertions(1);
    19.   await expect(user.getUserName(3)).rejects.toEqual({
    20.     error: 'User with 3 not found.',
    21.   });

    The code for this example is available at examples/async.

    If you’d like to test timers, like , take a look at the documentation.