Versión: Siguiente

Configuración y Finalización

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

A menudo, al escribir pruebas, necesitas realizar trabajos de configuración antes de ejecutar los tests y tareas de limpieza después de ejecutarlos. Jest proporciona funciones auxiliares para manejar esto.

Configuración Repetitiva

Si necesitas realizar alguna tarea repetidamente para varias pruebas, puedes usar los hooks beforeEach y afterEach.

Por ejemplo, supongamos que varias pruebas interactúan con una base de datos de ciudades. Tienes un método initializeCityDatabase() que debe llamarse antes de cada prueba, y un método clearCityDatabase() que debe llamarse después de cada prueba. Puedes hacerlo así:

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 y afterEach pueden manejar código asíncrono de las mismas formas que las pruebas manejan código asíncrono: pueden tomar un parámetro done o devolver una promesa. Por ejemplo, si initializeCityDatabase() devolviera una promesa que se resuelve cuando la base de datos está inicializada, querríamos devolver esa promesa:

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

Configuración Única

En algunos casos, solo necesitas hacer configuración una vez, al principio de un archivo. Esto puede ser especialmente molesto cuando la configuración es asíncrona y no puedes hacerla en línea. Jest proporciona los hooks beforeAll y afterAll para manejar esta situación.

Por ejemplo, si tanto initializeCityDatabase() como clearCityDatabase() devolvieran promesas, y la base de datos de ciudades pudiera reutilizarse entre pruebas, podríamos cambiar nuestro código de prueba a:

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

Ámbito

Los hooks before* y after* de nivel superior se aplican a todas las pruebas en un archivo. Los hooks declarados dentro de un bloque describe solo se aplican a las pruebas dentro de ese bloque describe.

Por ejemplo, supongamos que tenemos no solo una base de datos de ciudades, sino también una base de datos de alimentos. Podríamos hacer configuraciones diferentes para diferentes pruebas:

// 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 veal', () => {
    expect(isValidCityFoodPair('Vienna', 'Wiener Schnitzel')).toBe(true);
  });

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

Nota que el beforeEach de nivel superior se ejecuta antes del beforeEach dentro del bloque describe. Puede ser útil ilustrar el orden de ejecución de todos los 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

Orden de Ejecución

Jest ejecuta todos los manejadores describe en un archivo de prueba antes de ejecutar cualquiera de las pruebas reales. Esta es otra razón para hacer configuración y limpieza dentro de los manejadores before* y after* en lugar de dentro de los bloques describe. Una vez completados los bloques describe, Jest ejecuta todas las pruebas en serie según el orden en que fueron encontradas durante la fase de recolección, esperando a que cada una termine y se limpie antes de continuar.

Considera el siguiente archivo de prueba ilustrativo y su salida:

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

  describe('describe inner 1', () => {
    console.log('describe inner 1');

    test('test 1', () => console.log('test 1'));
  });

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

  test('test 2', () => console.log('test 2'));

  describe('describe inner 2', () => {
    console.log('describe inner 2');

    test('test 3', () => console.log('test 3'));
  });

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

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

Al igual que los bloques describe y test, Jest llama a los hooks before* y after* en el orden de declaración. Ten en cuenta que los hooks after* del ámbito envolvente se llaman primero. Por ejemplo, así es como puedes configurar y desmontar recursos que dependen unos de otros:

beforeEach(() => console.log('connection setup'));
beforeEach(() => console.log('database setup'));

afterEach(() => console.log('database teardown'));
afterEach(() => console.log('connection teardown'));

test('test 1', () => console.log('test 1'));

describe('extra', () => {
  beforeEach(() => console.log('extra database setup'));
  afterEach(() => console.log('extra database teardown'));

  test('test 2', () => console.log('test 2'));
});

// connection setup
// database setup
// test 1
// database teardown
// connection teardown

// connection setup
// database setup
// extra database setup
// test 2
// extra database teardown
// database teardown
// connection teardown

nota

Si estás usando el corredor de pruebas jasmine2, ten en cuenta que llama a los hooks after* en orden inverso a su declaración. Para obtener una salida idéntica, el ejemplo anterior debería modificarse así:

  beforeEach(() => console.log('connection setup'));
+ afterEach(() => console.log('connection teardown'));

  beforeEach(() => console.log('database setup'));
+ afterEach(() => console.log('database teardown'));

- afterEach(() => console.log('database teardown'));
- afterEach(() => console.log('connection teardown'));

  // ...

Consejos Generales

Si una prueba falla, una de las primeras cosas que debes verificar es si la prueba falla cuando es la única que se ejecuta. Para ejecutar solo una prueba con Jest, cambia temporalmente el comando test por 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');
});

Si tienes una prueba que falla con frecuencia cuando se ejecuta como parte de un conjunto más grande, pero no falla cuando la ejecutas sola, es muy probable que otra prueba esté interfiriendo con esta. Normalmente puedes solucionarlo limpiando algún estado compartido con beforeEach. Si no estás seguro de si se está modificando algún estado compartido, también puedes probar con un beforeEach que registre datos.

Configuración Repetitiva​

Configuración Única​

Ámbito​

Orden de Ejecución​

Consejos Generales​

Configuración Repetitiva

Configuración Única

Ámbito

Orden de Ejecución

Consejos Generales