javascript - test - Chai: esperando un error o no dependiendo de un parámetro

npm chai

Question

Esta pregunta ya tiene una respuesta aquí:

• Mocha / Chai espera.para.lo. no arrojar errores arrojados 6 respuestas

He estado intentando hacer un texto de una función que maneja los errores de una manera que, si es un error válido, se lanza, pero si no lo es, entonces no se arroja nada. El problema es que parece que no puedo configurar el parámetro mientras uso:

expect(handleError).to.throw(Error);

Lo ideal sería utilizar:

expect(handleError(validError)).to.throw(Error);

¿Hay alguna manera de lograr esta funcionalidad?

Código de la función:

function handleError (err) {
    if (err !== true) {
        switch (err) {
            case xxx:
            ...
        }
        throw "stop js execution";
    else {}
}

Y el código de la prueba (no funciona según lo previsto):

it("should stop Javascript execution if the parameter isnt /"true/"", function() {
    expect(handleError).to.be.a("function");
    expect(handleError(true)).to.not.throw(Error);
    expect(handleError("anything else")).to.throw(Error);
});

Answer 1

El problema es que usted está llamando a handleError y luego está pasando el resultado esperado. Si handleError lanza, espera que nunca se llame.

Debe aplazar la llamada handleError hasta que se llame a expect, para que espere pueda ver qué sucede cuando se llama a la función. Afortunadamente, esto es lo que espera quiere:

expect(function () { handleError(true); }).to.not.throw();
expect(function () { handleError("anything else") }).to.throw("stop js execution");

Si lee la documentation para el lanzamiento, verá que a la expectativa asociada se le debe pasar una función.

Answer 2

Envolver la llamada de función en un Lambda, como lo recomienda David Norman, es sin duda una buena manera de resolver este problema.

Sin embargo, puede agregar esto a sus utilidades de prueba, si está buscando una solución más legible. Esta función envuelve su función en un objeto con un método withArgs , que le permite escribir la misma declaración de una manera más legible. Idealmente esto sería construido en Chai.

var calling = function(func) {
  return {
    withArgs: function(/* arg1, arg2, ... */) {
      var args = Array.prototype.slice.call(arguments);
      return function() {
        func.apply(null, args);
      };
    }
  };
};

Entonces úsalo como:

expect(calling(handleError).withArgs(true)).to.not.throw();        
expect(calling(handleError).withArgs("anything else")).to.throw("stop js execution");

¡Se lee como inglés!

Answer 3

Me encontré con este mismo problema hoy y opté por otra solución que no se menciona aquí: aplicación de función parcial usando bind() :

expect(handleError.bind(null, true)).to.not.throw();
expect(handleError.bind(null, "anything else")).to.throw("stop js execution");

Esto tiene la ventaja de ser conciso, usar un JavaScript antiguo y simple, no requiere funciones adicionales e incluso puede proporcionar el valor de this si su función depende de ello.

Answer 4

Yo uso ES2015 con el preset babel stage-2, y si lo haces, también puedes usar esto.

Tomé la solución @ StephenM347 y la modifiqué un poco para ser más breve y MEJOR aún más legible:

let expectCalling = func => ({ withArgs: (...args) => expect(() => func(...args)) });

Uso

expectCalling(handleError).withArgs(true).to.not.throw();        
expectCalling(handleError).withArgs("anything else").to.throw("stop js execution");

Nota: si desea el mismo uso (y sigue usando expect() como está):

    let calling = func => ({ withArgs: (...args) => () => func(...args) });