Uso de Matchers

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 →

Jest utiliza "matchers" para verificar valores de diferentes maneras. Este documento presentará algunos matchers de uso común. Para la lista completa, consulta la documentación de la API expect.

Matchers comunes

La forma más simple de probar un valor es mediante igualdad exacta.

test('two plus two is four', () => {
  expect(2 + 2).toBe(4);
});

En este código, expect(2 + 2) devuelve un objeto "expectation". Normalmente no harás mucho con estos objetos excepto invocar matchers sobre ellos. En este código, .toBe(4) es el matcher. Cuando Jest se ejecuta, rastrea todos los matchers que fallan para mostrarte mensajes de error claros.

toBe usa Object.is para verificar igualdad exacta. Si necesitas comprobar el valor de un objeto, usa toEqual:

test('object assignment', () => {
  const data = {one: 1};
  data['two'] = 2;
  expect(data).toEqual({one: 1, two: 2});
});

toEqual verifica recursivamente cada campo de un objeto o array.

consejo

toEqual ignora claves de objetos con propiedades undefined, elementos de array undefined, espacios vacíos en arrays o diferencias de tipo de objeto. Para considerar estos casos usa toStrictEqual.

También puedes probar el opuesto de un matcher usando not:

test('adding positive numbers is not zero', () => {
  for (let a = 1; a < 10; a++) {
    for (let b = 1; b < 10; b++) {
      expect(a + b).not.toBe(0);
    }
  }
});

Valores truthy/falsy

En pruebas a veces necesitas distinguir entre undefined, null y false, pero otras veces no. Jest incluye ayudantes que te permiten ser explícito.

• toBeNull coincide solo con null

• toBeUndefined coincide solo con undefined

• toBeDefined es el opuesto de toBeUndefined

• toBeTruthy coincide con cualquier valor que una sentencia if considera verdadero

• toBeFalsy coincide con cualquier valor que una sentencia if considera falso

Por ejemplo:

test('null', () => {
  const n = null;
  expect(n).toBeNull();
  expect(n).toBeDefined();
  expect(n).not.toBeUndefined();
  expect(n).not.toBeTruthy();
  expect(n).toBeFalsy();
});

test('zero', () => {
  const z = 0;
  expect(z).not.toBeNull();
  expect(z).toBeDefined();
  expect(z).not.toBeUndefined();
  expect(z).not.toBeTruthy();
  expect(z).toBeFalsy();
});

Debes usar el matcher que corresponda con mayor precisión a lo que tu código debe hacer.

Números

La mayoría de las formas de comparar números tienen matchers equivalentes.

test('two plus two', () => {
  const value = 2 + 2;
  expect(value).toBeGreaterThan(3);
  expect(value).toBeGreaterThanOrEqual(3.5);
  expect(value).toBeLessThan(5);
  expect(value).toBeLessThanOrEqual(4.5);

  // toBe and toEqual are equivalent for numbers
  expect(value).toBe(4);
  expect(value).toEqual(4);
});

Para igualdad de punto flotante, usa toBeCloseTo en lugar de toEqual, ya que no querrás que una prueba dependa de un pequeño error de redondeo.

test('adding floating point numbers', () => {
  const value = 0.1 + 0.2;
  //expect(value).toBe(0.3);           This won't work because of rounding error
  expect(value).toBeCloseTo(0.3); // This works.
});

Cadenas de texto

Puedes verificar cadenas contra expresiones regulares con toMatch:

test('there is no I in team', () => {
  expect('team').not.toMatch(/I/);
});

test('but there is a "stop" in Christoph', () => {
  expect('Christoph').toMatch(/stop/);
});

Arrays e iterables

Puedes comprobar si un array o iterable contiene un elemento específico usando toContain:

const shoppingList = [
  'diapers',
  'kleenex',
  'trash bags',
  'paper towels',
  'milk',
];

test('the shopping list has milk on it', () => {
  expect(shoppingList).toContain('milk');
  expect(new Set(shoppingList)).toContain('milk');
});

Excepciones

Si necesitas probar si una función lanza un error al ser invocada, usa toThrow.

function compileAndroidCode() {
  throw new Error('you are using the wrong JDK!');
}

test('compiling android goes as expected', () => {
  expect(() => compileAndroidCode()).toThrow();
  expect(() => compileAndroidCode()).toThrow(Error);

  // You can also use a string that must be contained in the error message or a regexp
  expect(() => compileAndroidCode()).toThrow('you are using the wrong JDK');
  expect(() => compileAndroidCode()).toThrow(/JDK/);

  // Or you can match an exact error message using a regexp like below
  expect(() => compileAndroidCode()).toThrow(/^you are using the wrong JDK$/); // Test fails
  expect(() => compileAndroidCode()).toThrow(/^you are using the wrong JDK!$/); // Test pass
});

consejo

La función que lanza la excepción debe invocarse dentro de una función contenedora, de lo contrario la aserción toThrow fallará.

Y más

Esto es solo una muestra. Para la lista completa de matchers, revisa la documentación de referencia.

Una vez que conozcas los matchers disponibles, el siguiente paso es ver cómo Jest te permite probar código asíncrono.