casette

Casette is a no-nonsense, no dependancy small test framework created to use in node 13 with ECM.

Installation

Install with npm globally:

$ npm install --global casette

or as a development dependency for your project:

$ npm install --save-dev casette

Getting started

$ npm install --save-dev casette
$ mkdir test

Next in your favourite editor, create test/test.js:

import { Casette as c, assert} from 'casette'

c.describe('Array', function() {
  c.describe('#indexOf()', function() {
    c.test('should return -1 when value is not present', function() {
      assert.equal([1,2,3].indexOf(4), -1)
    })
  })
})

Set up a test script in package.json:

"scripts": {
  "test": "mocha"
}

Then run tests with:

$ npm test


  test/test.mjs
    √ Array #indexOf() should return -1 when value is not present


  1 passing (3ms)

Assertions

Not only does casette allow you to use any assertion library of your own choosing, it also comes with it's own assertion library based on node's default assert with a few extra methods:

• assert.notOk(value, [message]): Assert value is not ok.
• assert.match(value, test, [message]): Check if value matches RegExp test.
• assert.notMatch(value, [message]): Check if value does not match RegExp test.
• assert.isFulfilled(promise, [message]): Assert the promise resolves.
• assert.isRejected(promise, [message]): Assert the promise gets rejects.

Asynchronous Code

Casette supports any type of asynchronous code testing. It can either be done by adding a parameter to the function (usually done) that gets called once the tests done but casette also supports promises.

Example of testing using done:

import { Casette as c, assert} from 'casette'

c.describe('User', function() {
  c.describe('#save()', function() {
    c.test('should save without error', function(done) {
      var user = new User('Luna')
      user.save(function(err) {
        if (err) done(err)
        else done()
      })
    })
  })
})

Alternatively, just use the done() callback directly (which will handle an error argument, if it exists):

import { Casette as c, assert} from 'casette'

c.describe('User', function() {
  c.describe('#save()', function() {
    c.test('should save without error', function(done) {
      var user = new User('Luna')
      user.save(done)
    })
  })
})

Or another alternative is to use promises and return a promise directly:

import { Casette as c, assert} from 'casette'

c.test('should complete this test', function(done) {
  return new Promise(function(resolve, reject) {
    reject(new Error('Uh oh, something went wrong'))
  }).then(done)
})

Which works well with async/await like so:

c.test('async test', async function() {
  let user = await User.find({ username: 'test' })
  assert.ok(user)
})

Api

c.test(message, func)

Queue up the func as a test with the specified message.

c.describe(message, func)

In case you wanna describe a bunch of tests, you can add them inside func and it will have the specified message prepended before every test:

import { Casette as c, assert} from 'casette'

function someFunction() { return true }

c.test('#someFunction()', function() {
  c.test('should always return true', function() {
    assert.strictEqual(someFunction(), true)
    assert.strictEqual(someFunction(), true)
    assert.strictEqual(someFunction(), true)
  }).skip()
})

will output:

    √ #someFunction() should always return true

c.test(...).skip()

You can skip tests easily by adding .skip() after the test like so:

c.test('Skip due to something being broken', function() {
  BrokenFunction()
}).skip()

c.test(...).timeout(dur)

Tests can take a long time. By default, casette will cancel a test if it takes longer than 2 seconds. You can however override this by calling the timeout function after the test with the specified duration in milliseconds like so:

c.test('This is a really long test', async function() {
  await DoSomethingForReallyLongTime()
}).timeout(5000) // 5 seconds