Chai: expecting an error or not depending on a parameter

Question

I've been trying to do a text of a function that handles errors in a way that, if it is a valid error, it is thrown, but if it is not, then nothing is thrown. The problem is that i cant seem to set the parameter while using:

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

The ideal would be to use:

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

Is there any way to achieve this functionality?

code of the function:

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

And the code of the test (not working as intended):

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

score 46 · Accepted Answer · answered Oct 03 '13 at 02:58

46

The problem is that you are calling handleError, then passing the result to expect. If handleError throws, then expect never even gets called.

You need to defer calling handleError until expect is called, so that expect can see what happens when the function is called. Fortunately, this is what expect wants:

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

If you read the documentation for throw, you'll see that the associated expect should be passed a function.

answered Oct 03 '13 at 02:58

David Norman

19,396
12
64
54

how this can be achieved with 'should'? – matus Jul 11 '14 at 15:42
ok, I got it `should.Throw(function(){handleError("anything else");}, Error);` – matus Jul 11 '14 at 17:51
1

Do not type 'handleError().should.throw()'. It just '(function(){handlerError();}).should.throw()'. I didn't know this... It throw much time to trash. – NHK Aug 30 '14 at 12:47
2

I went with `expect(() => throwAnError(true)).to.throw()`; – Silviu-Marian Nov 20 '16 at 20:13
This makes more sense than the question that this was marked as a duplicate of – Jul 15 '17 at 14:07

score 7 · Answer 2 · answered Apr 24 '16 at 16:47

7

I ran into this same problem today and opted for another solution not mentioned here: partial function application using bind():

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

This has the benefit of being concise, using plain old JavaScript, requiring no extra functions and you can even provide the value of this should your function depend on it.

answered Apr 24 '16 at 16:47

Sven Schoenung

30,224
8
65
70

"requiring no extra functions" - that's not true. Under the hood "bind" method creates HOF (High Order Function). That said it's kinda same solution as mentioned above except ability to pass context more explicitly. – Skay Aug 29 '16 at 08:07
1

@Skay "no extra functions" just means you don't need to write a helper function [as this answer suggested](http://stackoverflow.com/a/34590246/5892036). `bind()` itself creates and returns a new function, of course. – Sven Schoenung Aug 29 '16 at 08:44

morsecoder · Answer 3 · 2016-01-13T17:28:44.217

Wrapping the function call in a Lambda, as recommended by David Norman, is certainly one good way to solve this problem.

You might add this to your testing utilities, though, if you're looking for a more readable solution. This function wraps your function in an object with a method withArgs, which allows you to write the same statement in a more readable way. Ideally this would be built into Chai.

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

Then use it like:

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

It reads like english!

What benefits brings your solution compared to built-in "bind" function? — Skay, Aug 29 '16 at 08:11

score 0 · Answer 4 · answered Jan 24 '16 at 19:26

I use ES2015 with babel stage-2 preset, and if you do so, you can use this as well.

I took @StephenM347 solution and modified it a little to be shorter an even more readable IMHO :

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

Usage :

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

Note: if you wish the same usage (and stick to use expect() as is) :

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

Chai: expecting an error or not depending on a parameter

4 Answers4

Linked