testing failed promises with mocha's built-in promise support [duplicate]

Answer 1

Some more digging, and it appears the right way is to add an additional catch block, like so...

it.only("do something (negative test)", function (done) {

  var Q = require('q');

  function makePromise() {
    var deferred = Q.defer();
    deferred.reject(Error('fail'));
    return deferred.promise;
  };

  makePromise()
  .catch(function(e) {
    expect(e.message).to.equal('fail');
  })
  .then(done, done);

});

I'm interested in alternative ideas, or confirmation that this is fine the way it is.. thanks.

UPDATE:

Ben - I now grok what you were saying, esp. after the terse but helpful comment from Benjamin G.

To summarize:

When you pass in a done parameter, the test is expected to trigger it's 'done-ness' by calling the done() function;

When you don't pass in a done parameter, it normally only works for synchronous calls. However, if you return a promise, the mocha framework (mocha >1.18) will catch any failures that normally would have been swallowed (per the promises spec). Here is an updated version:

it.only("standalone neg test for mocha+promises", function () {

  var Q = require('q');

  function makePromise() {
    var deferred = Q.defer();
    deferred.reject(Error('fail'));
    return deferred.promise;
  };

  return makePromise()
  .catch(function(e) {
    expect(e.message).to.equal('fail');
  });

});

Answer 2

chai-as-promised provides a clean testing framework for Promises:

$ npm install chai-as-promised

In your test file:

var chai = require('chai');
var expect = chai.expect;
var chaiAsPromised = require("chai-as-promised");
chai.use(chaiAsPromised);

...

it('resolves as promised', function() {
    return expect(Promise.resolve('woof')).to.eventually.equal('woof');
});

it('rejects as promised', function() {
    return expect(Promise.reject('caw')).to.be.rejectedWith('caw');
});

This feels clean and intuitive. But you can accomplish something similar without chai-as-promised like this:

it('resolved as promised', function() {
    return Promise.resolve("woof")
        .then(function(m) { expect(m).to.equal('woof'); })
        .catch(function(m) { throw new Error('was not supposed to fail'); })
            ;
});

it('rejects as promised', function() {
    return Promise.reject("caw")
        .then(function(m) { throw new Error('was not supposed to succeed'); })
        .catch(function(m) { expect(m).to.equal('caw'); })
            ;
});

Answer 3

You can return a promise to signal that the test is asynchronous:

function something() {
  return Q.reject(Error('fail'));
}

it('should reject', function() {
  return something().then(function() {
    throw new Error('expected rejection');
  },
  function() {
    return 'passed :]';
  });
});