Comment écrire un test qui s'attend à ce qu'une erreur soit lancée dans Jasmine?

J'essaie d'écrire un test pour Jasmine Test Framework qui attend une erreur. Pour le moment, j'utilise une intégration Jasmine Node.js de GitHub .

Dans mon module Node, j'ai le code suivant:

throw new Error("Parsing is not possible");

Maintenant, j'essaie d'écrire un test qui attend cette erreur:

describe('my suite...', function() {
    [..]
    it('should not parse foo', function() {
    [..]
        expect(parser.parse(raw)).toThrow(new Error("Parsing is not possible"));
    });
});

J'ai également essayé Error()et quelques autres variantes et je n'arrive pas à comprendre comment le faire fonctionner.

vous devez transmettre une fonction à l' expect(...)appel. Le code que vous avez ici:

// incorrect:
expect(parser.parse(raw)).toThrow(new Error("Parsing is not possible"));

essaie d' appeler parser.parse(raw) pour tenter de transmettre le résultat expect(...),

Essayez plutôt d'utiliser une fonction anonyme:

expect( function(){ parser.parse(raw); } ).toThrow(new Error("Parsing is not possible"));

Vous utilisez:

expect(fn).toThrow(e)

Mais si vous regardez le commentaire de la fonction (la chaîne attendue est):

294 /**
295  * Matcher that checks that the expected exception was thrown by the actual.
296  *
297  * @param {String} expected
298  */
299 jasmine.Matchers.prototype.toThrow = function(expected) {

Je suppose que vous devriez probablement l'écrire comme ceci (en utilisant lambda - fonction anonyme):

expect(function() { parser.parse(raw); } ).toThrow("Parsing is not possible");

Ceci est confirmé dans l'exemple suivant:

expect(function () {throw new Error("Parsing is not possible")}).toThrow("Parsing is not possible");

Douglas Crockford recommande fortement cette approche, au lieu d'utiliser "throw new Error ()" (façon de prototypage):

throw {
   name: "Error",
   message: "Parsing is not possible"
}

Une solution plus élégante que de créer une fonction anonyme dont le seul but est d'en envelopper une autre est d'utiliser la bindfonction d'es5 . La fonction de liaison crée une nouvelle fonction qui, lorsqu'elle est appelée, a son thismot clé défini sur la valeur fournie, avec une séquence donnée d'arguments précédant tout argument fourni lorsque la nouvelle fonction est appelée.

Au lieu de:

expect(function () { parser.parse(raw, config); } ).toThrow("Parsing is not possible");

Considérer:

expect(parser.parse.bind(parser, raw, config)).toThrow("Parsing is not possible");

La syntaxe de liaison vous permet de tester des fonctions avec des thisvaleurs différentes et, à mon avis, rend le test plus lisible. Voir aussi: https://stackoverflow.com/a/13233194/1248889

Je remplace le match toThrow de Jasmine par ce qui suit, ce qui vous permet de faire correspondre la propriété de nom de l'exception ou sa propriété de message. Pour moi, cela rend les tests plus faciles à écrire et moins fragiles, car je peux faire ce qui suit:

throw {
   name: "NoActionProvided",
   message: "Please specify an 'action' property when configuring the action map."
}

puis testez avec les éléments suivants:

expect (function () {
   .. do something
}).toThrow ("NoActionProvided");

Cela me permet de modifier le message d'exception plus tard sans casser les tests, lorsque l'important est qu'il a levé le type d'exception attendu.

C'est le remplacement de toThrow qui permet ceci:

jasmine.Matchers.prototype.toThrow = function(expected) {
  var result = false;
  var exception;
  if (typeof this.actual != 'function') {
    throw new Error('Actual is not a function');
  }
  try {
    this.actual();
  } catch (e) {
    exception = e;
  }
  if (exception) {
      result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected) || this.env.equals_(exception.name, expected));
  }

  var not = this.isNot ? "not " : "";

  this.message = function() {
    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
      return ["Expected function " + not + "to throw", expected ? expected.name || expected.message || expected : " an exception", ", but it threw", exception.name || exception.message || exception].join(' ');
    } else {
      return "Expected function to throw an exception.";
    }
  };

  return result;
};

Comme mentionné précédemment, une fonction doit être transmise toThrowcar c'est la fonction que vous décrivez dans votre test: "Je m'attends à ce que cette fonction renvoie x"

expect(() => parser.parse(raw))
  .toThrow(new Error('Parsing is not possible'));

Si vous utilisez Jasmine-Matchers, vous pouvez également utiliser l'un des éléments suivants lorsqu'ils conviennent à la situation;

// I just want to know that an error was
// thrown and nothing more about it
expect(() => parser.parse(raw))
  .toThrowAnyError();

ou

// I just want to know that an error of 
// a given type was thrown and nothing more
expect(() => parser.parse(raw))
  .toThrowErrorOfType(TypeError);

Je sais que c'est plus de code mais vous pouvez également faire:

try
   do something
   @fail Error("should send a Exception")
 catch e
   expect(e.name).toBe "BLA_ERROR"
   expect(e.message).toBe 'Message'

Pour les amateurs de coffeescript

expect( => someMethodCall(arg1, arg2)).toThrow()

Pour tous ceux qui pourraient encore être confrontés à ce problème, pour moi, la solution publiée ne fonctionnait pas et elle continuait de générer cette erreur: Error: Expected function to throw an exception. j'ai réalisé plus tard que la fonction que je m'attendais à lancer une erreur était une fonction asynchrone et attendait une promesse de être rejeté puis lancer une erreur et c'est ce que je faisais dans mon code:

throw new Error('REQUEST ID NOT FOUND');

et c'est ce que j'ai fait dans mon test et cela a fonctionné:

it('Test should throw error if request not found', willResolve(() => {
         const promise = service.getRequestStatus('request-id');
                return expectToReject(promise).then((err) => {
                    expect(err.message).toEqual('REQUEST NOT FOUND');
                });
            }));