Um Exemplo Assíncrono

Tradução Beta Não Oficial

Esta página foi traduzida por PageTurner AI (beta). Não é oficialmente endossada pelo projeto. Encontrou um erro? Reportar problema →

Primeiro, habilite o suporte ao Babel no Jest conforme documentado no guia Introdução.

Vamos implementar um módulo que busca dados de usuário de uma API e retorna o nome do usuário.

user.js

import request from './request';

export function getUserName(userID) {
  return request(`/users/${userID}`).then(user => user.name);
}

Na implementação acima, esperamos que o módulo request.js retorne uma promise. Encadeamos uma chamada a then para receber o nome do usuário.

Agora imagine uma implementação do request.js que acessa a rede e busca alguns dados de usuário:

request.js

const http = require('http');

export default function request(url) {
  return new Promise(resolve => {
    // This is an example of an http request, for example to fetch
    // user data from an API.
    // This module is being mocked in __mocks__/request.js
    http.get({path: url}, response => {
      let data = '';
      response.on('data', _data => (data += _data));
      response.on('end', () => resolve(data));
    });
  });
}

Como não queremos acessar a rede nos nossos testes, vamos criar um mock manual para nosso módulo request.js na pasta __mocks__ (a pasta diferencia maiúsculas/minúsculas - __MOCKS__ não funcionará). Poderia ser algo assim:

__mocks__/request.js

const users = {
  4: {name: 'Mark'},
  5: {name: 'Paul'},
};

export default function request(url) {
  return new Promise((resolve, reject) => {
    const userID = parseInt(url.slice('/users/'.length), 10);
    process.nextTick(() =>
      users[userID]
        ? resolve(users[userID])
        : reject({
            error: `User with ${userID} not found.`,
          }),
    );
  });
}

Agora vamos escrever um teste para nossa funcionalidade assíncrona.

__tests__/user-test.js

jest.mock('../request');

import * as user from '../user';

// The assertion for a promise must be returned.
it('works with promises', () => {
  expect.assertions(1);
  return user.getUserName(4).then(data => expect(data).toBe('Mark'));
});

Chamamos jest.mock('../request') para instruir o Jest a usar nosso mock manual. O it espera que o valor retornado seja uma Promise que será resolvida. Você pode encadear quantas Promises quiser e chamar expect a qualquer momento, desde que retorne uma Promise no final.

.resolves

Existe uma forma menos verbosa usando resolves para desempacotar o valor de uma promise resolvida junto com qualquer outro matcher. Se a promise for rejeitada, a asserção falhará.

it('works with resolves', () => {
  expect.assertions(1);
  return expect(user.getUserName(5)).resolves.toBe('Paul');
});

async/await

Também é possível escrever testes usando a sintaxe async/await. Veja como você escreveria os mesmos exemplos anteriores:

// async/await can be used.
it('works with async/await', async () => {
  expect.assertions(1);
  const data = await user.getUserName(4);
  expect(data).toBe('Mark');
});

// async/await can also be used with `.resolves`.
it('works with async/await and resolves', async () => {
  expect.assertions(1);
  await expect(user.getUserName(5)).resolves.toBe('Paul');
});

Para habilitar async/await no seu projeto, instale @babel/preset-env e ative o recurso no seu arquivo babel.config.js.

Tratamento de erros

Erros podem ser tratados usando o método .catch. Certifique-se de adicionar expect.assertions para verificar que um número específico de asserções é chamado. Caso contrário, uma promise resolvida não falharia o teste:

// Testing for async errors using Promise.catch.
it('tests error with promises', () => {
  expect.assertions(1);
  return user.getUserName(2).catch(error =>
    expect(error).toEqual({
      error: 'User with 2 not found.',
    }),
  );
});

// Or using async/await.
it('tests error with async/await', async () => {
  expect.assertions(1);
  try {
    await user.getUserName(1);
  } catch (error) {
    expect(error).toEqual({
      error: 'User with 1 not found.',
    });
  }
});

.rejects

O auxiliar .rejects funciona como o .resolves. Se a promise for resolvida, o teste falhará automaticamente. expect.assertions(number) não é obrigatório mas recomendado para verificar que um certo número de asserções são chamadas durante o teste. Caso contrário, é fácil esquecer de fazer return/await nas asserções .resolves.

// Testing for async errors using `.rejects`.
it('tests error with rejects', () => {
  expect.assertions(1);
  return expect(user.getUserName(3)).rejects.toEqual({
    error: 'User with 3 not found.',
  });
});

// Or using async/await with `.rejects`.
it('tests error with async/await and rejects', async () => {
  expect.assertions(1);
  await expect(user.getUserName(3)).rejects.toEqual({
    error: 'User with 3 not found.',
  });
});

O código deste exemplo está disponível em examples/async.

Se quiser testar temporizadores como setTimeout, consulte a documentação sobre Timer mocks.