Versión: 30.0

API Global

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 →

En tus archivos de prueba, Jest coloca cada uno de estos métodos y objetos en el entorno global. No necesitas requerir o importar nada para usarlos. Sin embargo, si prefieres importaciones explícitas, puedes usar import {describe, expect, test} from '@jest/globals'.

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 →

información

Los ejemplos de TypeScript en esta página solo funcionarán como se documenta si importas explícitamente las APIs de Jest:

import {expect, jest, test} from '@jest/globals';

Consulta la guía de Primeros pasos para obtener detalles sobre cómo configurar Jest con TypeScript.

Referencia

`afterAll(fn, timeout)`

Ejecuta una función después de que todas las pruebas en este archivo hayan finalizado. Si la función devuelve una promesa o es un generador, Jest espera a que esa promesa se resuelva antes de continuar.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Suele ser útil cuando necesitas limpiar algún 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();
  });
});

Aquí afterAll garantiza que cleanUpDatabase se llame después de ejecutar todas las pruebas.

Si afterAll está dentro de un bloque describe, se ejecuta al final de ese bloque.

Si prefieres ejecutar limpieza después de cada prueba individual en lugar de después de todas, usa afterEach.

`afterEach(fn, timeout)`

Ejecuta una función después de que cada prueba en este archivo finalice. Si la función devuelve una promesa o es un generador, Jest espera a que esa promesa se resuelva antes de continuar.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Es útil cuando necesitas limpiar estados temporales creados 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();
  });
});

Aquí afterEach garantiza que cleanUpDatabase se llame después de cada prueba.

Si afterEach está dentro de un bloque describe, solo se ejecuta después de las pruebas dentro de ese bloque.

Si prefieres ejecutar limpieza una sola vez después de todas las pruebas, usa afterAll.

`beforeAll(fn, timeout)`

Ejecuta una función antes de cualquier prueba en este archivo. Si la función devuelve una promesa o es un generador, Jest espera a que se resuelva antes de ejecutar las pruebas.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Es útil para configurar estados globales que usarán múltiples 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í beforeAll garantiza que la base de datos esté configurada antes de las pruebas. Si la configuración fuera síncrona, podrías hacerlo sin beforeAll. Lo clave es que Jest esperará a que se resuelva una promesa, permitiendo también configuración asíncrona.

Si beforeAll está dentro de un bloque describe, se ejecuta al inicio de ese bloque.

Si prefieres ejecutar algo antes de cada prueba individual en lugar de antes de todas, usa beforeEach.

`beforeEach(fn, timeout)`

Ejecuta una función antes de cada prueba en este archivo. Si la función devuelve una promesa o es un generador, Jest espera a que se resuelva antes de ejecutar la prueba.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Es útil para resetear estados globales que usarán múltiples 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í beforeEach garantiza que la base de datos se reinicie para cada prueba.

Si beforeEach está dentro de un bloque describe, se ejecutará para cada prueba dentro de ese bloque de descripción.

Si solo necesitas ejecutar código de configuración una vez, antes de que se ejecuten las pruebas, usa beforeAll en su lugar.

`describe(name, fn)`

describe(name, fn) crea un bloque que agrupa varias pruebas relacionadas. Por ejemplo, si tienes un objeto myBeverage que debe ser delicioso pero no ácido, podrías probarlo 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 obligatorio: puedes escribir bloques test directamente en el nivel superior. Pero resulta útil si prefieres organizar tus pruebas en grupos.

También puedes anidar bloques describe si tienes una jerarquía de pruebas:

const binaryStringToNumber = binString => {
  if (!/^[01]+$/.test(binString)) {
    throw new CustomError('Not a binary number.');
  }

  return parseInt(binString, 2);
};

describe('binaryStringToNumber', () => {
  describe('given an invalid binary string', () => {
    test('composed of non-numbers throws CustomError', () => {
      expect(() => binaryStringToNumber('abc')).toThrow(CustomError);
    });

    test('with extra whitespace throws CustomError', () => {
      expect(() => binaryStringToNumber('  100')).toThrow(CustomError);
    });
  });

  describe('given a valid binary string', () => {
    test('returns the correct number', () => {
      expect(binaryStringToNumber('100')).toBe(4);
    });
  });
});

`describe.each(table)(name, fn, timeout)`

Usa describe.each si sigues duplicando los mismos conjuntos de pruebas con diferentes datos. describe.each te permite escribir el conjunto de pruebas una vez y pasar los datos.

describe.each está disponible con dos APIs:

1. `describe.each(table)(name, fn, timeout)`

table: Array de Arrays con los argumentos que se pasan a la función fn para cada fila. Si pasas un array unidimensional de primitivas, internamente se mapeará a una tabla, es decir, [1, 2, 3] -> [[1], [2], [3]].
name: String título del conjunto de pruebas.
- Genera títulos únicos inyectando parámetros con formato printf:
  - %p - pretty-format.
  - %s- String.
  - %d- Number.
  - %i - Integer.
  - %f - Floating point value.
  - %j - JSON.
  - %o - Object.
  - %# - Índice del caso de prueba.
  - %$ - Número del caso de prueba.
  - %% - signo de porcentaje simple ('%').
- O genera títulos únicos inyectando propiedades con $variable
  - Para inyectar valores anidados: puedes usar una ruta de claves, es decir, $variable.path.to.value (solo propiedades propias, ej. $variable.constructor.name no funcionaría).
  - Usa $# para inyectar el índice del caso.
  - No combines $variable con formato printf (excepto %%).
fn: Function conjunto de pruebas a ejecutar, recibe parámetros de cada fila como argumentos.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

describe.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

2. describe.each`table`(name, fn, timeout)

table: Tagged Template Literal
- Primera fila de encabezados de nombres de variables separados con |
- Una o más filas posteriores de datos suministradas como expresiones de literal de plantilla usando la sintaxis ${value}.
name: String el título del conjunto de pruebas, usa $variable para inyectar datos de prueba en el título del conjunto desde las expresiones de plantilla etiquetadas, y $# para el índice de la fila.
- Para inyectar valores de objetos anidados, puedes proporcionar una ruta de claves, es decir, $variable.path.to.value (solo funciona para propiedades propias, por ejemplo, $variable.constructor.name no funcionaría)
fn: Function conjunto de pruebas a ejecutar, recibe el objeto de datos de prueba.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

describe.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('$a + $b', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

`describe.only(name, fn)`

También disponible con el alias: fdescribe(name, fn)

Puedes usar describe.only si quieres ejecutar solo un bloque describe:

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

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

describe('my other beverage', () => {
  // ... will be skipped
});

`describe.only.each(table)(name, fn)`

También disponible con los alias: fdescribe.each(table)(name, fn) y fdescribe.each`table`(name, fn)

Usa describe.only.each si quieres ejecutar solo suites de pruebas específicas en pruebas basadas en datos.

describe.only.each está disponible con dos APIs:

`describe.only.each(table)(name, fn)`

describe.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.only.each`table`(name, fn)

describe.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('passes', () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`describe.skip(name, fn)`

También disponible con el alias: xdescribe(name, fn)

Puedes usar describe.skip si no quieres ejecutar las pruebas de un bloque describe específico:

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

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

describe.skip('my other beverage', () => {
  // ... will be skipped
});

Usar describe.skip suele ser una alternativa más limpia que comentar temporalmente un grupo de pruebas. Ten en cuenta que el bloque describe aún se ejecutará. Si tienes alguna configuración que también deba omitirse, hazlo en un bloque beforeAll o beforeEach.

`describe.skip.each(table)(name, fn)`

También disponible con los alias: xdescribe.each(table)(name, fn) y xdescribe.each`table`(name, fn)

Usa describe.skip.each si quieres dejar de ejecutar una suite de pruebas basadas en datos.

describe.skip.each está disponible con dos APIs:

`describe.skip.each(table)(name, fn)`

describe.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip.each`table`(name, fn)

describe.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('will not be run', () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`test(name, fn, timeout)`

También disponible con el alias: it(name, fn, timeout)

Todo lo que necesitas en un archivo de pruebas es el método test que ejecuta una prueba. Por ejemplo, supongamos que hay una función inchesOfRain() que debería ser cero. Toda tu prueba podría ser:

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

El primer argumento es el nombre de la prueba; el segundo argumento es una función que contiene las expectativas a verificar. El tercer argumento (opcional) es timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Si se devuelve una promesa desde test, Jest esperará a que la promesa se resuelva antes de completar la prueba. Por ejemplo, supongamos que fetchBeverageList() devuelve una promesa que debería resolverse con una lista que contiene lemon. Puedes probar esto con:

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

Aunque la llamada a test regresará inmediatamente, la prueba no se completa hasta que se resuelva la promesa. Para más detalles, consulta la página Testing Asynchronous Code.

consejo

Jest también esperará si proporcionas un argumento a la función de prueba, normalmente llamado done. Esto puede ser útil cuando quieres probar callbacks.

`test.concurrent(name, fn, timeout)`

También disponible con el alias: it.concurrent(name, fn, timeout)

precaución

test.concurrent se considera experimental - consulta aquí para ver detalles sobre funciones faltantes y otros problemas.

Usa test.concurrent si quieres que la prueba se ejecute concurrentemente.

El primer argumento es el nombre de la prueba; el segundo argumento es una función asíncrona que contiene las expectativas a evaluar. El tercer argumento (opcional) es timeout (en milisegundos) para especificar cuánto esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

test.concurrent('addition of 2 numbers', async () => {
  expect(5 + 3).toBe(8);
});

test.concurrent('subtraction 2 numbers', async () => {
  expect(5 - 3).toBe(2);
});

consejo

Usa la opción de configuración maxConcurrency para evitar que Jest ejecute más pruebas de las especificadas simultáneamente.

`test.concurrent.each(table)(name, fn, timeout)`

También disponible como alias: it.concurrent.each(table)(name, fn, timeout)

Usa test.concurrent.each si repites la misma prueba con diferentes datos. test.each te permite escribir la prueba una vez e ingresar los datos; todas las pruebas se ejecutan asincrónicamente.

test.concurrent.each está disponible con dos APIs:

1. `test.concurrent.each(table)(name, fn, timeout)`

table: Array de Arrays con los argumentos que se pasarán a la función fn para cada fila. Si pasas un array unidimensional de valores primitivos, internamente se mapeará a una tabla, ej. [1, 2, 3] -> [[1], [2], [3]]
name: String título del bloque de prueba.
- Genera títulos únicos inyectando parámetros posicionalmente con formato printf:
  - %p - pretty-format.
  - %s- String.
  - %d- Número.
  - %i - Entero.
  - %f - Valor de punto flotante.
  - %j - JSON.
  - %o - Objeto.
  - %# - Índice del caso de prueba.
  - %$ - Número del caso de prueba.
  - %% - signo de porcentaje único ('%'). No consume un argumento.
fn: Function prueba a ejecutar, función que recibirá los parámetros de cada fila como argumentos. Debe ser una función asíncrona.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

test.concurrent.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

2. test.concurrent.each`table`(name, fn, timeout)

table: Tagged Template Literal
- Primera fila de encabezados de nombres de variables separados con |
- Una o más filas posteriores de datos suministradas como expresiones de literal de plantilla usando la sintaxis ${value}.
name: String que es el título de la prueba, usa $variable para inyectar datos de prueba en el título desde las expresiones del template
- Para inyectar valores de objetos anidados usa una ruta de claves ej. $variable.path.to.value (solo funciona para propiedades "own", ej. $variable.constructor.name no funcionaría)
fn: Function prueba a ejecutar, función que recibirá el objeto de datos de prueba. Debe ser una función asíncrona.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

test.concurrent.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

`test.concurrent.only.each(table)(name, fn)`

También disponible como alias: it.concurrent.only.each(table)(name, fn)

Usa test.concurrent.only.each si quieres ejecutar solo pruebas específicas con diferentes datos concurrentemente.

test.concurrent.only.each está disponible con dos APIs:

`test.concurrent.only.each(table)(name, fn)`

test.concurrent.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)

test.concurrent.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`test.concurrent.skip.each(table)(name, fn)`

También conocido como: it.concurrent.skip.each(table)(name, fn)

Usa test.concurrent.skip.each si quieres detener la ejecución de una colección de pruebas asíncronas basadas en datos.

test.concurrent.skip.each está disponible con dos API:

`test.concurrent.skip.each(table)(name, fn)`

test.concurrent.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each`table`(name, fn)

test.concurrent.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`test.each(table)(name, fn, timeout)`

También conocido como: it.each(table)(name, fn) y it.each`table`(name, fn)

Usa test.each cuando repites la misma prueba con diferentes datos. test.each te permite escribir la prueba una vez y pasar los datos.

test.each está disponible con dos API:

1. `test.each(table)(name, fn, timeout)`

table: Array de Arrays con los argumentos que se pasarán a la función fn para cada fila. Si pasas un array unidimensional de valores primitivos, internamente se mapeará a una tabla, ej. [1, 2, 3] -> [[1], [2], [3]]
name: String el título del bloque de pruebas.
- Genera títulos únicos inyectando parámetros posicionalmente con formato printf:
  - %p - pretty-format.
  - %s - String.
  - %d - Número.
  - %i - Entero.
  - %f - Valor de punto flotante.
  - %j - JSON.
  - %o - Objeto.
  - %# - Índice del caso de prueba.
  - %$ - Número del caso de prueba.
  - %% - signo de porcentaje único ('%'). No consume argumentos.
- O genera títulos únicos inyectando propiedades del objeto caso de prueba con $variable
  - Para inyectar valores de objetos anidados usa keyPath: $variable.path.to.value (solo funciona para propiedades "propias", ej. $variable.constructor.name no funcionaría)
  - Puedes usar $# para inyectar el índice del caso de prueba
  - No puedes combinar $variable con formato printf excepto para %%
fn: Function que es la prueba a ejecutar, recibirá los parámetros de cada fila como argumentos

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

2. test.each`table`(name, fn, timeout)

table: Tagged Template Literal
- Primera fila de encabezados de nombres de variables separados con |
- Una o más filas posteriores de datos suministradas como expresiones de literal de plantilla usando la sintaxis ${value}.
name: String que es el título de la prueba, usa $variable para inyectar datos de prueba en el título desde las expresiones del template
- Para inyectar valores de objetos anidados usa una ruta de claves ej. $variable.path.to.value (solo funciona para propiedades "own", ej. $variable.constructor.name no funcionaría)
fn: Function que es la prueba a ejecutar, recibirá el objeto de datos de prueba

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar por cada fila antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Ejemplo:

test.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

`test.failing(name, fn, timeout)`

También disponible bajo el alias: it.failing(name, fn, timeout)

nota

Esto solo está disponible con el runner predeterminado jest-circus.

Usa test.failing cuando estés escribiendo una prueba y esperes que falle. Estas pruebas se comportarán de manera opuesta a las pruebas normales: si una prueba failing lanza algún error, pasará; si no lanza errores, fallará.

consejo

Puedes usar este tipo de prueba cuando escribes código con enfoque BDD. En ese caso, las pruebas no aparecerán como fallidas hasta que pasen. Luego puedes simplemente eliminar el modificador failing para hacerlas pasar.

También es una forma útil de contribuir con pruebas fallidas a un proyecto, incluso si no sabes cómo solucionar el error.

Ejemplo:

test.failing('it is not equal', () => {
  expect(5).toBe(6); // this test will pass
});

test.failing('it is equal', () => {
  expect(10).toBe(10); // this test will fail
});

`test.failing.each(name, fn, timeout)`

También disponible bajo los alias: it.failing.each(table)(name, fn) y it.failing.each`table`(name, fn)

nota

Esto solo está disponible con el runner predeterminado jest-circus.

También puedes ejecutar múltiples pruebas a la vez añadiendo each después de failing.

Ejemplo:

test.failing.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

`test.only.failing(name, fn, timeout)`

También disponible bajo los alias: it.only.failing(name, fn, timeout), fit.failing(name, fn, timeout)

nota

Esto solo está disponible con el runner predeterminado jest-circus.

Usa test.only.failing si quieres ejecutar únicamente una prueba fallida específica.

`test.skip.failing(name, fn, timeout)`

También disponible bajo los alias: it.skip.failing(name, fn, timeout), xit.failing(name, fn, timeout), xtest.failing(name, fn, timeout)

nota

Esto solo está disponible con el runner predeterminado jest-circus.

Usa test.skip.failing si quieres omitir la ejecución de una prueba fallida específica.

`test.only(name, fn, timeout)`

También disponible bajo los alias: it.only(name, fn, timeout), y fit(name, fn, timeout)

Cuando depuras un archivo de pruebas grande, frecuentemente querrás ejecutar solo un subconjunto de pruebas. Puedes usar .only para especificar qué pruebas deben ejecutarse en ese archivo.

Opcionalmente, puedes proporcionar un timeout (en milisegundos) para especificar cuánto tiempo esperar antes de abortar. El tiempo de espera predeterminado es de 5 segundos.

Por ejemplo, supongamos que tienes estas pruebas:

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

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

Solo la prueba "it is raining" se ejecutará en este archivo, ya que usa test.only.

Normalmente no deberías subir código con test.only al control de versiones; úsalo para depurar y elimínalo una vez hayas corregido las pruebas rotas.

`test.only.each(table)(name, fn)`

También disponible como alias: it.only.each(table)(name, fn), fit.each(table)(name, fn), it.only.each`table`(name, fn) y fit.each`table`(name, fn)

Usa test.only.each si quieres ejecutar únicamente pruebas específicas con diferentes datos de prueba.

test.only.each está disponible con dos APIs:

`test.only.each(table)(name, fn)`

test.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)

test.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`test.skip(name, fn)`

También disponible como alias: it.skip(name, fn), xit(name, fn) y xtest(name, fn)

Cuando mantienes una base de código grande, a veces encuentras pruebas que están temporalmente rotas. Si quieres omitir su ejecución sin eliminar el código, usa test.skip para especificar qué pruebas saltar.

Por ejemplo, supongamos que tienes estas pruebas:

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

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

Solo se ejecutará la prueba "está lloviendo", ya que la otra usa test.skip.

Podrías comentar la prueba, pero suele ser mejor usar test.skip porque mantiene la indentación y resaltado de sintaxis.

`test.skip.each(table)(name, fn)`

También disponible como alias: it.skip.each(table)(name, fn), xit.each(table)(name, fn), xtest.each(table)(name, fn), it.skip.each`table`(name, fn), xit.each`table`(name, fn) y xtest.each`table`(name, fn)

Usa test.skip.each si quieres dejar de ejecutar un conjunto de pruebas basadas en datos.

test.skip.each está disponible con dos APIs:

`test.skip.each(table)(name, fn)`

test.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip.each`table`(name, fn)

test.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

`test.todo(name)`

También disponible como alias: it.todo(name)

Usa test.todo cuando planees escribir pruebas pendientes. Estas se resaltarán en el resumen final para que sepas cuántas pruebas faltan por implementar.

const add = (a, b) => a + b;

test.todo('add should be associative');

consejo

test.todo generará un error si le pasas una función de prueba. Usa test.skip si ya implementaste la prueba pero no quieres ejecutarla.

Uso con TypeScript

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 →

información

Los ejemplos de TypeScript en esta página solo funcionarán como se documenta si importas explícitamente las APIs de Jest:

import {expect, jest, test} from '@jest/globals';

Consulta la guía de Primeros pasos para obtener detalles sobre cómo configurar Jest con TypeScript.

`.each`

El modificador .each ofrece varias formas de definir tablas de casos de prueba. Algunas APIs tienen particularidades en la inferencia de tipos para los argumentos pasados a describe o test. Veamos cada caso.

nota

Para simplicidad usamos test.each en los ejemplos, pero la inferencia de tipos es idéntica en todos los casos donde se puede usar .each: describe.each, test.concurrent.only.each, test.skip.each, etc.

Arreglo de objetos

La API de arreglo de objetos es más detallada pero simplifica la inferencia de tipos. La table puede incluirse directamente:

import {test} from '@jest/globals';

test.each([
  {name: 'a', path: 'path/to/a', count: 1, write: true},
  {name: 'b', path: 'path/to/b', count: 3},
])('inline table', ({name, path, count, write}) => {
  // arguments are typed as expected, e.g. `write: boolean | undefined`
});

O declararse separadamente como variable:

import {test} from '@jest/globals';

const table = [
  {a: 1, b: 2, expected: 'three', extra: true},
  {a: 3, b: 4, expected: 'seven', extra: false},
  {a: 5, b: 6, expected: 'eleven'},
];

test.each(table)('table as a variable', ({a, b, expected, extra}) => {
  // again everything is typed as expected, e.g. `extra: boolean | undefined`
});

Arreglo de arreglos

El estilo de arreglo de arreglos funciona bien con tablas incluidas directamente:

import {test} from '@jest/globals';

test.each([
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
])('inline table example', (a, b, expected, extra) => {
  // arguments are typed as expected, e.g. `extra: boolean | undefined`
});

Sin embargo, si la tabla se declara como variable separada, debe tiparse como arreglo de tuplas para una correcta inferencia (solo es necesario si los elementos de la fila tienen tipos diferentes):

import {test} from '@jest/globals';

const table: Array<[number, number, string, boolean?]> = [
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
];

test.each(table)('table as a variable example', (a, b, expected, extra) => {
  // without the annotation types are incorrect, e.g. `a: number | string | boolean`
});

Literal de plantilla

Si todos los valores de entrada son del mismo tipo, la API de plantillas literales tipará los argumentos correctamente:

import {test} from '@jest/globals';

test.each`
  a    | b    | expected
  ${1} | ${2} | ${3}
  ${3} | ${4} | ${7}
  ${5} | ${6} | ${11}
`('template literal example same type', ({a, b, expected}) => {
  // all arguments are of type `number` because all inputs (a, b, expected) are of type `number`
});

Si las entradas tienen tipos diferentes, los argumentos se tiparán como una unión de todos los tipos de entrada (es decir, el tipo de las variables dentro de la plantilla literal):

import {test} from '@jest/globals';

test.each`
  a    | b    | expected
  ${1} | ${2} | ${'three'}
  ${3} | ${4} | ${'seven'}
  ${5} | ${6} | ${'eleven'}
`('template literal example different types', ({a, b, expected}) => {
  // all arguments are of type `number | string` because some inputs (a, b) are of type `number` and some others (expected) are of type `string`
});

De lo contrario, si quieres que cada argumento tenga el tipo correcto, debes proporcionar explícitamente el argumento de tipo genérico:

import {test} from '@jest/globals';

test.each<{a: number; b: number; expected: string; extra?: boolean}>`
  a    | b    | expected    | extra
  ${1} | ${2} | ${'three'}  | ${true}
  ${3} | ${4} | ${'seven'}  | ${false}
  ${5} | ${6} | ${'eleven'}
`('template literal example', ({a, b, expected, extra}) => {
  // all arguments are typed as expected, e.g. `a: number`, `expected: string`, `extra: boolean | undefined`
});

precaución

Ten en cuenta que las variables dentro de la plantilla literal no se verifican de tipos, por lo que debes asegurarte de que sus tipos sean correctos.

import {test} from '@jest/globals';

test.each<{a: number; expected: string}>`
  a                            | expected
  ${1}                         | ${'one'}
  ${'will not raise TS error'} | ${'two'}
  ${3}                         | ${'three'}
`('template literal with wrongly typed input', ({a, expected}) => {
  // all arguments are typed as stated in the generic: `a: number`, `expected: string`
  // WARNING: `a` is of type `number` but will be a string in the 2nd test case.
});

Métodos​

Referencia​

afterAll(fn, timeout)​

afterEach(fn, timeout)​

beforeAll(fn, timeout)​

beforeEach(fn, timeout)​

describe(name, fn)​

describe.each(table)(name, fn, timeout)​

1. describe.each(table)(name, fn, timeout)​

2. describe.each`table`(name, fn, timeout)​

describe.only(name, fn)​

describe.only.each(table)(name, fn)​

describe.only.each(table)(name, fn)​

describe.only.each`table`(name, fn)​

describe.skip(name, fn)​

describe.skip.each(table)(name, fn)​

describe.skip.each(table)(name, fn)​

describe.skip.each`table`(name, fn)​

test(name, fn, timeout)​

test.concurrent(name, fn, timeout)​

test.concurrent.each(table)(name, fn, timeout)​

1. test.concurrent.each(table)(name, fn, timeout)​

2. test.concurrent.each`table`(name, fn, timeout)​

test.concurrent.only.each(table)(name, fn)​

test.concurrent.only.each(table)(name, fn)​

test.only.each`table`(name, fn)​

test.concurrent.skip.each(table)(name, fn)​

test.concurrent.skip.each(table)(name, fn)​

test.concurrent.skip.each`table`(name, fn)​

test.each(table)(name, fn, timeout)​

1. test.each(table)(name, fn, timeout)​

2. test.each`table`(name, fn, timeout)​

test.failing(name, fn, timeout)​

test.failing.each(name, fn, timeout)​

test.only.failing(name, fn, timeout)​

test.skip.failing(name, fn, timeout)​

test.only(name, fn, timeout)​

test.only.each(table)(name, fn)​

test.only.each(table)(name, fn)​

test.only.each`table`(name, fn)​

test.skip(name, fn)​

test.skip.each(table)(name, fn)​

test.skip.each(table)(name, fn)​

test.skip.each`table`(name, fn)​

test.todo(name)​

Uso con TypeScript​

.each​

Arreglo de objetos​

Arreglo de arreglos​

Literal de plantilla​

Métodos

Referencia

`afterAll(fn, timeout)`

`afterEach(fn, timeout)`

`beforeAll(fn, timeout)`

`beforeEach(fn, timeout)`

`describe(name, fn)`

`describe.each(table)(name, fn, timeout)`

1. `describe.each(table)(name, fn, timeout)`

2. describe.each`table`(name, fn, timeout)

`describe.only(name, fn)`

`describe.only.each(table)(name, fn)`

`describe.only.each(table)(name, fn)`

describe.only.each`table`(name, fn)

`describe.skip(name, fn)`

`describe.skip.each(table)(name, fn)`

`describe.skip.each(table)(name, fn)`

describe.skip.each`table`(name, fn)

`test(name, fn, timeout)`

`test.concurrent(name, fn, timeout)`

`test.concurrent.each(table)(name, fn, timeout)`

1. `test.concurrent.each(table)(name, fn, timeout)`

2. test.concurrent.each`table`(name, fn, timeout)

`test.concurrent.only.each(table)(name, fn)`

`test.concurrent.only.each(table)(name, fn)`

test.only.each`table`(name, fn)

`test.concurrent.skip.each(table)(name, fn)`

`test.concurrent.skip.each(table)(name, fn)`

test.concurrent.skip.each`table`(name, fn)

`test.each(table)(name, fn, timeout)`

1. `test.each(table)(name, fn, timeout)`

2. test.each`table`(name, fn, timeout)

`test.failing(name, fn, timeout)`

`test.failing.each(name, fn, timeout)`

`test.only.failing(name, fn, timeout)`

`test.skip.failing(name, fn, timeout)`

`test.only(name, fn, timeout)`

`test.only.each(table)(name, fn)`

`test.only.each(table)(name, fn)`

test.only.each`table`(name, fn)

`test.skip(name, fn)`

`test.skip.each(table)(name, fn)`

`test.skip.each(table)(name, fn)`

test.skip.each`table`(name, fn)

`test.todo(name)`

Uso con TypeScript

`.each`

Arreglo de objetos

Arreglo de arreglos

Literal de plantilla