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

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 t.throwsmétodo de argumento , 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?

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);
});

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

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");
  }
});

Catchbloque catch su excepción, entonces se puede probar en su elevada Error. expect(true).toBe(false);Se necesita extraño para reprobar su prueba si no se espera que Errorse espere . De lo contrario, esta línea nunca es accesible ( Errordebe aparecer antes que ellos).

EDITAR: @Kenny Body sugiere una mejor solución que mejora la calidad del código si usa expect.assertions()

it('should throw Error with message \'UNKNOWN ERROR\' when no params were passed', () => {
  expect.assertions(1);
  try {
      throwError();
  } catch (e) {
      expect(e.message).toBe("UNKNOWN ERROR");
  }
});

Vea la respuesta original con más explicaciones: Cómo probar el tipo de excepción lanzada en Jest

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

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

Por mi exposición (aunque limitada) a Jest, he encontrado que expect().toThrow()es adecuado si solo desea probar que un error se arroja de un tipo específico:

expect(() => functionUnderTest()).toThrow(TypeError);

O se produce un error con un mensaje específico:

expect(() => functionUnderTest()).toThrow('Something bad happened!');

Si intentas hacer ambas cosas, obtendrás un falso positivo. Por ejemplo, si arroja su código RangeError('Something bad happened!'), esta prueba pasará:

expect(() => functionUnderTest()).toThrow(new TypeError('Something bad happened!'));

La respuesta de bodolsog que sugiere el uso de un try / catch es cercana, pero en lugar de esperar que true sea falso para garantizar que las afirmaciones esperadas en el catch sean acertadas, puede usar expect.assertions(2)al comienzo de su prueba dónde 2está el número de afirmaciones esperadas . Siento que esto describe con mayor precisión la intención de la prueba.

Ejemplo completo de prueba del tipo Y mensaje de error:

describe('functionUnderTest', () => {
    it('should throw a specific type of error.', () => {
        expect.assertions(2);

        try {
            functionUnderTest();
        } catch (error) {
            expect(error).toBeInstanceOf(TypeError);
            expect(error).toHaveProperty('message', 'Something bad happened!');
        }
    }); 
});

Si functionUnderTest()NO arroja un error, las aserciones serán acertadas pero expect.assertions(2)fallará y la prueba fallará.

No lo he intentado yo mismo, pero sugeriría usar la afirmación de Jest para lanzar . 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);
});

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

Jest tiene un método 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);

Los documentos

La broma moderna le permite hacer más controles sobre el valor rechazado. Por ejemplo:

const request = Promise.reject({statusCode: 404})
await expect(request).rejects.toMatchObject({ statusCode: 500 });

fallará con error

Error: expect(received).rejects.toMatchObject(expected)

- Expected
+ Received

  Object {
-   "statusCode": 500,
+   "statusCode": 404,
  }

La documentación es clara sobre cómo hacer esto. Digamos que tengo una función que toma dos parámetros y arrojará un error si uno de ellos es null.

function concatStr(str1, str2) {
  const isStr1 = str1 === null
  const isStr2 = str2 === null
  if(isStr1 || isStr2) {
    throw "Parameters can't be null"
  }
  ... // continue your code

Su prueba

describe("errors", () => {
  it("should error if any is null", () => {
    // notice that the expect has a function that returns the function under test
    expect(() => concatStr(null, "test")).toThrow()
  })
})

En caso de que esté trabajando con Promises:

await expect(Promise.reject(new HttpException('Error message', 402)))
  .rejects.toThrowError(HttpException);

Terminé escribiendo un método de conveniencia 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)
    }
  }

Además de la publicación de Peter Danis, solo quería enfatizar la parte de su solución que involucra "[pasar] una función a esperar (función) .toThrow (en blanco o tipo de error)".

En Jest, cuando prueba un caso en el que debe arrojarse un error, dentro de su ajuste de la función que se espera (), debe proporcionar una capa adicional de ajuste de la función de flecha para que funcione. Es decir

Incorrecto (pero el enfoque lógico de la mayoría de las personas):

expect(functionUnderTesting();).toThrow(ErrorTypeOrErrorMessage);

Correcto:

expect(() => { functionUnderTesting(); }).toThrow(ErrorTypeOrErrorMessage);

Es muy extraño, pero debería hacer que la prueba se ejecute con éxito.

tratar
expect(t).rejects.toThrow()