Können Sie asynchrone Tests schreiben, die toThrow erwarten?

Ich schreibe einen asynchronen Test, der erwartet, dass die asynchrone Funktion so wirft:

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

Aber Scherz ist nur scheitern, anstatt die Prüfung zu bestehen:

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

    Failed: I should fail!

Wenn ich den Test umschreibe sieht das so aus:

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

Ich erhalte diesen Fehler anstelle eines bestandenen Tests:

expect(function).toThrow(undefined)

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

Sie können Ihre asynchrone Funktion wie folgt testen:

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

Die Zeichenfolge „Ich sollte scheitern“ stimmt mit jedem Teil des ausgegebenen Fehlers überein.

Ich möchte dem nur hinzufügen und sagen, dass die Funktion, die Sie testen, ein tatsächliches Error-Objekt werfen muss throw new Error(...). Jest scheint nicht zu erkennen, wenn Sie nur einen Ausdruck wie werfen throw 'An error occurred!'.

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

Wir müssen den Code in eine Funktion packen, um den Fehler abzufangen. Hier erwarten wir, dass die von someAsyncFunction ausgegebene Fehlermeldung gleich „Some error message“ sein sollte. Wir können auch den Ausnahmehandler aufrufen

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

Weiterlesen https://jestjs.io/docs/expect#tothrowerror

Benutzerdefinierte Fehlerklasse

Die Verwendung von rejects.toThrow wird bei dir nicht funktionieren. Stattdessen können Sie die kombinieren rejects Methode mit der toBeInstanceOf Matcher, um den ausgegebenen benutzerdefinierten Fehler abzugleichen.

Beispiel

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

oder

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

Um viele Testbedingungen machen zu können, ohne jedes Mal das Promise auflösen zu müssen, geht auch das:

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'),
            })
        })
    })

Ich habe Firebase-Cloud-Funktionen getestet und folgendes herausgefunden:

test("It should test async on failing cloud functions calls", async () => {
    await expect(async ()=> {
        await failingCloudFunction(params)
    })
    .rejects
    .toThrow("Invalid type"); // This is the value for my specific error
  });

Dies baut auf Lisandros Antwort auf.

Das hat bei mir funktioniert

it("expects to have failed", async () => {
  let getBadResults = async () => {
    await failingAsyncTest()
  }
  expect(getBadResults()).reject.toMatch('foo')
  // or in my case
  expect(getBadResults()).reject.toMatchObject({ message: 'foo' })
})