Wie schreibe ich einen Test, der erwartet, dass ein Fehler in Jasmine ausgelöst wird?

Ich versuche, einen Test für das Jasmine Test Framework zu schreiben, der einen Fehler erwartet. Im Moment verwende ich eine Jasmine Node.js-Integration von GitHub .

In meinem Knotenmodul habe ich folgenden Code:

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

Jetzt versuche ich einen Test zu schreiben, der diesen Fehler erwartet:

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

Ich habe auch Error()und einige andere Varianten ausprobiert und kann einfach nicht herausfinden, wie es funktioniert.

Sie sollten eine Funktion an den expect(...)Aufruf übergeben. Der Code, den Sie hier haben:

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

versucht tatsächlich , parser.parse(raw) einen Versuch aufzurufen , das Ergebnis an weiterzugeben expect(...),

Versuchen Sie stattdessen eine anonyme Funktion:

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

Du benutzt:

expect(fn).toThrow(e)

Aber wenn Sie sich den Funktionskommentar ansehen (erwartet wird ein String):

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) {

Ich nehme an, Sie sollten es wahrscheinlich so schreiben (mit Lambda - anonyme Funktion):

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

Dies wird im folgenden Beispiel bestätigt:

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

Douglas Crockford empfiehlt diesen Ansatz nachdrücklich, anstatt "throw new Error ()" (Prototyping-Methode) zu verwenden:

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

Eine elegantere Lösung als das Erstellen einer anonymen Funktion, deren einziger Zweck darin besteht, eine andere zu verpacken, ist die Verwendung der bindFunktion von es5 . Die Bindungsfunktion erstellt eine neue Funktion, deren thisSchlüsselwort beim Aufruf auf den angegebenen Wert gesetzt wird, wobei eine bestimmte Folge von Argumenten vor jeder angegebenen steht, die beim Aufruf der neuen Funktion angegeben wird.

Anstatt:

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

Erwägen:

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

Die Bindungssyntax ermöglicht es Ihnen, Funktionen mit unterschiedlichen thisWerten zu testen und macht den Test meiner Meinung nach besser lesbar. Siehe auch: https://stackoverflow.com/a/13233194/1248889

Ich ersetze Jasmines toThrow-Matcher durch den folgenden, mit dem Sie die Namenseigenschaft oder die Nachrichteneigenschaft der Ausnahme abgleichen können. Für mich macht dies das Schreiben von Tests einfacher und weniger spröde, da ich Folgendes tun kann:

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

und dann mit folgendem testen:

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

Auf diese Weise kann ich die Ausnahmemeldung später optimieren, ohne die Tests zu unterbrechen, wenn es darauf ankommt, dass der erwartete Ausnahmetyp ausgelöst wird.

Dies ist der Ersatz für toThrow, der dies ermöglicht:

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

Wie bereits erwähnt, muss eine Funktion übergeben werden, toThrowda es sich um die Funktion handelt, die Sie in Ihrem Test beschreiben: "Ich erwarte, dass diese Funktion x auslöst."

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

Wenn Sie Jasmine-Matcher verwenden , können Sie auch eine der folgenden Optionen verwenden, wenn sie der Situation entsprechen.

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

oder

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

Ich weiß, dass das mehr Code ist, aber Sie können auch Folgendes tun:

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

Für Coffeescript-Liebhaber

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

Für alle, die immer noch mit diesem Problem konfrontiert sind, hat die veröffentlichte Lösung nicht funktioniert und diesen Fehler immer wieder ausgelöst: Error: Expected function to throw an exception. Später wurde mir klar, dass die Funktion, von der ich erwartet hatte, dass sie einen Fehler auslöst, eine asynchrone Funktion ist und ein Versprechen erwartet abgelehnt werden und dann Fehler werfen und das habe ich in meinem Code getan:

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

und das habe ich in meinem Test gemacht und es hat funktioniert:

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