node-qunit


QUnit testing framework for Node.js

https://qunitjs.com

https://github.com/qunitjs/qunit

$3

- cli
- testrunner api
- test coverage via istanbul
- 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
- generators support

$3

``bash
$ npm i node-qunit
`

#### Package Name Up to 1.0.0

Up until version 1.0.0, this package was published under the name qunit. That
name is now used by the official QUnit package and CLI, and this package will be
published as node-qunit from version 1.0.0 onward.

Additionally, prior to 1.0.0, the node-qunit package was a different project
that was deprecated and now lives under the name qnit.

$3

https://api.qunitjs.com

#### The only exception

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

$3

#### Command line

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

`bash
$ 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:

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

#### via api

`javascript
var testrunner = require("node-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 coverage
coverage: true,

// log global coverage (all files)
globalCoverage: 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,

// max amount of ms child can be blocked, after that we assume running an infinite loop
maxBlockDuration: 2000
}
`

`javascript
// 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);
`

$3

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

Some tests examples

`javascript
test("a basic test example", function (assert) {
assert.ok(true, "this test is fine");
var value = "hello";
assert.equal("hello", value, "We expect value to be hello");
});

QUnit.module("Module A");

test("first test within module", function (assert) {
assert.ok(true, "a dummy");
});

test("second test within module", function (assert) {
assert.ok(true, "dummy 1 of 2");
assert.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) {
assert.expect(2);
assert.equal(true, false, "failing test");
assert.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", function (assert) {
assert.deepEqual({ test: 123 }, this.options, "passing test");
});

test("this is an async test example", function (assert) {
var done = assert.stop();
assert.expect(2);
setTimeout(function () {
assert.ok(true, "finished async test");
assert.strictEqual(true, true, "Strict equal assertion uses ===");
done();
}, 100);
});
`

$3

`javascript
test("my async test with generators", function* (assert) {
var data = yield asyncFn();
assert.equal(data, {a: 1}, 'generators work');
});
`

$3

`bash
$ npm it
`

$3

Code coverage via Istanbul.

To utilize, install istanbul and set option coverage: true or give a path where to store report coverage: {dir: "coverage/path"} or pass --cov parameter in the shell.

To specify the format of coverage report pass reporters array to the coverage options: coverage: {reporters: ['lcov', 'json']} (default)

Coverage calculations based on code and tests passed to node-qunit`.