Come scrivere un test che prevede che venga lanciato un errore in Jasmine?

Sto cercando di scrivere un test per il Jasmine Test Framework che prevede un errore. Al momento sto usando un'integrazione Jasmine Node.js da GitHub .

Nel mio modulo Node ho il seguente codice:

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

Ora provo a scrivere un test che prevede questo errore:

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

Ho provato anche Error()alcune altre varianti e non riesco proprio a capire come farlo funzionare.

dovresti passare una funzione nella expect(...)chiamata. Il codice che hai qui:

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

sta cercando di chiamare effettivamente parser.parse(raw)nel tentativo di passare il risultato in expect(...),

Prova invece a utilizzare una funzione anonima:

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

Tu stai usando:

expect(fn).toThrow(e)

Ma se darai un'occhiata al commento della funzione (previsto è stringa):

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

Suppongo che dovresti probabilmente scriverlo in questo modo (usando lambda - funzione anonima):

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

Ciò è confermato nel seguente esempio:

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

Douglas Crockford raccomanda vivamente questo approccio, invece di usare "throw new Error ()" (prototipazione):

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

Una soluzione più elegante della creazione di una funzione anonima che ha come unico scopo quello di avvolgerne un'altra, è quella di utilizzare la bindfunzione es5 . La funzione bind crea una nuova funzione che, quando viene chiamata, ha la thisparola chiave impostata sul valore fornito, con una determinata sequenza di argomenti che precede qualsiasi fornita quando viene chiamata la nuova funzione.

Invece di:

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

Prendere in considerazione:

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

La sintassi del bind consente di testare funzioni con thisvalori diversi e, a mio avviso, rende il test più leggibile. Vedi anche: https://stackoverflow.com/a/13233194/1248889

Sostituisco il matcher toThrow di Jasmine con il seguente, che ti consente di abbinare la proprietà name dell'eccezione o la proprietà message. Per me questo rende i test più facili da scrivere e meno fragili, poiché posso fare quanto segue:

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

e quindi prova con quanto segue:

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

Questo mi consente di modificare il messaggio di eccezione in un secondo momento senza interrompere i test, quando l'importante è che abbia generato il tipo di eccezione previsto.

Questa è la sostituzione di toThrow che consente questo:

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

Come accennato in precedenza, una funzione deve essere passata in toThrowquanto è la funzione che stai descrivendo nel test: "Mi aspetto che questa funzione passi x"

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

Se usi Jasmine-Matchers puoi anche usare uno dei seguenti quando si adattano alla situazione;

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

o

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

So che è più codice ma puoi anche fare:

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

Per gli amanti del caffè

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

Per chiunque possa ancora affrontare questo problema, per me la soluzione pubblicata non ha funzionato e ha continuato a lanciare questo errore: in Error: Expected function to throw an exception. seguito ho capito che la funzione che mi aspettavo di lanciare un errore era una funzione asincrona e mi aspettavo la promessa di essere rifiutato e quindi gettare errore ed è quello che stavo facendo nel mio codice:

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

ed è quello che ho fatto nel mio test e ha funzionato:

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