web-dev-qa-db-fra.com

Comment tester si une fonction ASYNC annulée a été réussie avec JEST?

Comment testez-vous concistablement si une fonction ASYNC annulée a été exécutée avec succès avec JEST? J'utilise documentscript.

// foo.ts
export class Foo {
  public async bar(): Promise<void> {
    await someAsync();
  }
}

Comment tester que new Foo().bar() ne jette pas une erreur?

typescriptpromisejestjsvoid
8
adanilev

C'est la façon la plus sémantique que j'ai trouvée. C'est même une traduction du nom de test.

describe("Foo.bar()", () => {
      test("Should not throw", async () => {
        await expect(new Foo().bar()).resolves.not.toThrow();
      });
    });
7
Mr Menezes

C'est la meilleure façon que j'ai trouvée. En espérant qu'il y a quelque chose de plus élégant.

describe("Foo.bar()", () => {
  it("should not throw", async () => {
    expect.assertions(1);

    try {
      await new Foo().bar();
      expect(true).toBeTruthy();
    } catch {
      // should not come here
    }
  });
});
2
adanilev

La promesse a l'avantage de ne pas jeter du tout, plutôt être résolue ou rejetée. D'autre part, la touche toBe() L'affirmation attend un argument, même s'il existe un Promise<void> Dans Typecript.

Donc, et s'il n'y a pas d'argument passé (ou l'argument n'est pas vide) mais il est toujours évalué. L'argument est undefined.

  test("Should resolve", async () => {
      await expect(new Foo().bar()).resolves.toBe(undefined);
  });

Test de not.toThrow() Il est arrivé d'être un faux ami pour moi, car mon Foo.bar() n'a pas lancé, pas non plus.

0
Alex

... alternative est resolves affirmation.

describe("Foo.bar()", () => {
  it("should not throw", () => {
      return expect(new Foo().bar()).resolves.toEqual();
  });
});

Ici, vous devez revenir en résultat puisqu'il s'agit d'une promesse (et de faire attendre la plaisanterie jusqu'à ce qu'il soit accompli). Il est légèrement plus laconique si vous n'avez besoin que de vérifier résolue (ou de rejeté - il y a un accessoire similaire rejects pour vérifier la valeur de rejet).

Mais dans le cas où vous auriez besoin d'exécuter plusieurs chèques après la fonction basée sur des promesses est exécuté comme

describe("Foo.bar()", () => {
  it("should not throw", () => {
      const promise = new Foo().bar()
      expect(promise).resolves.toEqual();
      expect(someMock).toHaveBeenCalled();
      return promise;
  });
});

vous pouvez trouver une option avec async/await est plus ... satisfaisant?

Ps comme pour votre variante

describe("Foo.bar()", () => {
  it("should not throw", async () => {
    expect.assertions(1);

    try {
      await new Foo().bar();
      expect(true).toBeTruthy();
    } catch {
      // should not come here
    }
  });
});

Je crois que ce n'est pas nécessaire pour attraper une erreur - donc expect.assertions Devient également redondant. Pourquoi? Une exception non capturée échouera votre test et on ne s'attend pas à une exception, alors il convient de l'échouer. Une telle structure sera nécessaire si vous vous attendez à une exception et que vous souhaitez vérifier ses propriétés.

Également si le test échoue à l'option avec expect.assertions Vous en informera à peu près son échec lorsque l'exception non capturée mettra en évidence une déclaration spécifique (utile si le test a plusieurs états possibles)

[Upd] aussi j'ai raté le point initial que vous devez vérifier si la promesse est résolue avec tout Résultat (mon vérification de la version qui est résolu avec undefined qui n'est pas vraiment bon mouvement (il Ne gâche rien si la fonction commence à renvoyer quelque chose S'il est renvoyé Rien avant). En attendant, nous devrions avoir au moins un chèque de test ...

Alors peut-être votre approche avec le talon expect(true) est la même légitime ici.

Mais je vérifierais deux fois si vous ne voulez pas faire plus expect dans le même cas de test. Cette déclaration est-elle en test vraiment isolé? Ou vous venez d'exploser des chèques liés à Séparez it()?

0
skyboyer