Skip to content

Latest commit

 

History

History
111 lines (76 loc) · 2.93 KB

README.md

File metadata and controls

111 lines (76 loc) · 2.93 KB
Raw

austere-tester

A humble tool to aid with testing JavaScript code.

  • Works in Node.js and in browsers.
  • Runs synchronous and asynchronous tests with configurable timeouts, in series and in parallel.
  • Has first-class Promise support.
  • Works with any assertion library.
  • Provides test execution metrics.
  • No magic - no global variables, preserves tested functions context.
  • No bloat - zero dependencies, simple API, ~ 100 NCLOC.

Installation and usage

Requirements

The environment must provide a native or shimmed implementation of the following ES6 and ES5 features:

  • Promise
  • Object.assign
  • Array.prototype.find
  • Array.prototype.map

For native implementation, it translates to Node.js >= 4.0 and most modern browsers (excluding IE).

Apply your favourite shims to use the module in older environments.

Installation

$ npm install austere-tester --save-dev

To use in a browser, include ./index.js via the script tag - it will make AustereTester available in the global scope.

Alternatively, use Browserify or webpack or other CommonJS bundler.

Workflow

austere-tester is a lightweight utility that helps to run tests. It does not dictate how you should write and arrange them.

  1. Write down a set of functions that test your code. Make them throw an Error when test is failing - either with a plain throw new Error('Message'); or with any assertion library.
  2. Register those functions with austere-tester.
  3. Ask it to run registered functions.
  4. Check output for errors.

Examples

// ./examples/basic.js:

// Create an instance of the module:
var AustereTester = require('austere-tester');
var tester = new AustereTester();

// Register a test procedure:
tester.plan('basic test', function() {
  return 'passing';
});

// Run it:
tester.run('basic test');
$ node examples/basic
[austere-tester] run PASSED in 0 ms - basic test

In many cases you can run synchronous tests like the one shown above without using special tools.

Taming asynchronyous tests is a more complicated task, since you need to put extra efforts to catch errors, to handle timeouts, and often to perform operations in a strict order.

This is where austere-tester is most useful.

Async tests can be planned like this:

tester.plan('async with callback', function(finished) {
  setTimeout(finished, 100);
});

tester.plan('async with promise', function() {
  return new Promise(function(resolve, reject) {
    setTimeout(resolve, 100);
  });
});

When you need to run a set of tests:

// runs all planned tests one by one, FIFO
tester.runAll();

// runs all planned tests in parallel
tester.runAllInParallel();

For more examples demonstrating planning and running tests, please see ./examples/complex.js and API documentation.

API

Described here.

License

MIT