nyc-middleware

This package was inspired by the istanbul-middleware and most of the code is from this package. It's simply been ported to support NYC.

Connect middleware for getting code coverage numbers in functional tests for nodejs apps using istanbul version 2.

Run the sample app at test/app to get a feel for how this works. Server-side code coverage

This involves:

• hooking require() in the server process
• exposing coverage information on special endpoints (e.g. /coverage)
• allowing reset of coverage numbers to ensure clean slate
• allowing users to download coverage reports after tests have run

var im = require('nyc-middleware'),
    isCoverageEnabled = (process.env.COVERAGE == "true"); // or a mechanism of your choice

//before your code is require()-ed, hook the loader for coverage
if (isCoverageEnabled) {
    console.log('Hook loader for coverage - ensure this is not production!');
    im.hookLoader(__dirname);
        // cover all files except under node_modules
        // see API for other options
}

// now require the rest of your code
var stuff = require('./lib'),
    express = require('express'),
    app = express();

// set up basic middleware
// ...

// add the coverage handler
if (isCoverageEnabled) {
    //enable coverage endpoints under /coverage
    app.use('/coverage', im.createHandler());
}

//add your router and other endpoints
//...

app.listen(80);

The above snippet adds the following endpoints to your app under /coverage

Client-side coverage

This involves:

• Delivering instrumented code instead of the original Javascript to the browser
• Having your tests post the coverage information to the server (see POST /client endpoint above) using the window.__coverage__ object. You need to figure out how to do this using your favorite test runner.
• Aggregating the client and server coverage numbers. This is automatically done for you by the server-side middleware.

var path = require('path'),
    im = require('nyc-middleware');

// do the server side stuff as described above

// add a client handler at the appropriate place
// (before your static handler, for example)
// all JS files under here will be sent instrumented to the browser
// see API below for additional options (e.g. ignoring framework code)
app.use(im.createClientHandler(__dirname));

// however, it will only reliably work for simple cases
// such as absolute URLs to the JS.
// you still need to post the coverage numbers to the
//server from your browser tests

You can write your own custom middleware and completely ignore this library's client handler. As in:

app.use(function (req, res, next) {
    if (isJSRequiringCoverage(req)) {
        var file = getFilePath(req), //translate request to file name to be delivered
            code = readTheCodeFromFile(file), //use async for a real implementation
            instrumenter = im.getInstrumenter();
        res.send(instrumenter.instrumentSync(code, file));
            //exception handling omitted for brevity
    } else {
        next();
    }
});

API

nycMiddleware.hookLoader(rootOrMatcher, instrumenterOpts)

hooks require for coverage using istanbul.

rootOrMatcher can be:

• a string in which case it is assumed to be the root under which you want to cover all files except those under node_modules
• a function in which case it is assumed to be a match function with signature fn(filePath) that should return true when the supplied filePath should be covered and false otherwise

instrumenterOpts is an optional object with additional options to be passed to the istanbul instrumenter. See the API docs in istanbul for more information. In addition, options can also contain the postLoadHook key that is passed to istanbul.hook.hookRequire()

nycMiddleware.createHandler(opts)

returns connect middleware that exposes additional endpoints for coverage. Endpoints exposed are documented in the summary.

opts is optional and currently only supports one flag.

• resetOnGet - boolean to allow resets of coverage to baseline numbers using GET in addition to POST

nycMiddleware.createClientHandler(root, opts)

returns connect middleware similar to the static middleware to return instrumented JS to the client. The default behavior of the middleware is to intercept all GET requests to Javascript files and return the instrumented version by deriving the path of the file from the URL, instrumenting the code and sending the instrumented version in the response.

opts is an optional object with the following supported keys:

• matcher - a function of the form fn(request) that returns true if instrumentation is required and false otherwise.
• pathTransformer - a function of the form fn(request) that inspects the request URL and returns the physical path to the JS file on the filesystem.

An example of a matcher function could be:

function ignoreFrameworks(req) {
    var parsed = require('url').parse(req.url);
    return parsed.pathname && parsed.pathname.match(/\.js$/) && !parsed.pathname.match(/jquery/);
}

For all other cases where the client handler provided by this library is not good enough, just write your own middleware as documented in the summary.

nycMiddleware.getInstrumenter()

returns the instrumenter object that is created as a side-effect of the hookLoader call. Useful for custom client-side instrumentation to ensure that the instrumentation is done with the same options for all code.