Jest

Translate this Doc

The Jest Object

El objeto jest se encuentra de manera automática en el scope de cada archivo de prueba. Los métodos dentro del objeto jest ayudan a crear funciones simuladas mock y controlar el comportamiento general de Jest.

Métodos #

Referencia #

jest.clearAllTimers() #

Remueve cualquier temporizador pendiente en el sistema de temporizadores.

Esto significa que, cualquier temporizador que haya sido programado (pero no se ha ejecutado aún), será borrado y no tendrá la oportunidad de ejecutarse en un futuro.

jest.disableAutomock() #

Deshabilita la simulación mock automática en el cargador de módulos.

Una vez que se haya ejecutado este método, todas las llamadas a require() regresarán el módulo real (en lugar de una simulación mock).

Esto es especialmente útil en el caso donde las dependencias que se desean simular es mucho menor a las dependencias que no se desean simular. Por ejemplo, si se escribe un test para un módulo que ocupa una gran cantidad de dependencias que se podrían clasificar como "detalles de la implementación", es probable que no se deseen simular.

Ejemplos de dependencias que podrían considerarse "detalles de la implementación" pueden ser módulos nativos del lenguaje (como métodos de Array.prototype), módulos de utilidad muy comunes (como underscore/lo-dash, utilidades de arreglos, etc) y librerías completas como React.js.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

Nota: este método se llamaba anteriormente autoMockOff. Cuando se usa babel-jest, las llamadas a disableAutomock se llevan automáticamente al principio del bloque de código. Si se desea evitar este comportamiento, se debe usar autoMockOff.

jest.enableAutomock() #

Habilita la simulación mock automática en el cargador de módulos.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

Nota: este método se llamaba anteriormente autoMockOn. Cuando se usa babel-jest, las llamadas a enableAutomock se llevan automáticamente al principio del bloque de código. Si se desea evitar este comportamiento, se debe usar autoMockOn.

jest.fn(implementation) #

Regresa una nueva instancia, sin utilizar, de una función mock. Opcionalmente acepta como parámetro una implementación de mock.

  const mockFn = jest.fn();
  mockFn();
  expect(mockFn).toHaveBeenCalled();

  // With a mock implementation:
  const returnsTrue = jest.fn(() => true);
  console.log(returnsTrue()); // true;

jest.isMockFunction(fn) #

Determina si la función dada es una función simulada.

jest.genMockFromModule(moduleName) #

Dado el nombre de un modulo, usa el sistema automático de simulación mock para generar una versión mock del modulo deseado.

Esto es útil cuando se desea crear una simulación manual que extiende el comportamiento automático de la simulación mock.

jest.mock(moduleName, factory, options) #

Crea una simulación mock de un modulo auto-mocked cuando es requerido. Las opciones factory y options son opcionales. Por ejemplo:

// banana.js
module.exports = () => 'banana';

// __tests__/test.js
jest.mock('../banana');

const banana = require('../banana'); // banana will be explicitly mocked.

banana(); // will return 'undefined' because the function is auto-mocked.

El segundo argumento puede usarse para especificar que se ejecute una fábrica de módulos de manera explicita en lugar de la funcionalidad de simulación mock automática de Jest:

jest.mock('../moduleName', () => {
  return jest.fn(() => 42);
});

const moduleName = require('../moduleName'); // This runs the function specified as second argument to `jest.mock`.
moduleName(); // Will return '42';

El tercer argumento puede ser usado para crear simulaciones mock virtuales, es decir, mocks de módulos que no existen en ninguna parte del sistema:

jest.mock('../moduleName', () => {
  /*
   * Custom implementation of a module that doesn't exist in JS,
   * like a generated module or a native module in react-native.
   */
}, {virtual: true});

Advertencia: Importar un modulo en el archivo de configuración inicial (como se especifica en setupTestFrameworkScriptFile) previene que se simule dicho modulo, así como cualquier otro módulo que éste importe.

Los módulos que son simulados vía jest.mock son solo simulados para el archivo que ejecuta jest.mock. Cualquier otro archivo que importe el modulo hará uso de la implementación original incluso si éste se ejecuta después de una prueba que use un mock para el mismo módulo.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.unmock(moduleName) #

Le indica al sistema de módulos que nunca debe regresar una versión simulada mock de un modulo en especifico cuando se importe vía require() (es decir, que siempre debe regresar el modulo real).

El uso más común de esta API es para especificar el modulo que se va a probar (y que por tanto no se desea simular automáticamente).

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.doMock(moduleName, factory, options) #

When using babel-jest, calls to mock will automatically be hoisted to the top of the code block. Use this method if you want to explicitly avoid this behavior.

One example when this is useful is when you want to mock a module differently within the same file:

beforeEach(() => {
  jest.resetModules();
});

test('moduleName 1', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 1);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toEqual(1);
});

test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 2);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toEqual(2);
});

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.dontMock(moduleName) #

When using babel-jest, calls to unmock will automatically be hoisted to the top of the code block. Use this method if you want to explicitly avoid this behavior.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.clearAllMocks() #

Borra las propiedades mock.calls y mock.instances de todos los mocks. Es el equivalente a llamar a .mockClear() en cada función simulada.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.resetAllMocks() #

Restablece el estado de todos los mock. Es el equivalente a llamar a .mockReset() en cada función simulada.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.restoreAllMocks() #

available in Jest 20.1.0+ #

Restores all mocks back to their original value. Equivalent to calling .mockRestore on every mocked function. Beware that jest.restoreAllMocks() only works when mock was created with jest.spyOn; other mocks will require you to manually restore them.

jest.resetModules() #

Restablece el registro de módulos - el caché de todos los módulos importados. Esto es útil para aislar módulos donde estado local podría entrar en conflicto entre pruebas.

Ejemplo:

const sum1 = require('../sum');
jest.resetModules();
const sum2 = require('../sum');
sum1 === sum2;
// > false (Both sum modules are separate "instances" of the sum module.)

Ejemplo en una prueba:

beforeEach(() => {
  jest.resetModules();
});

test('works', () => {
  const sum = require('../sum');
});

test('works too', () => {
  const sum = require('../sum');
  // sum is a different copy of the sum module from the previous test.
});

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.runAllTicks() #

Agota la cola de tareas micro (cuya interfaz en node es process.nextTick).

Cuando se llama a este API, todas las micro-tareas que estén en la cola de process.nextTick serán ejecutadas. De manera adicional, si esas micro-tareas mismas crean nuevas micro-tareas, éstas se agotaran continuamente hasta que no haya más micro-tareas en la cola.

jest.runAllTimers() #

Agota la cola de tareas macro (es decir todas las tareas que hayan entrado a la cola de setTimeout(), setInterval(), y setImmediate()).

Cuando se llama a este API, todas las "macro-tareas" que estén en la cola de setTimeout() o setInterval() serán ejecutadas. De manera adicional, si esas macro-tareas mismas crean nuevas macro-tareas, éstas se agotaran continuamente hasta que no haya más micro-tareas en la cola.

Esto es útil para ejecutar setTimeouts de manera sincronía en una prueba para así verificar de manera sincronía acciones que ocurrirían después de que se ejecuten los callbacks de setTimeout() o setInterval(). Véase el documento de Simulaciones de temporizadores para más información.

jest.runAllImmediates() #

Agota todas las tareas en la cola de setImmediate().

jest.runTimersToTime(msToRun) #

Ejecuta solo las tareas macro (es decir todas aquellas programadas por setTimeout(), setInterval() y setImmediate()).

Cuando se manda a llamar este API, todas las "macro-tareas" pendientes que se hayan puesto en la cola a través de setTimeout() o setInterval(), se ejecutarán después de la cantidad de mili segundos especificada en msToRun. Además si esas macro tareas programan nuevas macro tareas que se ejecutarían dentro del mismo plazo, éstas también se ejecutarán hasta que no haya más macro-tareas restantes en la cola. Esto se ejecutara en los mili segundos especificados en msToRun.

jest.runOnlyPendingTimers() #

Ejecuta solo las macro-tareas que se encuentren pendientes (es decir, sólo las tareas que entraron a la cola vía setTimeout() o setInterval() hasta ese momento). Si cualquiera de esas macro-tareas crearon nuevas macro-tareas, éstas últimas no se ejecutarán en esta llamada.

Esto es útil para escenarios donde el modulo probado llama a setTimeout() y éste a su vez llama a setTimeout() de manera recursiva (de manera que las llamadas nunca terminan). En dichos escenarios, es útil poder avanzar en la linea de tiempo de ejecución un paso a la vez.

jest.setMock(moduleName, moduleExports) #

Provee de manera especifica el modulo simulado mock que el sistema de módulos debe regresar para un modulo en especifico.

Hay ocasiones donde el modulo mock que se genera automáticamente por el sistema de módulos no es adecuado para las pruebas que se desean realizar. Normalmente, en esas circunstancias se debe escribir un módulo mock manual que sea más adecuado para el módulo en cuestión. Y sin embargo, en raras ocasiones, inclusive un mock manual puede no ser apropiado para los propósitos de la prueba, en cuyo caso se tiene que construir el mock dentro de la prueba.

En estos raros casos, se puede ocupar esta API para llenar de manera manual el registro del módulo mock en el sistema de módulos.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

Es importante notar que es mejor práctica ocupar jest.mock(). El segundo argumento del API de jest.mock es una fábrica de modulos en lugar del objeto del modulo que se espera exportar.

jest.setTimeout(timeout) #

Set the default timeout interval for tests and before/after hooks in milliseconds.

Note: The default timeout interval is 5 seconds if this method is not called.

Ejemplo:

jest.setTimeout(1000); // 1 second

jest.useFakeTimers() #

Indica a Jest que se deben ocupar versiones falsas de las funciones estándares de temporizadores (setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate y clearImmediate).

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.useRealTimers() #

Indica a Jest que se deben ocupar las versiones reales de las funciones estándares de temporizadores.

Regresa el objeto jest para poder ser usado llamadas consecutivas.

jest.spyOn(object, methodName) #

disponible en Jest 19.0.0+ #

Crea una función simulada de manera similar a jest.fn pero que permite también llevar un registro de llamadas a object[methodName]. Regresa una función mock.

Nota: Por defecto, jest.spyOn también llama al método spied. Este comportamiento es diferente de casi todas las otras librerías para pruebas. Si se desea remplazar la función original, se puede usar jest.spyOn(object, methodName).mockImplementation(() => implementacionPropia) o object[methodName] = jest.fn(() => implementacionPropia);

Ejemplo:

const video = {
  play() {
    return true;
  },
};

module.exports = video;

Prueba de ejemplo:

const video = require('./video');

test('plays video', () => {
  const spy = jest.spyOn(video, 'play');
  const isPlaying = video.play();

  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);

  spy.mockReset();
  spy.mockRestore();
});
← AnteriorSiguiente →