使用Q promise的node.js项目的代码覆盖率

Question

I'm currently working on a node.js project. We use Q library for promises ( https://github.com/kriskowal/q ).

We are using mocha for tests and code-coverage provided with grunt tasks ( https://github.com/pghalliday/grunt-mocha-test ) which uses blanket.js for coverage and travis-cov reporter for asserting the coverage threshold.

Unfortunately the solution does not provide branches coverage for promises.

I have tried Intern ( http://theintern.io/ ), however basic example I wrote does not show correct branch coverage too.

Can you recommend a solution that would provide correct coverage for Q promises and works with grunt and node seamlessly?

Answer 1

Well, checking promises for coverage should not be too hard because JavaScript has absolutely sick aspect oriented programming abilities. While automated tools are offtopic here, let's go through what branches a promise has:

• First, the resolver function for the promise (either a promise constructor or a deferred) have their own branches.
• Each .then clause has 3 branches (one for success, one for failure, one for progress), if you want loop coverage too, you'd want each progress event when progress is attached to fire zero times, once and multiple times - although let's avoid progress for this question and in general since it's being deprecated and replaced in Q.
• The .done , .catch etc... are all private cases of .then . Aggregation methods like .all are private cases of the promise constructor since they create a new aggregate promise and their .then needs to be checked just as well.

So, let's see how we can do this, first - note that Q uses Promise.prototype.then internally for aggregation methods, so we can override it:

Promise.prototype._then = Promise.prototype.then;
var branches = 0;
Promise.prototype.then = function(fulfilled,rejected,progressed){
    branches += (fulfilled.call) +(rejected.call) + (progressed.call);
    var nFulfilled = function(){ branches--;return fulfilled.apply(this,arguments); };
    var nRejected = function(){ branches--; return rejected.apply(this,arguments); };
    //progression may happen more than once
    var nProgressed = function(){ 
        if(!nProgress.happened) {
            branches--;
            nProgress.happened = true;
        }
        return progressed.apply(this,arguments); 
    };
    nProgressed.happened = false;
    return this._then((fulfilled.call) ? nFulfilled : undefined,
                      (rejected.call) ? nRejected : undefined,
                      (progressed.call) ? nProgressed : undefined);
};

What we're doing here, is hooking on every .then and keeping track of handlers attached and handlers being called.

The branches variable will contain the number of code paths created with promises, and not actually executed. You can use more sophisticated logic here (for example - count rather than subtract) and I'd like to see someone pick up the glove and make a git repo from this :)