Using expect(...).to.throw(...) with custom assertion function

I would like to be able to run more detailed assertions against a thrown exception than what currently seems possible. It would be awesome if expect(...).to.throw(...) supported something like the following pattern:

expect(function() {
  someFunctionThatThrows();
}).to.throw(function(err) {
  expect(err.toString()).to.equal('Error: something is wrong here');
  expect(err.actual).to.not.exist;
  expect(err.expected).to.not.exist;
});

I currently have this implemented in a local helper, but I think that supporting this might make sense in chai itself:

Assertion.overwriteMethod('throw', function (_super) {
  return function(fn) {
    if (typeof fn === 'function') {
      var obj = this._obj;

      try {
        obj();
      } catch (err) {
        return fn(err);
      }

      throw new chai.AssertionError('expected [Function] to throw an exception');

    } else {
      _super.apply(this, arguments);
    }
  };
});

Note that this doesn’t support using it with .not and I’m not sure if that would actually make sense. That case should probably be handled though and fail if the 'negate' flag is encountered.

[keithamus]

@Turbo87 There’s a few solutions here, let me go through them:

If you want to assert on all of the properties for equality, .deep.equal will work:

expect(functionThatThrows).to.throw(ErrorConstructor, 'a message')
  .that.deep.equals({
    'firstProp': 'foo',
    'secondProp': 'bar',
  });

If you want to assert on some of the properties for equality, .members will work:

expect(functionThatThrows).to.throw(ErrorConstructor, 'a message')
  .which.has.members({
    'firstProp': 'foo',
    'secondProp': 'bar',
  });

However, if you want to assert some semantics over individual properties, we don’t have a way to do that just yet. You could use satisfy for now:

expect(functionThatThrows).to.throw(ErrorConstructor, 'a message')
  .that.satisfies(function (error) {
    return typeof error.firstProp === 'string' && typeof error.secondProp === 'string';
  });

Alternatively, you can subscribe to issue https://github.com/chaijs/chai/issues/644 - which is working out how to implement a matcher API for this kind of thing.

Hopefully that gives you some ideas to work with @Turbo87. Let us know if that’s helpful, or if you want to discuss things further 😄

[RahmanM]

Ok, this error message was very confusing. For anyone else who might be having the same issue the solution was this:

expect(()=> calc.divide(2,0)).to.throw('Divide by zero is not permitted.');

Instead of:

expect(()=> calc.divide(2,0)).to.throw(new Error('Divide by zero is not permitted.'));