Et asynkront eksempel

Unofficial Beta Translation

This page was AI-translated by PageTurner (beta). Not officially endorsed by the project. Found an error? Report issue →

Først må du aktivere Babel-støtte i Jest som beskrevet i Komme i gang-guiden.

La oss implementere en modul som henter brukerdata fra et API og returnerer brukernavnet.

user.js

import request from './request';

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

I implementasjonen ovenfor forventer vi at request.js-modulen returnerer en promise. Vi kjeder et kall til then for å motta brukernavnet.

Se for deg en implementering av request.js som går ut på nettet for å hente brukerdata:

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

Siden vi ikke ønsker å gå ut på nettet i testen vår, skal vi opprette en manuell mock for request.js-modulen i __mocks__-mappen (mappenavnet er case-sensitivt - __MOCKS__ vil ikke fungere). Den kan se omtrent slik ut:

__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.`,
          }),
    );
  });
}

La oss nå skrive en test for vår asynkrone funksjonalitet.

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

Vi kaller jest.mock('../request') for å fortelle Jest at den skal bruke vår manuelle mock. it forventer at returverdien er en promise som skal oppfylles. Du kan koble så mange promises du vil og kalle expect når som helst, så lenge du returnerer en promise til slutt.

.resolves

Det finnes en mer kortfattet måte å bruke resolves for å pakke ut verdien av en oppfylt promise sammen med en hvilken som helst annen matcher. Dersom promise blir avvist, vil asserjonen feile.

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

async/await

Du kan også skrive tester med async/await-syntaks. Slik ville du skrevet de samme eksemplene:

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

For å aktivere async/await i prosjektet ditt, installer @babel/preset-env og aktiver funksjonen i babel.config.js-filen din.

Feilhåndtering

Feil kan håndteres med .catch-metoden. Husk å legge til expect.assertions for å bekrefte at et visst antall asserjoner blir kalt. Ellers vil en oppfylt promise ikke føre til at testen feiler:

// 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

Hjelpefunksjonen .rejects fungerer på samme måte som .resolves. Dersom promise oppfylles, vil testen automatisk feile. expect.assertions(number) er ikke påkrevd, men anbefales for å bekrefte at et visst antall asserjoner kjøres under testen. Det er ellers lett å glemme å return eller awaite .resolves-asserjonene.

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

Koden for dette eksempelet finner du på examples/async.

Hvis du ønsker å teste timere som setTimeout, kan du se Timer mocks-dokumentasjonen.