Setup and Teardown

Resumen

setup/Teardown

En Jest hay cláusulas para isolar las pruebas, donde un escenario de pruebas no afecte a otro, para ello se agrupan los casos con describe().
Teardown se trata de demoler o quitar casos de prueba anteriores para que no afecten en el actual al usar los hooks, que son sentencias adicionales según el tiempo de ejecución del grupo o los casos.

Codigo comentado

// describe reune un conjunto de bruebas, mejora la lectura del código y la encapsulación.
describe('gruop 1', () => {
  // beforeAll es una sentencia [setup] que corre antes de todas las pruebas xej up db
  // este tipo de utilidad se puede llamar hook y respeta el alcance o scope del grupo (describe).
  beforeAll(() => {
    console.log('beforeAll');
    // up db
  });
  // afterAll es lo mismo pero después XD.
  afterAll(() => {
    console.log('afterAll');
    // down db
  });
  // beforeEach corre antes de cada caso de prueba hasta el último.
  beforeEach(() => {
    console.log(beforeEach);
  });
  // afterEach es lo mismo pero después XD.
  afterEach(() => {
    console.log(afterEach);
  });
  // eslint-disable-next-line no-trailing-spaces

  test('case 1', () => {
    console.log('case 1');
    expect(1 + 1).toBe(2);
  });
  test('case 2', () => {
    console.log('case 2');
    expect(1 + 3).toBe(4);
  });

  // En pruebas estáticas en producción es mala práctica poner console.log.

  describe('group 2', () => {
    beforeAll(() => {
      console.log('beforeAll 2');
      // up db
    });
    test('case 3', () => {
      console.log('case 3');
      expect(1 + 1).toBe(2);
    });
    test('case 4', () => {
      console.log('case 4');
      expect(1 + 3).toBe(4);
    });
  });
});

• OUT Terminal

 ~/.../testing-js/demos   master ●  npm run test

> demos@1.0.0 test
> jest

 PASS  src/05-setup.test.js
  ● Console

    console.log
      beforeAll

      at Object.log (src/05-setup.test.js:7:13)

    console.log
      [Function: beforeEach]

      at Object.log (src/05-setup.test.js:17:13)

    console.log
      case 1

      at Object.log (src/05-setup.test.js:26:13)

    console.log
      [Function: afterEach]

      at Object.log (src/05-setup.test.js:21:13)

    console.log
      [Function: beforeEach]

      at Object.log (src/05-setup.test.js:17:13)

    console.log
      case 2

      at Object.log (src/05-setup.test.js:30:13)

    console.log
      [Function: afterEach]

      at Object.log (src/05-setup.test.js:21:13)

    console.log
      beforeAll 2

      at Object.log (src/05-setup.test.js:38:15)

    console.log
      [Function: beforeEach]

      at Object.log (src/05-setup.test.js:17:13)

    console.log
      case 3

      at Object.log (src/05-setup.test.js:42:15)

    console.log
      [Function: afterEach]

      at Object.log (src/05-setup.test.js:21:13)

    console.log
      [Function: beforeEach]

      at Object.log (src/05-setup.test.js:17:13)

    console.log
      case 4

      at Object.log (src/05-setup.test.js:46:15)

    console.log
      [Function: afterEach]

      at Object.log (src/05-setup.test.js:21:13)

    console.log
      afterAll

      at Object.log (src/05-setup.test.js:12:13)

 PASS  src/04-assertions.test.js
 PASS  src/02-math.test.js
 PASS  src/01-sum.test.js

Test Suites: 4 passed, 4 total
Tests:       18 passed, 18 total
Snapshots:   0 total
Time:        0.761 s, estimated 1 s
Ran all test suites.

Esto explica muchas cosas. xDD
Encontraba ejemplos con estos hooks y no entendía nada.

Setup / Teardown

En Jest hay cláusulas para isolar las pruebas, donde un escenario de pruebas no afecte a otro, para ello se agrupan los casos con describe().

Teardown se trata de demoler o quitar casos de prueba anteriores para que no afecten en el actual al usar los hooks, que son sentencias adicionales según el tiempo de ejecución del grupo o los casos.

Veamos ahora como hacer esto:

// Podemos encerrar varios test() dentro de este describe()
/* Esto nos sirve para cosas como mejorar la lectura y el
encapsulamiento */
describe('conjuto', () => {
  test('case 1', () => {
    expect(1 + 1).toBe(2);
  });

  test('case 2', () => {
    expect(2 + 2).toBe(4);
  });

  // Inlcuso podemos tener conjuntos de test unos dentro de otros
  describe('conjunto dentro de conjunto', () => {
    test('case 3', () => {
      expect(3 + 3).toBe(6);
    });

    test('case 4', () => {
      expect(4 + 4).toBe(8);
    });
  });
});

También podemos tener cosas como el beforeAll(), el cual es una sentencia que se ejecuta antes de todas las pruebas.

describe('conjuto', () => {
  beforeAll(() => {
    // se ejecuta antes de todas las pruebas.
  });
	...
});

Esto nos sirve por ejemplo: en caso de que necesitemos levantar una base de datos antes de hacer las pruebas para tener los datos necesarios.

EL afterAll() se ejecuta después de que se ejecute todas las pruebas, en todos los casos de prueba.

describe('conjuto', () => {
  afterAll(() => {
    // Se ejecuta después de todas las pruebas
  });
	...
});

Esto nos puede servir por ejemplo para una vez ejecutada la prueba podamos bajar la base de datos en nuestro test.

EL beforeEach(), es una sentencia que se va a ejecutar por cada una de las pruebas, ósea en vez de hacerlo antes de que se hagan las pruebas, lo hace en todas y cada una de las pruebas antes de que se ejecuten.

describe('conjuto', () => {
  beforeEach(() => {
    // Se ejecuta antes de que se haga una prueba en cada prueba
  });
	...
});

El afterEach(), es lo mismo que el beforeEach(), solo que en vez de hacerlo antes de cada una de las pruebas, lo hace después de cada una de las pruebas.

describe('conjuto', () => {
  afterEach(() => {
    // Se ejecuta después de que se haga una prueba en cada prueba
  });
	...
});

Chin pum!

beforeEach() es muy útiles para cargar una precondición necesaria antes de ejecutar cada una de las pruebas del set.

beforeAll() es muy útiles para cargar una precondición necesaria antes de ejecutar un set de pruebas.

Con afterEach() podemos generar postcondiciones que ayuden a la prueba a quedar como si nunca se ejecutó y/o hacer que la siguiente prueba del set no se vea perjudicada por esta. Ejemplo hacer un logout al final de la prueba si la siguiente requiere hacer login.

afterAll() sirve para ejecutar una postcondicion despues de ejecutar todas las pruebas de

describe se usa para tener un conjunto de pruebas.

• beforeAll(): se ejecuta antes de todas las pruebas.
• beforeEach(): se ejecuta antes de cada prueba.
• afterEach(): se ejecuta después de cada prueba.
• afterAll(): se ejecuta después de todas las pruebas

ACLARACIÓN: 👀 Los términos Setup y Teardown se refieren al proceso de configuración inicial y limpieza final que se realiza en un entorno de prueba para garantizar que las pruebas se ejecuten de manera adecuada y consistente.

• Setup (Configuración): Se refiere a la preparación del entorno de prueba antes de que se ejecuten las pruebas. Esto puede incluir la creación de objetos necesarios, la inicialización de variables, la configuración de conexiones a bases de datos u otros recursos, entre otras cosas. En Jest, esto se logra típicamente usando beforeAll()ybeforeEach() para configurar el estado inicial necesario antes de cada prueba.

  

• Teardown (Desmontaje o Limpieza): Se refiere a la limpieza del entorno de prueba después de que se hayan ejecutado las pruebas. Esto puede incluir la eliminación de objetos creados durante la configuración, la limpieza de variables, el cierre de conexiones a bases de datos u otros recursos, entre otras tareas. En Jest, esto se logra típicamente usando afterAll()yafterEach() para limpiar o cerrar recursos después de que se hayan ejecutado todas las pruebas o después de cada prueba, respectivamente.

  

El uso de Setup y Teardown ayuda a garantizar que las pruebas se ejecuten en un entorno controlado y consistente, lo que es fundamental para obtener resultados precisos y confiables en las pruebas automatizadas.