Javascript test frameworks

JS (Node) Test Frameworks

Assert

  • Built into node.js
assert.fail(actual, expected, message, operator)
assert.ok(value, [message])
assert.equal(actual, expected, [message])
assert.doesNotThrow(block, [error], [message])
assert.ifError(value)

Mocha

  • browser support
  • test coverage reporting
  • simple async support
  • times tests & highlights slow tests
  • global variable leak reporting
  • before, after, before each, after each hooks
  • use any assertion library you want
  • run tests matching regex

Synchronous

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

Async

describe('User', function(){
  describe('#save()', function(){
    it('should save without error', function(done){
      var user = new User('Luna');
      user.save(function(err){
        if (err) throw err;
        done();
      });
    })
  })
})

Expresso

  • By TJ Holowaychuk (author of Express web framework)
  • async support
  • test coverage support using node-jscoverage
assert.isNull(null);
assert.isNotNull(false);
assert.isDefined(false);
assert.isUndefined(undefined);
assert.length('foo', 3);
assert.includes([1,2,3], 3);

Define tests by exporting a function

exports['test String#length'] = function(){
    assert.equal(6, 'foobar'.length);
};

For large numbers of tests you can export a “suite”

module.exports = {
    'test String#length': function(beforeExit, assert) {
      assert.equal(6, 'foobar'.length);
    }
};

Async exports

setTimeout(function() {
    exports['test async exports'] = function(){
        assert.ok('wahoo');
    };
}, 100);

Nodeunit

  • Runs in browser or node
  • async support
  • setup & teardown functions
  • flexible reporters HTML & XUnit style output
  • allows use of mocks and stubs
exports.testSomething = function(test){
    test.expect(1);
    test.ok(true, "this assertion should pass");
    test.done();
};

exports.testSomethingElse = function(test){
    test.ok(false, "this assertion should fail");
    test.done();
};

Jasmine

  • BDD Framework
  • can be run in browser, or node
  • Ruby Gem for rails testing
  • From Pivotal Labs (makers of Pivotal Tracker)
describe("Jasmine", function() {
  it("makes testing JavaScript awesome!", function() {
    expect(yourCode).toBeLotsBetter();
  });
});

Vows

  • async BDD framework for node.js
  • executes tests in parallel
  • executes tests sequentially when there are dependencies
  • emphasis on speed of execution, clarity, and user experience
var vows = require('vows'),
    assert = require('assert');

// Create a Test Suite
vows.describe('Division by Zero').addBatch({
    'when dividing a number by zero': {
        topic: function () { return 42 / 0 },

        'we get Infinity': function (topic) {
            assert.equal (topic, Infinity);
        }
    },
    'but when dividing zero by zero': {
        topic: function () { return 0 / 0 },

        'we get a value which': {
            'is not a number': function (topic) {
                assert.isNaN (topic);
            },
            'is not equal to itself': function (topic) {
                assert.notEqual (topic, topic);
            }
        }
    }
}).run(); // Run it

Kyuri

  • A node.js cucumber implementation
  • a few extra asynchronous keywords.
  • supports 160+ languages
  • exports to VowsJS stub

Whiskey

  • From Rackspace
  • text, html, json reporters (no xunit?)
  • support for hooking up the coverage for services started with the process runner
  • support for aggregating code coverage reports
  • code coverage
  • test isolation — each test runs in a separate process
  • needs unix sockets?
  • process runner — keeps track of integration test dependencies via json config file

should
Assertion framework

</pre>
var user = {
    name: 'tj'
  , pets: ['tobi', 'loki', 'jane', 'bandit']
};

user.should.have.property('name', 'tj');
user.should.have.property('pets').with.lengthOf(4);

someAsyncTask(foo, function(err, result){
  should.not.exist(err);
  should.exist(result);
  result.bar.should.equal(foo);
});

Gently
for mocking

See also this list:
https://github.com/joyent/node/wiki/modules#testing

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s