Jest

Translate this Doc

Expect

Cuando estás escribiendo tests, a menudo necesitas comprobar que los valores cumplen ciertas condiciones. expect te da acceso a un número de marcadores que te permiten validar diferentes cosas.

Métodos #

Referencia #

expect(value) #

La función expect se utiliza cada vez que desea testear un valor. Rara vez se utiliza expect por sí mismo. En su lugar, utilizarás expect junto a una función de "comparación" para afirmar algo sobre un valor.

Es más fácil entenderlo con este ejemplo. Digamos que tenemos un método mejorSabor() que se supone que devuelve el texto 'grapefruit'. Así es cómo sería el test:

test('el mejor sabor es de melocotón', () => {
  expect(mejorSabor()).toBe('melocotón');
});

En este caso, toBe es la función de comparación. Hay una gran cantidad de funciones matcher diferentes, documentadas a continuación, para ayudarte a probar cosas diferentes.

El argumento expect debe ser el valor que produce tu código, y cualquier argumento de comparación debe ser el valor correcto. Si los mezclas, tus test problablemente seguiran funcionando, pero los mensajes de error seran confusos.

expect.extend(matchers) #

Puedes utilizar expect.extend para añadir tus propios comparadores a Jest. Por ejemplo, digamos que estás probando una librería de operaciones numéricas y con frecuencia estás afirmando que los números son divisibles por otros números. Podrías abstraer a un comparador de divisiblePor:

expect.extend({
  divisiblePor(recibido, argumento) {
    const pass = (recibido % argumento == 0);
    if (pass) {
      return {
        message: () => (
          `se esperaba ${recibido} no es divisible por ${argumento}`
        ),
        pass: true,
      };
    } else {
      return {
        message: () => (`se esperaba ${recibido} ser divisible por ${argumento}`),
        pass: false,
      };
    }
  },
});

test('números par y impar', () => {
  expect(100).divisiblePor(2);
  expect(101).not.divisiblePor(2);
});

Los comparadores deben devolver un objeto con dos parámetros. pass indica si hubo un acierto o no, y message proporciona una función sin argumentos que devuelve un mensaje de error en caso de fallo. Así, cuando pass es falso, message debe devolver el mensaje de error para cuando expect(x).tuComparador(). Y cuando pass es 'true', message debe devolver el mensaje de error para cuando expect(x).not.tuComparador().

Éstas funciones auxiliares se pueden encontrar dentro de this como comparador personalizado:

this.isNot #

Un boleano te permite conocer si un comparador fue llamado con el modificador de negación .not, permitiendo negar la afirmación.

this.equals(a, b) #

Esta es una función de igualdad profunda que regresará true si dos objetos tienen los mismos valores (recursivamente).

this.utils #

Hay un número de herramientas de utilidad reveladas en this.utils que consisten en las funciones de jest-matcher-utils.

Las más útiles son matcherHint, printExpected y printReceived para dar formato mas agradable a los mensajes de error. Por ejemplo, echa un vistazo en la implementación para el comparador toBe:

const diff = require('jest-diff');
expect.extend({
  toBe(received, expected) {
    const pass = received === expected;

    const message = pass
      ? () => this.utils.matcherHint('.not.toBe') + '\n\n' +
        `Expected value to not be (using ===):\n` +
        `  ${this.utils.printExpected(expected)}\n` +
        `Received:\n` +
        `  ${this.utils.printReceived(received)}`
      : () => {
        const diffString = diff(expected, received, {
          expand: this.expand,
        });
        return this.utils.matcherHint('.toBe') + '\n\n' +
        `Expected value to be (using ===):\n` +
        `  ${this.utils.printExpected(expected)}\n` +
        `Received:\n` +
        `  ${this.utils.printReceived(received)}` +
        (diffString ? `\n\nDifference:\n\n${diffString}` : '');
      };

    return {actual: received, message, pass};
  },
});

Esto mostrará algo así:

  expect(recibido).toBe(esperado)

    Expected value to be (using ===):
      "banana"
    Received:
      "apple"

Cuando una afirmación falla, el mensaje de error debería dar las señales necesarias para que el usuario pueda resolver sus problemas rápidamente. Deberías crear mensajes de errores precisos para que los usuarios de tus afirmaciones personalizadas se sientan cómodos usándolas.

expect.anything() #

expect.anything() aprobará cualquier cosa excepto null o undefined. Pedes usarlo dentro de toEqual o toBeCalledWith en vez de usar un valor literal. Por ejemplo, si quieres asegurarte de que un mock ha sido llamado con un argumento que no sea null:

test('map calls its argument with a non-null argument', () => {
  const mock = jest.fn();
  [1].map(mock);
  expect(mock).toBeCalledWith(expect.anything());
});

expect.any(constructor) #

expect.any(constructor) aprueba cualquier cosa que sea creada con el constructor recibido. Pedes usarlo dentro de toEqual o toBeCalledWith en vez de usar un valor literal. Por ejemplo, si quieres asegurarte de que un mock ha sido llamado con un número:

function randocall(fn) {
  return fn(Math.floor(Math.random() * 6 + 1));
}

test('randocall calls its callback with a number', () => {
  const mock = jest.fn();
  randocall(mock);
  expect(mock).toBeCalledWith(expect.any(Number));
});

expect.arrayContaining(array) #

expect.arrayContaining(array) aprueba que la matriz recibida contiene todos los elementos de la matriz esperada. Eso significa que la matriz esperada es un subconjunto de la matriz recibida. Por tanto, aprueba una matriz recibida que contenga elementos que no estén en la matriz esperada.

Puedes utilizarla en vez de usar un valor literal:

  • en toEqual o toBeCalledWith
  • para aprobar una propiedad en objectContaining o toMatchObject
describe('arrayContaining', () => {
  const expected = ['Alice', 'Bob'];
  it('matches even if received contains additional elements', () => {
    expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected));
  });
  it('does not match if received does not contain expected elements', () => {
    expect(['Bob', 'Eve']).not.toEqual(expect.arrayContaining(expected));
  });
});
describe('Beware of a misunderstanding! A sequence of dice rolls', () => {
  const expected = [1, 2, 3, 4, 5, 6];
  it('matches even with an unexpected number 7', () => {
    expect([4, 1, 6, 7, 3, 5, 2, 5, 4, 6])
      .toEqual(expect.arrayContaining(expected));
  });
  it('does not match without an expected number 2', () => {
    expect([4, 1, 6, 7, 3, 5, 7, 5, 4, 6])
      .not.toEqual(expect.arrayContaining(expected));
  });
});

expect.assertions(number) #

expect.assertions(number) verifica que un cierto número de afirmaciones han sido realizadas durante un test. Esto es útil a la hora de probar código asíncrono para asegurarnos de que las afirmaciones de un callback fueron llamadas.

Por ejemplo, supongamos que tenemos una función doAsync que recibe dos devoluciones de llamada callback1 y callback2, asincrónicamente se llamará a ambas en un orden desconocido. Podemos comprobarlo con:

test('doAsync llama a ambos callbacks', () => {
  expect.assertions(2);
  function callback1(data) {
    expect(data).toBeTruthy();
  }
  function callback2(data) {
    expect(data).toBeTruthy();
  }

  doAsync(callback1, callback2);
});

La llamada de expect.assertions(2) asegura que ambas devoluciones de llamada son efectivamente ejecutadas.

expect.hasAssertions() #

expect.hasAssertions() verifica que al menos una verificación es llamada durante un test. Esto es útil a la hora de probar código asíncrono para asegurarnos de que las afirmaciones de un callback fueron llamadas.

Por ejemplo, digamos que tenemos unas pocas funciones y todas tratan con un estado. prepareState llama a una devolución de llamada con un objeto de estado, validateState se ejecuta en este objeto de estado, y waitOnState devuelve una promesa que espera hasta que las devoluciones de llamada de prepareState completen. Podemos comprobarlo con:

test('prepareState prepara un estado valido', () => {
  expect.hasAssertions();
  prepareState(state => {
    expect(validateState(estado)).toBeTruthy();
  });
  return waitOnState();
});

La llamada de expect.hasAssertions() asegura que ambas devoluciones de llamada de prepareState son efectivamente ejecutadas.

expect.objectContaining(object) #

expect.objectContaining(object) compara recursivamente con cualquier objeto recibido que cumpla con las propiedades esperadas. Es decir, el objeto esperado es un subconjunto del objeto recibido. De tal manera que, hace match con un objeto que contiene propiedades que no se encuentran en el objeto esperado.

En lugar de verificar los valores de propiedades en el objeto esperado, se pueden ocupar matchers, como expect.anything(), entre otros.

Por ejemplo, si se espera que la función onPress sea llamada con el objeto Event, y solo se necesita verificar que el evento tiene las propiedades event.x y event.y. Puedes hacer esto con:

test('onPress es llamado con argumentos correctos', () => {
  const onPress = jest.fn();
  simulatePresses(onPress);
  expect(onPress).toBeCalledWith(expect.objectContaining({
    x: expect.any(Number),
    y: expect.any(Number),
  }));
});

expect.stringContaining(string) #

disponible en Jest 19.0.0+ #

expect.stringContaining(string) coincide con cualquier cadena de texto recibida que contenga la cadena de texto exacta.

expect.stringMatching(regexp) #

expect.stringMatching(regexp) coincide con cualquier cadena recibida que coincida con la expresión regular esperada.

Puedes utilizarla en vez de usar un valor literal:

  • en toEqual o toBeCalledWith
  • para que coincida con un elemento en arrayContaining
  • para aprobar una propiedad en objectContaining o toMatchObject

Este ejemplo también muestra cómo se pueden anidar múltiples marcadores de comparación asimétricas, con expect.stringMatching dentro de expect.arrayContaining.

describe('stringMatching en arrayContaining', () => {
  const esperado = [
    expect.stringMatching(/^Alic/),
    expect.stringMatching(/^[BR]ob/),
  ];
  it('hace match incluso si se reciben elementos adicionales', () => {
    expect(['Alicia', 'Roberto', 'Evelina'])
      .toEqual(expect.arrayContaining(esperado));
  });
  it('no hace match si lo recibido no contiene los elementos esperados', () => {
    expect(['Roberto', 'Evelina'])
      .not.toEqual(expect.arrayContaining(esperado));
  });
});

expect.addSnapshotSerializer(serializer) #

Puedes llamar a expect.addSnapshotSerializer para agregar un módulo que formatee estructuras de datos específicas de la aplicación.

Para un archivo de test individual, un módulo añadido precede a los módulos de snapshotSerializers en la configuración, que preceden los serializadores de instantánea predeterminados para tipos de JavaScript integrados y elementos de React. El último módulo añadido, es el primero módulo testeado.

import serializer from 'my-serializer-module';
expect.addSnapshotSerializer(serializer);

// afecta a las afirmaciones expect(value).toMatchSnapshot() en el archivo de test

Si añades un serializador de instantánea en los archivos de test individuales en vez de a agregarlo a la configuración de snapshotSerializers:

  • Haces la dependencia explícita en lugar de implícita.
  • Evitas límites de la configuración que podría causarte expulsar desde create-react-app.

Véase configurando Jest para más información.

.not #

Si sabes cómo testear algo, .no te permite comprobar su opuesto. Por ejemplo, este código testea que el mejor sabor de La Croix no es coco:

test('el mejor sabor no es coco', () => {
  expect(mejorSaborLaCroix()).not.toBe('coco');
});

.resolves #

disponible en Jest 20.0.0+ #

Utiliza resolves para desenvolver el valor de una promesa cumplida, para que así cualquier otro marcados pueda ser encadenado. Si la promesa se rechaza la afirmación falla.

Por ejemplo, este código testea que la promesa resuelve y que el valor resultando es 'limon':

test('resuelve a limon', () => {
  // Es esencial que se agregue un statement de return
  return expect(Promise.resolve('limon')).resolves.toBe('limon');
});

Alternativamente, se puede usar async/await en combinación con .resolves:

test('resuelve a limon', async () => {
  await expect(Promise.resolve('limon')).resolves.toBe('limon');
  await expect(Promise.resolve('limon')).resolves.not.toBe('pulpo');
});

.rejects #

disponible en Jest 20.0.0+ #

Usa .rejects para desenvolver el valor de una promesa cumplida, para que así cualquier otro marcados pueda ser encadenado. Si la promesa es rechazada la afirmación falla.

Por ejemplo, este código de test que la promesa rechaza con una razón:

test('fetchData() rechaza para ser un error', () => {
  // Es esencial que se agregue un statement de return
  return expect(Promise.reject('pulpo')).rejects.toBeDefined();
});

Alternativamente, se puede usar async/await en combinación con .rejects. Además, este código comprueba que la razón devuelta incluye 'octopus':

test('fetchData() rechaza para ser un error', async () => {
  const bebidaPulpo = new Promise(() => {
      throw new ErrorSaborRepugnante('puaf, sabor a pulpo');
  });

  await expect(bebidaPulpo).rejects.toMatch('pulpo');
});

.toBe(value) #

toBe solo comprueba que un valor es lo que se espera. Utiliza === para la comprobarla igualdad estricta.

Por ejemplo, el código a continuación valida algunas propiedades del objeto lata:

const lata = {
  nombre: 'pomelo',
  onzas : 12,
};

describe('la lata', () => {
  test('tiene 12 onzas', () => {
    expect(lata.onzas).toBe(12);
  });

  test('tiene un nombre sofisticado', () => {
    expect(lata.nombre).toBe('pomelo');
  });
});

No utilices toBe con números de punto flotante. Por ejemplo, debido al redondeo, en JavaScript 0,2 + 0,1 no es estrictamente igual a 0,3. Si tienes números de punto flotante, prueba .toBeCloseTo en su lugar.

.toHaveBeenCalled() #

También bajo el alias: .toBeCalled()

Usa .toHaveBeenCalled para asegurar que una función "mock" fue llamada.

Por ejemplo, digamos que tienes una función beberTodo(beber, sabor) que tiene una función beber y la aplica a todas las bebidas disponibles. Podrías querer comprobar que este beber es llamado para 'limon', pero no para 'pulpo', porque el sabor de 'pulpo' es realmente extraño y, ¿por qué iba a tener algo sabor a pulpo? Puedes hacerlo con esta serie de tests:

describe('beberTodo', () => {
  test('bebe algo con sabor a limon', () => {
    const beber = jest.fn();
    beberTodo(beber, 'limon');
    expect(beber).toHaveBeenCalled();
  });

  test('no bebe algo con sabor a pulpo', () => {
    const beber = jest.fn();
    drinkAll(beber, 'pulpo');
    expect(beber).not.toHaveBeenCalled();
  });
});

.toHaveBeenCalledTimes(number) #

Usa .toHaveBeenCalledTimes para asegurar que una función "mock" se llamo un número de veces exacto.

Por ejemplo, digamos que tienes una función beberCada(beber, Array<sabor>) que toma una función beber y la aplica a un arreglo de bebidas. Puede que quieras comprobar que la función beber se llamó un numero exacto de veces. Puedes hacerlo con esta serie de tests:

test('beberCada bebe cada bebida', () => {
  const beber = jest.fn();
  beberCada(beber, ['limon', 'pulpo']);
  expect(beber).toHaveBeenCalledTimes(2);
});

.toHaveBeenCalledWith(arg1, arg2, ...) #

También bajo el alias: .toBeCalledWith()

Usa .toHaveBeenCalledWith para asegurar que una función mock haya sido llamada con argumentos específicos.

Por ejemplo, digamos que tienes una bebida con una función registrar, y aplicarATodo(f) que aplica la función f a todas las bebidas registradas. Para asegurarte que funciona, puedes escribir:

test('registro aplicado correctamente a La Croix naranja', () => {
  const bebida = new LaCroix('naranja');
  registrar(bebida);
  const f = jest.fn();
  aplicarATodo(f);
  expect(f).toHaveBeenCalledWith(bebida);
});

.toHaveBeenLastCalledWith(arg1, arg2, ...) #

También bajo el alias: .lastCalledWith(arg1, arg2, ...)

Si tienes una función mock, puedes usar .toHaveBeenLastCalledWith para ver los argumentos con los que fue llamada la ultima vez. Por ejemplo digamos que tienes una función aplicarATodosLosSabores(f) que aplica la función f a diversos sabores, y quieres asegurarte que la ultima vez que se llama a esta función el último sabor al que se le aplica la función es 'mango'. Puedes escribir:

test('aplicarATodosLosSabores deja el mango para el final', () => {
  const bebida = jest.fn();
  aplicarATodosLosSabores(bebida);
  expect(bebida).toHaveBeenLastCalledWith('mango');
});

.toBeCloseTo(número, númeroDigitos) #

Usar la igualdad exacta con números de punto flotante es una mala idea. Redondear hace que cosas que parecen intuitivas puedan fallar. Por ejemplo, esta prueba falla:

test('sumar funciona de manera sencilla con decimales simples', () => {
  expect(0.2 + 0.1).toBe(0.3); // Falla!
});

Esto falla porque en Javascript, 0.2 + 0.1 es en realidad 0.30000000000000004. Lástima.

En su lugar, usa .toBeCloseTo. Utiliza numDigits para controlar cuántos dígitos después del punto decimal se deben verificar. Por ejemplo, si quieres estar seguro que 0.2 + 0.1 es igual a 0.3 con una precisión de 5 dígitos decimales, puedes ocupar esta prueba:

test('sumar funciona de manera sencilla con decimales simples', () => {
  expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
});

El valor por defecto para númeroDigitos es 2, el cual ha demostrado ser un buen valor por defecto para la mayoría de los casos.

.toBeDefined() #

Usa .toBeDefined para verificar que una variable no sea undefined. Por ejemplo, si deseas verificar que la función conseguirNuevaIdeaSabor() regresa algo, puedes escribir:

test('hay una nueva idea de sabor', () => {
  expect(conseguirNuevaIdeaSabor()).toBeDefined();
});

Puedes escribir expect(conseguirNuevaIdeaSabor()).not.toBe(undefined), pero es buena practica omitir el uso de undefined directamente en el código.

.toBeFalsy() #

Usa .toBeFalsy cuando no te importa el valor y solo te interesa saber si el valor es falso en un contexto booleano. Por ejemplo, digamos que algún fragmento de una aplicación se ve algo así:

beberPocoLaCroix();
if (!conseguirErrores()) {
  beberMasLaCroix();
}

Puede que no te importe el valor que conseguirErrores regrese, específicamente - podría regresar false, null, o ``, y el código funcionaría correctamente. Si quieres probar que no hay errores después de tomar algo de La Croix, podrías escribir:

test('beber LaCroix no provoca errores', () => {
  beberPocoLaCroix();
  expect(conseguirErrores()).toBeFalsy();
});

En JavaScript, hay seis valores falsos en contexto booleano, o "falsy": false, `,'',null,undefined, yNaN`. Cualquier otro valor es verdadero en contexto booleano, o "truthy".

.toBeGreaterThan(número) #

Para comparar números de punto flotante, puedes usar toBeGreaterThan. Por ejemplo, si deseas probar que onzasPorLata() regresa un valor de más de 10 onzas, puedes escribir:

test('onzas por lata es mayor a 10', () => {
  expect(onzasPorLata()).toBeGreaterThan(10);
});

.toBeGreaterThanOrEqual(número) #

Para comparar números de punto flotante, puedes usar toBeGreaterThanOrEqual. Por ejemplo, si deseas probar que onzasPorLata() regresa un valor de por lo menos 12 onzas, puedes escribir:

test('onzas por lata es por lo menos 12', () => {
  expect(onzasPorLata()).toBeGreaterThanOrEqual(12);
});

.toBeLessThan(número) #

Para comparar números de punto flotante, puedes usar toBeLessThan. Por ejemplo, si deseas probar que onzasPorLata() regresa un valor de menor a 20 onzas, puedes escribir:

test('onzas por lata es menor a 20', () => {
  expect(onzasPorLata()).toBeLessThan(20);
});

.toBeLessThanOrEqual(número) #

Para comparar números de punto flotante, puedes usar toBeLessThanOrEqual. Por ejemplo, si deseas probar que onzasPorLata() regresa un valor de a lo mucho 12 onzas, puedes escribir:

test('onzas por lata es a lo mucho 12', () => {
  expect(onzasPorLata()).toBeLessThanOrEqual(12);
});

.toBeInstanceOf(Class) #

Utiliza .toBeInstanceOf(Class) para verificar que un objeto es instancia de cierta clase. Esta comparación se realiza de manera interna ocupando instanceof.

class A {}

expect(new A()).toBeInstanceOf(A);
expect(() => {}).toBeInstanceOf(Function);
expect(new A()).toBeInstanceOf(Function); // avienta error

.toBeNull() #

.toBeNull() es idéntico a .toBe(null) pero con mensajes de error más claros. Por tanto, es preferible usar .toBeNull() para verificar si algo es nulo.

function bloop() {
  return null;
}

test('bloop regresa null', () => {
  expect(bloop()).toBeNull();
});

.toBeTruthy() #

Usa .toBeTruthy cuando no te importa el valor y solo te interesa saber si el valor es verdadero en un contexto booleano. Por ejemplo, digamos que algún fragmento de una aplicación se ve algo así:

beberPocoLaCroix();
if (infoSed()) {
  beberMasLaCroix();
}

Puede que no te importe el valor que infoSed regrese, específicamente - podría regresar trueo un objeto complejo, y el código funcionaría correctamente. Así que si solo te interesa probar que infoSed sea verdadero en un contexto booleano, o "truthy" después de beber un poco de La Croix, podrías escribir:

test('beber La Croix lleva a conseguir info de sed', () => {
  beberPocoLaCroix();
  expect(infoSed()).toBeTruthy();
});

En JavaScript, hay seis valores falsos en contexto booleano, o "falsy": false, `,'',null,undefined, yNaN`. Cualquier otro valor es verdadero en contexto booleano, o "truthy".

.toBeUndefined() #

Usa .toBeDefined para verificar que una variable es undefined. Por ejemplo, si quieres verificar que la función mejorBebidaPorSabor(sabor) regresa undefined para el sabor 'pulpo', porque no existe ninguna bebida con sabor a pulpo que sepa bien:

test('la mejor bebida con sabor a pulpo es undefined', () => {
  expect(mejorBebidaPorSabor('pulpo')).toBeUndefined();
});

Podría escribir expect(mejorBebidaPorSabor('pulpo')).toBe(undefined), pero es buena practica omitir el uso de undefined directamente en el código.

.toContain(item) #

Utilice .toContain cuando se desee verificar si un objeto esta en una lista. Para verificar cada objeto individual, este método utiliza ===, una verificación estricta de igualdad.

Por ejemplo, si el método conseguirTodosSabores() regresa una lista de sabores y quieres estar seguro que lima esta en la lista, puedes escribir:

test('la lista de sabores contiene lima', () => {
  expect(conseguirTodosSabores()).toContain('lima');
});

.toContainEqual(item) #

Utilice .toContainEqual cuando se desee verificar si un objeto esta en una lista. Para verificar cada objeto individualmente, este método verifica de manera recursiva igualdad en todos los campos, en lugar de verificar la identidad del objeto.

describe('mi bebida', () => {
  test('es deliciosa y no es agría', () => {
    const miBebida = {deliciosa: true, agria: false};
    expect(misBebidas()).toContainEqual(miBebida);
  });
});

.toEqual(value) #

Utilice .toEqual cuando se desee verificar que dos objetos tienen el mismo valor. Este método verifica la igualdad de todos los campos, en lugar de verificar la identidad del objeto - a esto se le conoce también como "igualdad profunda". Por ejemplo, toEqual y toBe se comportan diferentemente en esta serie de tests, así que todos los tests pasan:

const lata1 = {
  sabor: 'toronja',
  onzas: 12,
};
const lata2 = {
  sabor: 'toronja',
  onzas: 12,
};

describe('las latas de La Croix en mi escritorio', () => {
  test('tienen las mismas propiedades', () => {
    expect(lata1).toEqual(lata2);
  });
  test('no son la misma lata', () => {
    expect(lata1).not.toBe(lata2);
  });
});

Nota: .toEqual no realizara una verificación de igualdad profunda para dos errores. Sólo la propiedad message de un error se verifica para comparar igualdad. Se recomienda utilizar el método .toThrow para probar errores.

.toHaveLength(number) #

Utilice .toHaveLength para verificar que un objeto tenga longitud de .length y tenga cierto valor numérico.

Es especialmente útil para verificar el tamaño de cadenas o arreglos.

expect([1, 2, 3]).toHaveLength(3);
expect('abc').toHaveLength(3);
expect('').not.toHaveLength(5);

.toMatch(regexpOrString) #

Utilice .toMatch para verificar que la cadena coincida con una expresión regular (Regex).

Por ejemplo, puede que no sepas el valor exacto que ensayoSobreElMejorSabor() regresa, pero sabes que es una cadena muy larga, y que la cadena toronja es parte del contenido. Podemos probarlo con:

describe('un ensayo sobre el mejor sabor', () => {
  test('menciona toronja', () => {
    expect(ensayoSobreElMejorSabor()).toMatch(/toronja/);
    expect(ensayoSobreElMejorSabor()).toMatch(new RegExp('toronja'));
  });
});

Este método acepta también una cadena, con la que va a intentar coincidir:

describe('las toronjas son saludables', () => {
  test('las toronjas son frutas', () => {
    expect('toronjas').toMatch('fruta');
  });
});

.toMatchObject(object) #

Usa .toMatchObject para comprobar que un objeto de JavaScript coincide con un subconjunto de las propiedades de un objeto. Hará match de objetos recibidos cuyas propiedades no están en el objeto esperado.

También se puede pasar un arreglo de objetos, en cuyo caso el método regresara true solo si cada objeto en el arreglo hace match (como descrito en toMatchObject anteriormente) con el objeto correspondiente en el arreglo esperado. Esto es útil si se desea verificar que dos arreglos coinciden en el número de sus elementos, opuesto a arrayContaining, lo cual permite que el arreglo recibido contenga elementos adicionales.

Se puede hacer match de propiedades a través de sus valores o con matchers.

const casaEnVenta = {
  bañera: true,
  habitaciones: 4,
  cocina: {
    amenidades: ['horno', 'estufa', 'lavadora'],
    area: 20,
    colorPared: 'blanco',
  },
};
const casaDeseada = {
  bañera: true,
  cocina: {
    amenidades: ['horno', 'estufa', 'lavadora'],
    colorPared: expect.stringMatching(/blanco|amarillo/),
  },
};

test('la casa tiene las propiedades deseadas', () => {
  expect(casaEnVenta).toMatchObject(casaDeseada);
});
describe('toMatchObject aplicado a arreglos', () => {
  test('el número de elementos debe coincidir', () => {
    expect([
      { foo: 'bar' },
      { baz: 1 }
    ]).toMatchObject([
      { foo: 'bar' },
      { baz: 1 }
    ]);
  });

  // .arrayContaining "hará match de objetos recibidos cuyas propiedades no están en el objeto esperado."
  test('.toMatchObject no permite elementos extra', () => {
    expect([
      { foo: 'bar' },
      { baz: 1 }
    ]).toMatchObject([
      { foo: 'bar' }
    ]);
  });

  test('.toMatchObject es llamado para cada elemento, de modo que las propiedades extra del objeto no importan', () => {
    expect([
      { foo: 'bar' },
      { baz: 1, extra: 'quux' }
    ]).toMatchObject([
      { foo: 'bar' },
      { baz: 1 }
    ]);
  });
});

.toHaveProperty(pathLlave, valor) #

Utilice .toHaveProperty para verificar si la propiedad en la referencia de pathLlave existe para un objeto dado. Para verificar las propiedades anidadas de un objeto, utilice dot notation para referencias profundas.

Opcionalmente, se puede proveer un valor para verificar si está presente en el pathLlave del objeto objetivo. Este método utiliza 'igualdad profunda' (cómo toEqual()) y compara por igualdad a todos los campos de forma recursiva.

El siguiente ejemplo contiene un objeto casaEnVenta con propiedades anidadas. Estamos usando toHaveProperty para verificar la existencia y los valores de varias propiedades en el objeto.

// Objeto que contiene las propiedades de casa que se desean probar
const casaEnVenta = {
  bañera: true,
  habitaciones: 4,
  cocina: {
    amenidades: ['horno', 'estufa', 'lavadora'],
    area: 20,
    colorPared: 'white',
  },
};

test('this house has my desired features', () => {
  // Referencia simple
  expect(casaEnVenta).toHaveProperty('bañera');
  expect(casaEnVenta).toHaveProperty('habitaciones', 4);

  expect(casaEnVenta).not.toHaveProperty('piscina');

  // Referencia profuna ocupando notación dot
  expect(casaEnVenta).toHaveProperty('cocina.area', 20);
  expect(casaEnVenta).toHaveProperty('cocina.amenidades', [
    'horno',
    'estufa',
    'lavadora',
  ]);

  expect(casaEnVenta).not.toHaveProperty('cocina.abierta');
});

.toMatchSnapshot(optionalString) #

Esto garantiza que un valor coincide con el snapshot más reciente. Véase la guia de Snapshot Testing para más información.

Opcionalmente, se puede nombrar explicitamente el nombre del snapshot. Si no se especifica, el nombre se infiere de la prueba.

Nota: Las pruebas de snapshot son comúnmente usadas con componentes de React, sin embargo cualquier valor serializable puede utilizarse como snapshot.

.toThrow(error) #

También bajo el alias: .toThrowError(error)

Utilice .toThrow en una prueba para verificar que una función arroja un error cuando se llama. Por ejemplo, si deseamos probar que beberSabor('pulpo') arroja un error, porque el sabor a pulpo es demasiado repugnante para beber, podemos escribir:

test('arroja error en pulpo', () => {
  expect(() => {
    beberSabor('pulpo');
  }).toThrow();
});

Si deseas verificar que se arroja cierto error en especifico, se le puede proveer un argumento a toThrow. El argumento puede ser una cadena representando el mensaje del error, la clase del error, o una expresión regular regex que coincida con el error. Por ejemplo, digamos que el código de beberSabor es el siguiente:

function beberSabor(sabor) {
  if (sabor == 'pulpo') {
    throw new ErrorSaborRepugnante('guac! sabor a pulpo');
  }
  // Funcionalidad extra
}

Podríamos probar que este error lanza una excepción de varias formas:

test('arroja error en pulpo', () => {
  function beberPulpo() {
    beberSabor('pulpo');
  }

  // Probar el mensaje de error
  expect(beberPulpo).toThrowError('guac! sabor a pulpo');

  // Probar que el mensaje de error contiene "guac" en algún lugar del mensaje
  expect(beberPulpo).toThrowError(/guac/);

  // Probar que arroja un error ErrorSaborRepugnante
  expect(beberPulpo).toThrowError(ErrorSaborRepugnante);
});

.toThrowErrorMatchingSnapshot() #

Utilice .toThrowErrorMatchingSnapshot para probar que una función arroja un error igual al snapshot más reciente cuando es llamada. Por ejemplo, digamos que tienes una función beberSabor que arroja un error cuando el sabor es 'pulpo', y su código es el siguiente:

function beberSabor(sabor) {
  if (sabor == 'pulpo') {
    throw new ErrorSaborRepugnante('guac! sabor a pulpo');
  }
  // Funcionalidad extra
}

El test para esta función se verá así:

test('arroja error en pulpo', () => {
  function beberPulpo() {
    beberSabor('pulpo');
  }

  expect(beberPulpo).toThrowErrorMatchingSnapshot();
});

Y generará el siguiente snapshot:

exports[`drinking flavors throws on octopus 1`] = `"yuck, octopus flavor"`;

Echa un ojo a React Tree Snapshot Testing para más información sobre tests de instantánea.

← AnteriorSiguiente →