Edit

Setup and Teardown

Adesea, în timp ce scrieți teste aveți nevoie de configurări, care trebuie să se ruleze înainte de teste, şi diverse curățări, care trebuie să se ruleze după execuția testelor. Jest oferă funcţii utilitare pentru aceste situații.

Repetarea configurării mai multor teste

Dacă aveţi ceva rulați ceva cod în mod repetat pentru mai multe teste, puteţi utiliza beforeEach şi afterEach.

De exemplu, să prespunem că mai multe teste interacţionează cu o bază de date a oraşelor. Avem o metodă initializeCityDatabase() care trebuie să fie apelată înainte de fiecare dintre aceste teste, si o metodă clearCityDatabase() care trebuie să fie apelată după fiecare dintre aceste teste. Aceasta se poate realiza cu:

beforeEach(() => {
  initializeCityDatabase();
});

afterEach(() => {
  clearCityDatabase();
});

test('city database has Vienna', () => {
  expect(isCity('Vienna')).toBeTruthy();
});

test('city database has San Juan', () => {
  expect(isCity('San Juan')).toBeTruthy();
});

beforeEach şi afterEach pot rula cod asincron în acelaşi mod cum testele pot rula cod asincron - fie primesc un parametru done sau returnează o promisiune. De exemplu, în cazul în care initializeCityDatabase() returnează o promisiune care este rezolvată atunci când baza de date s-a inițializat, ar trebui să returnăm acea promisiune:

beforeEach(() => {
  return initializeCityDatabase();
});

Configurare unică

În unele cazuri, trebuie să configurăm o singură dată, la începutul unui fişier. This can be especially bothersome when the setup is asynchronous, so you can't do it inline. Jest oferă beforeAll şi afterAll pentru aceste situaţii.

De exemplu, dacă initializeCityDatabase şi clearCityDatabase returnează promisiuni, şi baza de date cu oraşe ar putea fi refolosită între teste, am putea schimba codul nostru de testare în felul următor:

beforeAll(() => {
  return initializeCityDatabase();
});

afterAll(() => {
  return clearCityDatabase();
});

test('city database has Vienna', () => {
  expect(isCity('Vienna')).toBeTruthy();
});

test('city database has San Juan', () => {
  expect(isCity('San Juan')).toBeTruthy();
});

Delimitare

În mod implicit, blocurile before şi after se aplică la fiecare test din fişier. Însă puteţi grupa testele împreună folosind un bloc describe. Atunci când acestea sunt în interiorul unui bloc describe, blocurile before şi after se aplică numai la testele din interiorul acelui bloc describe.

De exemplu, să presupunem că nu avem doar o bază de datecu orașe, ci avem și o bază de date de alimente. Am putea face configurări diferite pentru diferite teste:

// Applies to all tests in this file
beforeEach(() => {
  return initializeCityDatabase();
});

test('city database has Vienna', () => {
  expect(isCity('Vienna')).toBeTruthy();
});

test('city database has San Juan', () => {
  expect(isCity('San Juan')).toBeTruthy();
});

describe('matching cities to foods', () => {
  // Applies only to tests in this describe block
  beforeEach(() => {
    return initializeFoodDatabase();
  });

  test('Vienna <3 sausage', () => {
    expect(isValidCityFoodPair('Vienna', 'Wiener Schnitzel')).toBe(true);
  });

  test('San Juan <3 plantains', () => {
    expect(isValidCityFoodPair('San Juan', 'Mofongo')).toBe(true);
  });
});

Note that the top-level beforeEach is executed before the beforeEach inside the describe block. It may help to illustrate the order of execution of all hooks.

beforeAll(() => console.log('1 - beforeAll'));
afterAll(() => console.log('1 - afterAll'));
beforeEach(() => console.log('1 - beforeEach'));
afterEach(() => console.log('1 - afterEach'));
test('', () => console.log('1 - test'));
describe('Scoped / Nested block', () => {
  beforeAll(() => console.log('2 - beforeAll'));
  afterAll(() => console.log('2 - afterAll'));
  beforeEach(() => console.log('2 - beforeEach'));
  afterEach(() => console.log('2 - afterEach'));
  test('', () => console.log('2 - test'));
});

// 1 - beforeAll
// 1 - beforeEach
// 1 - test
// 1 - afterEach
// 2 - beforeAll
// 1 - beforeEach
// 2 - beforeEach
// 2 - test
// 2 - afterEach
// 1 - afterEach
// 2 - afterAll
// 1 - afterAll

Order of execution of describe and test blocks

Jest executes all describe handlers in a test file before it executes any of the actual tests. This is another reason to do setup and teardown inside before* and after* handlers rather than inside the describe blocks. Once the describe blocks are complete, by default Jest runs all the tests serially in the order they were encountered in the collection phase, waiting for each to finish and be tidied up before moving on.

Consider the following illustrative test file and output:

describe('outer', () => {
  console.log('describe outer-a');

  describe('describe inner 1', () => {
    console.log('describe inner 1');
    test('test 1', () => {
      console.log('test for describe inner 1');
      expect(true).toEqual(true);
    });
  });

  console.log('describe outer-b');

  test('test 1', () => {
    console.log('test for describe outer');
    expect(true).toEqual(true);
  });

  describe('describe inner 2', () => {
    console.log('describe inner 2');
    test('test for describe inner 2', () => {
      console.log('test for describe inner 2');
      expect(false).toEqual(false);
    });
  });

  console.log('describe outer-c');
});

// describe outer-a
// describe inner 1
// describe outer-b
// describe inner 2
// describe outer-c
// test for describe inner 1
// test for describe outer
// test for describe inner 2

Sfaturi generale

În cazul în care un test eșuează, unul dintre primele lucruri pe care ar trebui să le verificaţi este dacă dacă testul cade si atunci când rulează doar el. To run only one test with Jest, temporarily change that test command to a test.only:

test.only('this will be the only test that runs', () => {
  expect(true).toBe(false);
});

test('this test will not run', () => {
  expect('A').toBe('A');
});

Dacă aveţi un test care cade adesea atunci când face parte dintr-o suită mai mare de teste, dar nu cade atunci când rulează singur, cu siguranță ceva de la un test precedent interferează cu acesta. Puteţi rezolva adesea acest lucru curățarea stării comune cu beforeEach. If you're not sure whether some shared state is being modified, you can also try a beforeEach that logs data.