web-dev-qa-db-fra.com

Comment tester le type d'exception levée dans Jest

Je travaille avec un code où je dois tester le type d'exception levée par fonction (Est-ce que TypeError, ReferenceError etc.).

Mon framework de test actuel est AVA et je peux le tester en tant que second argument t.throws, comme ici:

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

J'ai commencé à réécrire mes tests en Jest et je ne trouvais pas comment le faire facilement. Est-ce même possible?

javascriptunit-testingjestjs
63
Tranotheron

En Jest, vous devez passer une fonction dans expect (fonction) .toThrow (blanc ou type d'erreur).

Exemple:

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

Si vous avez besoin de tester une fonction existante avec des arguments, vous devez l'envelopper dans une fonction anonyme dans expect ().

Exemple:

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

Un peu bizarre, mais ça marche et à mon avis, c'est bien lisible:

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 block attrape votre exception, vous pouvez alors tester sur votre Error élevé. Étrange expect(true).toBe(false); est nécessaire pour faire échouer votre test si vous attendez que Error ne soit pas lancé. Sinon, cette ligne n'est jamais accessible (Error devrait être élevé avant eux).

34
bodolsog

J'utilise une version légèrement plus concise:

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

Je n'ai pas essayé moi-même, mais je suggérerais d'utiliser l'affirmation toThrow de Jest. Je suppose donc que votre exemple ressemblerait à quelque chose comme ceci:

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

Encore une fois, je ne l'ai pas testé mais je pense que cela devrait fonctionner.

Faites-moi savoir si cela a aidé.

Bon codage!

9
Andrei CACIO

Jest a une méthode toThrow(error) pour tester le lancement d'une fonction lors de son appel.

Donc, dans votre cas, vous devriez l'appeler ainsi:

expect(t).toThrowError(TypeError);

Les docs

8
alexmac

essayer
expect(t).rejects.toThrow()

1
Razim Saidov

J'ai fini par écrire une méthode pratique pour notre bibliothèque de 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)
    }
  }
1
kpollock