QUnit testing framework for nodejs.

http://qunitjs.com

http://github.com/jquery/qunit

Features

• cli
• testrunner api
• test coverage via jscoverage is removed, node-bunker have to be implemented #26
• tests inside of one testfile run synchronous, but every testfile runs parallel
• tests from each file run in its own spawned node process
• same API for client and server side code (original QUnit is used)
• the simplest API of the world, especially for asynchronous testing
• you can write tests in TDD or BDD style depending on your task and test type
• you can run the same tests in browser if there is no dependencies to node

Installation

npm i qunit

API

http://api.qunitjs.com

The only exception

// Separate tests into modules.
// Use `QUnit` namespace, because `module` is reserved
QUnit.module(name, lifecycle)

Usage

Command line

Read full cli api doc using "--help" or "-h":

$ qunit -h
$ qunit -c ./code.js -t ./tests.js

By default, code and dependencies are added to the global scope. To specify requiring them into a namespace object, prefix the path or module name with the variable name to be used for the namespace object, followed by a colon:

$ qunit -c code:./code.js -d utils:utilmodule -t ./time.js

via api

var testrunner = require("qunit");
Defaults:
{
// logging options
log: {
// log assertions overview
assertions: true,
// log expected and actual values for failed tests
errors: true,
// log tests overview
tests: true,
// log summary
summary: true,
// log global summary (all files)
globalSummary: true,
// log currently testing code file
testing: true
},
// run test coverage tool
coverage: false,
// define dependencies, which are required then before code
deps: null,
// define namespace your code will be attached to on global['your namespace']
namespace: null
}
// change any option for all tests globally
testrunner.options.optionName = value;
// or use setup function
testrunner.setup({
log: {
summary: true
}
});
// one code and tests file
testrunner.run({
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, callback);
// require code into a namespace object, rather than globally
testrunner.run({
code: {path: "/path/to/your/code.js", namespace: "code"},
tests: "/path/to/your/tests.js"
}, callback);
// one code and multiple tests file
testrunner.run({
code: "/path/to/your/code.js",
tests: ["/path/to/your/tests.js", "/path/to/your/tests1.js"]
}, callback);
// array of code and test files
testrunner.run([
{
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
},
{
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}
], callback);
// using testrunner callback
testrunner.run({
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, function(err, report) {
console.dir(report);
});
// specify dependency
testrunner.run({
deps: "/path/to/your/dependency.js",
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, callback);
// dependencies can be modules or files
testrunner.run({
deps: "modulename",
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, callback);
// dependencies can required into a namespace object
testrunner.run({
deps: {path: "utilmodule", namespace: "utils"},
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, callback);
// specify multiple dependencies
testrunner.run({
deps: ["/path/to/your/dependency1.js", "/path/to/your/dependency2.js"],
code: "/path/to/your/code.js",
tests: "/path/to/your/tests.js"
}, callback);

Writing tests

QUnit API and code which have to be tested are already loaded and attached to the global context.

Some tests examples

test("a basic test example", function (assert) {
ok(true, "this test is fine");
var value = "hello";
equal("hello", value, "We expect value to be hello");
});
QUnit.module("Module A");
test("first test within module", 1, function (assert) {
ok(true, "a dummy");
});
test("second test within module", 2, function (assert) {
ok(true, "dummy 1 of 2");
ok(true, "dummy 2 of 2");
});
QUnit.module("Module B", {
setup: function () {
// do some initial stuff before every test for this module
},
teardown: function () {
// do some stuff after every test for this module
}
});
test("some other test", function (assert) {
expect(2);
equal(true, false, "failing test");
equal(true, true, "passing test");
});
QUnit.module("Module C", {
setup: function() {
// setup a shared environment for each test
this.options = { test: 123 };
}
});
test("this test is using shared environment", 1, function (assert) {
deepEqual({ test: 123 }, this.options, "passing test");
});
test("this is an async test example", function (assert) {
expect(2);
stop();
setTimeout(function () {
ok(true, "finished async test");
strictEqual(true, true, "Strict equal assertion uses ===");
start();
}, 100);
});

Run tests

npm i
make test

Coverage

Jscoverage is removed due to a lot of installation problems and bad api, node-bunker is planned to use but not implemented yet.