Pouvez-vous écrire des tests asynchrones qui attendent toThrow ?

Question

J'écris un test asynchrone qui s'attend à ce que la fonction asynchrone soit lancée comme ceci :

it("expects to have failed", async () => {
  let getBadResults = async () => {
    await failingAsyncTest()
  }
  expect(await getBadResults()).toThrow()
})

Mais Jest échoue juste au lieu de passer le test :

 FAIL  src/failing-test.spec.js
   expects to have failed

    Failed: I should fail!

Si je réécris le test pour qu'il ressemble à ceci :

expect(async () => {
  await failingAsyncTest()
}).toThrow()

J'obtiens cette erreur au lieu d'un test réussi :

expect(function).toThrow(undefined)

Expected the function to throw an error.
But it didn't throw anything.

Answer 1

Vous pouvez tester votre fonction asynchrone comme ceci :

it('should test async errors', async () =>  {        
    await expect(failingAsyncTest())
    .rejects
    .toThrow('I should fail');
});

La chaîne "I should fail" correspondra à n'importe quelle partie de l'erreur déclenchée.

Answer 2

Je voudrais juste ajouter que la fonction que vous testez doit lancer un objet d'erreur réel. throw new Error(...) . Jest ne semble pas reconnaître si vous lancez simplement une expression comme throw 'An error occurred!' .

Answer 3

await expect(async () => { 
    await someAsyncFunction(someParams); 
}).rejects.toThrowError("Some error message");

Nous devons envelopper le code dans une fonction pour attraper l'erreur. Ici, nous nous attendons à ce que le message d'erreur envoyé par someAsyncFunction soit égal à "Some error message". Nous pouvons également appeler le gestionnaire d'exception

await expect(async () => { 
    await someAsyncFunction(someParams); 
}).rejects.toThrowError(new InvalidArgumentError("Some error message"));

Lire la suite https://jestjs.io/docs/expect#tothrowerror

Answer 4

Classe d'erreur personnalisée

L'utilisation de rejects.toThrow ne fonctionnera pas pour vous. Au lieu de cela, vous pouvez combiner les rejects avec la méthode toBeInstanceOf pour correspondre à l'erreur personnalisée qui a été déclenchée.

Exemple

it("should test async errors", async () => {
  await expect(asyncFunctionWithCustomError()).rejects.toBeInstanceOf(
    CustomError
  )
})

o

it("should test async errors", async () => {
  await expect(async () => {
    await asyncFunctionWithCustomError()
  }).rejects.toBeInstanceOf(CustomError)
})

Answer 5

Pour pouvoir réaliser de nombreuses conditions de test sans devoir résoudre la promesse à chaque fois, cela fonctionnera également :

it('throws an error when it is not possible to create an user', async () => {
        const throwingFunction = () => createUser(createUserPayload)

        // This is what prevents the test to succeed when the promise is resolved and not rejected
        expect.assertions(3)

        await throwingFunction().catch(error => {
            expect(error).toBeInstanceOf(Error)
            expect(error.message).toMatch(new RegExp('Could not create user'))
            expect(error).toMatchObject({
                details: new RegExp('Invalid payload provided'),
            })
        })
    })