Using Matchers

Jest usa "matchers" para permitir probar valores en caminos diferentes. Hay muchos y diversos matchers para memorizarlos todos, así este documento solo introducirá a los mas usuales.

Marcadores más comunes #

El camino más simple para comprobar un valor es con una igualdad.

test('dos mas dos son cuatro', () => {
  expect(2 + 2).toBe(4);
});

Este código, expect (2 + 2) devuelve un objeto de "expectativa". Típicamente no hará mucho con esos objetos de tipo expectations, excepto llamar a matchers en ellos. Este código, .toBe(4) es el matcher. Cuando Jest es ejecutado, este sigue la huella de los matchers así que puede imprimir un mensaje de error más agradable.

toBe usa === para comprobar la igualdad exacta. Si quieres verificar el valor de un objeto puedes usar toEqual en su lugar:

test('asignacion de objeto', () => {
  const data = {uno: 1};
  data['dos'] = 2;
  expect(data).toEqual({uno: 1, dos: 2});
});

toEqual verifica recursivamente cada campo de un objeto o un arreglo.

También puedes comprobar lo contrario de que espera el matcher:

test('agregando un numero positivo que no sea 0', () => {
  for (let a = 1; a < 10; a++) {
    for (let b = 1; b < 10; b++) {
      expect(a + b).not.toBe(0);
    }
  }
});

Veracidad #

En los tests a veces es necesario distinguir entre undefined, null, y false, pero en otras ocasiones quizás deseas tratarlos por igual. Jest contiene helpers que te permitirán ser explícito acerca de lo que deseas.

• toBeNull coincide solo con null
• toBeUndefined coincide solo con undefined
• toBeDefinedes el opuesto a toBeUndefined
• toBeTruthy coincide con lo que sea que el condicional if devuelva como true
• toBeFalsy coincide con lo que sea que el condicional if devuelva como false

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('cero', () => {
  const z = 0;
  expect(z).not.toBeNull();
  expect(z).toBeDefined();
  expect(z).not.toBeUndefined();
  expect(z).not.toBeTruthy();
  expect(z).toBeFalsy();
});

Deberías usar el matcher que corresponda de manera mas precisa a lo que su código quiera que haga.

Números #

Existen múltiples matchers equivalentes para la comprobación de números.

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

  // toBe y toEqual son equivalentes para números
  expect(value).toBe(4);
  expect(value).toEqual(4);
});

Para igualdad de punto flotante, use toBeCloseTo en lugar de toEqual, esto por que no quisiera depender de un pequeño error de redondeo.

test(Sumando números punto flotante', () => {
  const value = 0.1 + 0.2;
  expect(value).not.toBe(0.3);    // ¡No coinciden! Por error de redondeo
  expect(value).toBeCloseTo(0.3); // Ésto funciona.
});

Strings #

Puede probar cadenas contra expresiones regulares con toMatch:

test('no hay I en Team', () => {
  expect('team').not.toMatch(/I/);
});

test('hay "stop" en Christoph', () => {
  expect('Christoph').toMatch(/stop/);
});

Arrays #

Puede verificar que un arreglo contenga un elemento particular usando toContain:

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

test('lista de compras tien beer en ella', () => {
  expect(shoppingList).toContain('beer');
});

Excepciones #

Si quiere probar que una función particular lanze un error cuando sea llamada use toThrow.

function compileAndroidCode() {
  throw new ConfigError('usted usa el JDK erroneo');
}

test('La compilacion de android va por buen camino', () => {
  expect(compileAndroidCode).toThrow();
  expect(compileAndroidCode).toThrow(ConfigError);

  // Puede usar el mensaje de error exacto o regex
  expect(compileAndroidCode).toThrow('Usa el  JDK equivocado');
  expect(compileAndroidCode).toThrow(/JDK/);
});

Hay más #

Esto es sólo un ejemplo. Para una lista completa de matchers, véase los documentos de referencia reference docs.

Una vez que haya aprendido sobre los matchers que están disponibles, como recomendación, verifique test asynchronous code.