Globals · Jest

Jest coloca estos métodos y objetos en el entorno global de cada archivo de prueba. No es necesario importarlos vía require o import para hacer uso de ellos.

Métodos #

Referencia #

`afterAll(fn)` #

Ejecuta una función una vez que se hayan ejecutado todas las pruebas del archivo. Si la función regresa un promise, Jest esperará a que ésta resuelva antes de continuar.

Esto es frecuentemente útil para restablecer el estado global compartido entre pruebas.

Por ejemplo:

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterAll(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

La función afterAll garantiza que el método cleanUpDatabase sea llamado una vez terminada la ejecución de pruebas.

Si afterAll es llamado dentro de un bloque describe, este se ejecutará al final de la ejecución del bloque describe.

Si se desea ejecutar algún tipo de limpieza o restablecimiento después de cada prueba en lugar de al final de todas las pruebas, se puede utilizar afterEach.

`afterEach(fn)` #

Ejecuta una función después de que se ejecute cada prueba del archivo. Si la función regresa un promise, Jest esperará a que ésta resuelva antes de continuar.

Esto es frecuentemente útil para restablecer algún estado temporal que sea creado por cada prueba.

Por ejemplo:

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterEach(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

La función afterAll garantiza que el método cleanUpDatabase sea llamado una vez terminada cada prueba.

Si afterAll es llamado dentro de un bloque describe, este se ejecutará al final de la ejecución de cada prueba en el bloque describe.

Si se desea ejecutar algún tipo de limpieza o restablecimiento una sola vez por todas las pruebas, se puede utilizar afterAll.

`beforeAll(fn)` #

Ejecuta una función antes de que se ejecute alguna prueba del archivo. Si la función regresa un promise, Jest esperará a que ésta resuelva antes de continuar.

Esto es frecuentemente útil para establecer algún estado global a ser ocupado por varias pruebas.

Por ejemplo:

const globalDatabase = makeGlobalDatabase();

beforeAll(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

// Since we only set up the database once in this example, it's important
// that our tests don't modify it.
test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

Aquí el bloque beforeAll garantiza que la base de datos sea configurada antes de que se ejecuten las pruebas. Si la configuración inicial es asincrona, esto se puede realizar sin beforeAll. La clave es que Jest espera a una promise para resolver, de modo que también se puede tener configuración inicial setup asincrona.

Si el bloque beforeAll se encuentra dentro de un bloque describe, esté se ejecutará al principio del bloque describe.

Si se desea ejecutar código antes de cada prueba en lugar de antes de todas las pruebas, se puede usar beforeEach.

`beforeEach(fn)` #

Ejecuta una función antes de cada prueba del archivo. Si la función regresa un promise, Jest esperará a que ésta resuelva antes de continuar.

Esto es frecuentemente útil para restablecer algún estado global a ser ocupado por varias pruebas.

Por ejemplo:

const globalDatabase = makeGlobalDatabase();

beforeEach(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

Aquí el bloque beforeAll garantiza que la base de datos se restablezca antes de cada prueba.

Si el bloque beforeAll se encuentra dentro de un bloque describe, esté se ejecutará una vez antes de cada prueba en el bloque describe.

Si se desea ejecutar código de configuración inicial, una sola vez antes de cualquier prueba, usesé beforeAll.

`describe(name, fn)` #

describe(name, fn) crea un bloque que agrupa diferentes pruebas relacionadas entre ellas en un "suite de pruebas". Por ejemplo, si se tiene una objeto myBeverage que representa una bebida que debe ser deliciosa pero no agria, se podría probar con:

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

Esto no es requerido, se podrían escribir directamente todas las pruebas test en el nivel superior. Pero es preferible organizarlas en grupos.

También se pueden anidar bloques describe si se tiene una jerarquía de pruebas:

const cadenaBinariaANumero = cadenaBinaria => {
  if (!/^[01]+$/.test(cadenaBinaria)) {
    throw new CustomError('No es un número binario.');
  }

  return parseInt(cadenaBinaria, 2);
};

describe('cadenaBinariaANumero', () => {
  describe('dada una cadena binaria invalida', () => {
    test('compuesta de no-números arroja un CustomError', () => {
      expect(() => cadenaBinariaANumero('abc')).toThrowError(CustomError);
    });

    test('con espacios en blanco extra arroja un CustomError', () => {
      expect(() => cadenaBinariaANumero('  100')).toThrowError(CustomError);
    });
  });

  describe('dada una cadena binaria valida', () => {
    test('regresa el número correcto', () => {
      expect(cadenaBinariaANumero('100')).toBe(4);
    });
  });
});

`describe.only(name, fn)` #

Se puede encontrar también debajo del alias: fdescribe(name, fn)

Se puede utilizar describe.only si se desea ejecutar solo ún bloque describe:

describe.only('mi bebida', () => {
  test('es deliciosa', () => {
    expect(miBebida.deliciosa).toBeTruthy();
  });

  test('no es amarga', () => {
    expect(miBebida.amarga).toBeFalsy();
  });
});

describe('mi otra bebida', () => {
  // ... will be skipped
});

`describe.skip(name, fn)` #

Se puede encontrar también debajo del alias: xdescribe(name, fn)

Se puede utilizar describe.skip si se desea omitirun bloque describe en particular:

describe('mi bebida', () => {
  test('es deliciosa', () => {
    expect(miBebida.deliciosa).toBeTruthy();
  });

  test('no es amarga', () => {
    expect(miBebida.amarga).toBeFalsy();
  });
});

describe.skip('mi otra bebida', () => {
  // ... will be skipped
});

Usar describe.skip es frecuentemente usado como una alternativa a comentar bloques de código de manera temporal.

`require.requireActual(moduleName)` #

Regresa el modulo actual en lugar de una simulación mock, omitiendo cualquier otra indicación de si simular el modulo o no.

`require.requireMock(nombreModulo)` #

Regresa una modulo simulado mock en lugar del modulo real, omitiendo cualquier otra indicación de si el modulo debe ser requerido o no.

`test(name, fn)` #

Se puede encontrar también debajo del alias it(name, fn)

Todo lo que se requiere en un archivo de prueba es el metodo test para ejecutar una prueba. Por ejemplo, se asume una función que mide las pulgadas de lluvia inchesOfRain() debe regresar cero. La prueba completa sería:

test('did not rain', () => {
  expect(inchesOfRain()).toBe(0);
});

El primer argumento es el nombre de la prueba, el segundo argumento es una función con el codigo de expectativas a ser probadas.

Si el método test regresa un promise, Jest esperará a que esta resuelva para completar la prueba.

Por ejemplo, se asume una función que regresa una lista de bebidas fetchBeverageList(). Si esta función regresa una promise que se resuelve a una lista que contiene lemon. Se podría probar con lo siguiente:

test('has lemon in it', () => {
  return fetchBeverageList().then(list => {
    expect(list).toContain('lemon');
  });
});

Aunque la llamada al test terminará inmediatamente, la prueba no será completada hasta que resuelva el promise.

`test.only(name, fn)` #

También bajo el alias: it.only(name, fn) o fit(name, fn)

Cuando se trabaja sobre una gran cantidad de código, a menudo se desea correr solo un subconjunto de pruebas. .only puede usarse para especificar que pruebas se desean ejecutar.

Por ejemplo, digamos que se tuviera estas pruebas:

test.only('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Sólo se ejecutaría la prueba "it is raning", pues se agregó el test.only.

Usualmente no se tiende a hacer commits de pruebas con test.only en sistemas de control de código. Se tiende a usar para depuración y removerse una vez que se arreglaron las pruebas que fallaban.

`test.skip(name, fn)` #

También bajo el alias: it.skip(name, fn) o xit(name, fn) o xtest(name, fn)

Cuando se trabaja en una gran base de código, es frecuente encontrar alguna prueba que falla de manera temporal. Si se desea omitir la ejecución de dicha prueba, pero no se desea eliminar el código, se puede usar test.skip para indicar que se deben saltar esas pruebas.

Por ejemplo, digamos que se tuviera estas pruebas:

test('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test.skip('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Sólo se ejecutaría la prueba "it is raning", pues se agregó test.skip a la otra prueba.

En su lugar se puede simplemente comentar la prueba, pero usar test.skip permite mantener la indentación y el resaltado de sintaxis.

Métodos #

Referencia #

afterAll(fn) #

afterEach(fn) #

beforeAll(fn) #

beforeEach(fn) #

describe(name, fn) #

describe.only(name, fn) #

describe.skip(name, fn) #

require.requireActual(moduleName) #

require.requireMock(nombreModulo) #

test(name, fn) #

test.only(name, fn) #

test.skip(name, fn) #

`afterAll(fn)` #

`afterEach(fn)` #

`beforeAll(fn)` #

`beforeEach(fn)` #

`describe(name, fn)` #

`describe.only(name, fn)` #

`describe.skip(name, fn)` #

`require.requireActual(moduleName)` #

`require.requireMock(nombreModulo)` #

`test(name, fn)` #

`test.only(name, fn)` #

`test.skip(name, fn)` #