tapsoneer
v0.1.0
Published
Parallel testing framework, emitting a tapson stream
Downloads
4
Readme
tapsoneer
A simple Node.js/io.js interface to the tapson test protocol, version 1.0.0.
Tests are planned, then run asynchronously. If some of your tests depend on each other, you can specify how.
Exports a readable tapson protocol stream.
Tutorial
// Instantiate
var taps = require("tapsoneer")();
// Create 2 tests that finish in 0 - 1 seconds
var test1 = taps.plan("this runs first", function(cb) {
setTimeout(function() { cb(null, "first ok") }, Math.random() * 1000);
});
var test2 = taps.plan("this runs second", function(cb) {
setTimeout(function() { cb(null, "second ok") }, Math.random() * 1000);
});
// Tell tapsoneer we're done with planning tests
taps.done();
// Run the tests in parallel
test1();
test2();
// Read the output data stream
taps.out.on("data", function(d) { console.log(d); });
With the above, tapsoneer runs both tests in parallel. You can expect output that looks like—
{"id":"5a10fa17-1783-4b72-afa5-5cab41209dae","expected":"this runs first"}
{"id":"68cb2ae4-f769-4f86-82d9-a15fdab4180a","expected":"this runs second"}
{"id":"4f4ac792-f37f-4dc3-a97d-5004e05ca669","ok":true,"actual":"second ok"}
{"id":"4b157358-603f-49c3-aec5-a0498ff89447","ok":true,"actual":"first ok"}
Exported things
var tests = tapsoneer([options])
Creates a new tapsoneer test set, ready and waiting for tests.
By default, the emitted stream outputs Node Buffers. If you want a stream of
objects instead, pass an options object with { objectMode : true }
.
var test = tests.plan([description], testFunction)
Plans a new test with an optional description and a function that runs it. Returns a function that you can call to immediately run the test.
The test
will be passed a callback function as its only argument, which it
should call once it is finished. As is the usual Node.js practice, if there's
a failure, pass an Error
object or String
error message as the first
parameter. If it succeeded, pass null
as the first parameter and an optional
String describing the success as the second.
test([callback])
Runs the given test immediately. Its results will be on the output stream as soon as the test completes.
You can optionally pass it a callback
argument, to be notified when the test
finishes. This is handy if some of your tests depend on other tests, and means
you can use async.js to do stuff like—
var databaseConnection = null;
var testSetupDatabase = tests.plan("database sets up", function(cb) {
// Do whatever you need to set up the database, and call `cb`.
});
var testQuery = tests.plan("query some values", function(cb) {
// Use the `databaseConnection` to do stuff and call `cb`.
});
tests.done();
async.series([ testSetupDatabase, testQuery ]);
—to ensure they run sequentially. If you have a tangly mess of dependencies,
async.auto
is your friend.
If you want to run a test immediately after you plan it because it has no dependencies on anything, that's fine too. It'll run in parallel with other tests:
tests.plan("this runs right away", function(cb) { cb(null, "no problemo") })();
If you want to pass data between tests (some stuff from a database, say), just
call your test function's result callback with that data as additional
arguments. They'll be prepended to the test callback's arguments in a way
that's compatible with async.waterfall
:
var queryDatabase = tests.plan("database opens", function(cb) {
db.query("some-query", function(e, data) {
if (e) {
cb(e); // fail
}
else {
cb(null, "database ok", data);
}
});
});
var checkData = tests.plan("data looks fine", function(data, cb) {
if (data == "correct value") {
cb(null, "yep");
} else {
cb("Got bad data: " + data); // fail
}
}
tests.done();
async.waterfall([ queryDatabase, checkData ]);
tests.out
This is a stream containing tapson. All test plans and test results are emitted from it as they happen. The stream finishes when all the tests finish.
If you want it on stdout
, just do tests.out.pipe(process.stdout)
.
License
ISC.