highkick

Asynchronous, no-style, super simple testing tool.

HighKick is a small testing framework that I like.

$ npm install highkick

Overview

It enables ChaiJS' assert and expect modules by default.

BDD:

describe('Array', function(){
  describe('#indexOf()', function(){
    it('should return -1 when the value is not present', function(){
      assert.equal(-1, [1,2,3].indexOf(5));
      expect([1,2,3].indexOf(0).to.be(5));
    })
  })
})

CommonJS:

 
exports.init = function init(optionscallback){
    startWebServer(callback);
}
 
exports.testFoo = function testFoo(callback){
    get('http://localhost/api/foo', function(errorresponse){
        if(error){
            callback(error);
            return;
        }
        
        assert.equal(response.foo, 'foo')
        
        callback();
    });
}
 
exports.end = function end(callback){
    stopWebServer(callback);
}
 

First Steps

HighKick takes a module and executes the functions that have a name starting with "test". A simple test module would look like this;

 
var assert = require('assert');
 
exports.testFoo = function(callback){
    try {
        assert.something();
        callback();
    } catch (error) {
        callback(error);
    }
}
 
exports.testBar = function(callback){
    setTimeout(callback, 100);
}
 

Below command will run the all tests defined in tests.js;

$ highkick tests.js

To specify the tests that needs to run;

$ kick=foo highkick tests.js

se comma for separating multiple test names, and '*' for running all tests.

An init function is called before the execution of the tests in a module for once. Init functions take an options object from HighKick and are able to produce the first parameters of test functions as shown in the example below;

CommonJS:

exports.before = function before(optionscallback){
    callback( undefined, +(new Date), Math.PI );
}
 
exports.testFoo = function(timestamppicallback){
    ...
}

Use beforeEach to define a function to be called before each test.

 
function beforeEach(callback){
    callback( undefined, +(new Date));
}
 
exports.testFoo = function(nowcallback){
    ...
}
 

Similar to the init functions, what a beforeEach function produces is passed to test functions. The key difference is, beforeEach functions take parameters from init functions, too.

exports.init = function(optionscallback){
    callback(undefined, 'hello');
}
 
exports.beforeEach = function(hellocallback){
    callback(undefined, 'world';
}
 
exports.testFoo = function(helloworldcallback){
    ...
}

An afterEach function is called after each test, regardless of results.

exports.beforeEach = function(callback){
    callback(undefined, new ChildProcess);
}
 
exports.testFoo = function(processcallback){
    ...
}
 
exports.afterEach = function(processcallback){
    process.terminate();
    callback();
}

Unlikely to afterEach, an end function is called after all tests are done.

exports.after = function(callback){
    callback(undefined, new ChildProcess);
}
 
exports.testFoo = function(processcallback){
    ...
}
 
exports.end = function(processcallback){
    process.terminate();
    callback();
}

HighKick provides a very minimalistic concept of nested tests;

exports.testFoobar = highkick('./foobar');

You can use comma for separating multiple test names and pass '*' for enabling output for child tests.

In the case a custom callback is needed for getting a summary of testsuite:

highkick('./tests', function(error, result){
    if(error){
        logging.error('Ran %d tests, %d failed', result.len, result.fail);
        logging.error(error);
    }
 
    logging.info('Ran %d tests successfully, without any error.', result.len);
});