¿Cómo escribir una prueba que espera que se arroje un error en Jasmine?

Estoy tratando de escribir una prueba para Jasmine Test Framework que espera un error. En este momento estoy usando una integración Jasmine Node.js de GitHub .

En mi módulo Node tengo el siguiente código:

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

Ahora trato de escribir una prueba que espera este error:

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

También probé Error()y algunas otras variantes y simplemente no puedo entender cómo hacerlo funcionar.

deberías pasar una función a la expect(...)llamada. El código que tienes aquí:

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

está intentando llamar realmente parser.parse(raw)en un intento de pasar el resultado a expect(...),

Intente usar una función anónima en su lugar:

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

Tu estas usando:

expect(fn).toThrow(e)

Pero si observa el comentario de la función (se espera que sea una cadena):

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

Supongo que probablemente deberías escribirlo así (usando lambda - función anónima):

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

Esto se confirma en el siguiente ejemplo:

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

Douglas Crockford recomienda encarecidamente este enfoque, en lugar de usar "throw new Error ()" (forma de creación de prototipos):

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

Una solución más elegante que crear una función anónima cuyo único propósito es envolver otra es usar la bindfunción es5 . La función de vinculación crea una nueva función que, cuando se llama, tiene su thispalabra clave establecida en el valor proporcionado, con una secuencia dada de argumentos que precede a cualquier proporcionada cuando se llama a la nueva función.

En vez de:

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

Considerar:

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

La sintaxis de enlace le permite probar funciones con diferentes thisvalores y, en mi opinión, hace que la prueba sea más legible. Ver también: https://stackoverflow.com/a/13233194/1248889

Reemplazo el emparejador toThrow de Jasmine con lo siguiente, que le permite coincidir con la propiedad del nombre de la excepción o su propiedad de mensaje. Para mí, esto hace que las pruebas sean más fáciles de escribir y menos frágiles, ya que puedo hacer lo siguiente:

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

y luego prueba con lo siguiente:

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

Esto me permite ajustar el mensaje de excepción más tarde sin romper las pruebas, cuando lo importante es que arrojó el tipo de excepción esperado.

Este es el reemplazo de toThrow que permite esto:

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

Como se mencionó anteriormente, es necesario pasar una función, toThrowya que es la función que está describiendo en su prueba: "Espero que esta función arroje x"

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

Si usa Jasmine-Matchers , también puede usar uno de los siguientes cuando se adapten a la situación;

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

Sé que es más código pero también puedes hacer:

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

Para los amantes del café

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

Para cualquiera que todavía pueda estar enfrentando este problema, para mí la solución publicada no funcionó y siguió arrojando este error: Error: Expected function to throw an exception. más tarde me di cuenta de que la función que esperaba lanzar un error era una función asincrónica y esperaba prometer ser rechazado y luego arrojar error y eso es lo que estaba haciendo en mi código:

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

y eso fue lo que hice en mi prueba y funcionó:

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