javascript - unit - Cómo probar el tipo de excepción lanzada en Jest

unit testing react js

Question

Estoy trabajando con algún código donde necesito probar el tipo de excepción lanzada por función (¿Es TypeError, ReferenceError, etc.).

Mi marco de prueba actual es AVA y puedo probarlo como un segundo argumento del método t.throws , como aquí:

it(''should throw Error with message /'UNKNOWN ERROR/' when no params were passed'', (t) => {
  const error = t.throws(() => {
    throwError();
  }, TypeError);

  t.is(error.message, ''UNKNOWN ERROR'');
});

Comencé a reescribir mis pruebas a Jest y no pude encontrar cómo hacerlo fácilmente. ¿Es posible?

Answer 1

En Jest, debe pasar una función a esperar (función) .toThrow (en blanco o tipo de error).

Ejemplo:

test("Test description", () => {
  const t = () => {
    throw new TypeError();
  };
  expect(t).toThrow(TypeError);
});

Si necesita probar una función existente si se lanza con un conjunto de argumentos, debe envolverla dentro de una función anónima en expect ().

Ejemplo:

test("Test description", () => {
  expect(() => {http.get(yourUrl, yourCallbackFn)}).toThrow(TypeError);
});

Answer 2

Jest tiene un método para toThrow(error) para probar que una función se lanza cuando se llama.

Entonces, en su caso, debería llamarlo así:

expect(t).toThrowError(TypeError);

toThrow

Answer 3

No lo he intentado yo mismo, pero sugeriría usar la afirmación de Jest para toThrow . Así que supongo que su ejemplo se vería así:

it(''should throw Error with message /'UNKNOWN ERROR/' when no params were passed'', (t) => {
  const error = t.throws(() => {
    throwError();
  }, TypeError);

  expect(t).toThrowError(''UNKNOWN ERROR'');
  //or
  expect(t).toThrowError(TypeError);
});

Nuevamente, no lo he probado, pero creo que debería funcionar.

Hagame saber si esto fue de utilidad.

¡Feliz codificación!

Answer 4

Terminé escribiendo un método conveniente para nuestra biblioteca test-utils

/**
 *  Utility method to test for a specific error class and message in Jest
 * @param {fn, expectedErrorClass, expectedErrorMessage }
 * @example   failTest({
      fn: () => {
        return new MyObject({
          param: ''stuff''
        })
      },
      expectedErrorClass: MyError,
      expectedErrorMessage: ''stuff not yet implemented''
    })
 */
  failTest: ({ fn, expectedErrorClass, expectedErrorMessage }) => {
    try {
      fn()
      expect(true).toBeFalsy()
    } catch (err) {
      let isExpectedErr = err instanceof expectedErrorClass
      expect(isExpectedErr).toBeTruthy()
      expect(err.message).toBe(expectedErrorMessage)
    }
  }

Answer 5

Un poco raro, pero funciona y en mi humilde opinión es bueno:

it(''should throw Error with message /'UNKNOWN ERROR/' when no params were passed'', () => {
  try {
      throwError();
      // Fail test if above expression doesn''t throw anything.
      expect(true).toBe(false);
  } catch (e) {
      expect(e.message).toBe("UNKNOWN ERROR");
  }
});

Catch bloque de captura captura su excepción, luego puede probar su Error elevado. Extraño expect(true).toBe(false); es necesario para fallar su prueba si no se arrojará el Error esperado. De lo contrario, esta línea nunca es accesible (el Error debe aparecer antes que ellos).

Answer 6

Yo uso una versión un poco más concisa:

expect(() => {
  //code block that should throw error
}).toThrow(TypeError) //or .toThrow(''expectedErrorMessage'')

Answer 7

tratar
expect(t).rejects.toThrow()