@substrate-system/tapzero

tapzero

Zero dependency test framework

A fork of raynos/tapzero

Contents

• Source code
• install
• Migrating from tape
• End automatically
• Plan
  • Callbacks + planning
    • set a different timeout value
• API
  • test(name, [fn])
  • test.only(name, fn)
  • test.plan(number, [timeout])
  • test.skip(name, [fn])
  • t.deepEqual (actual, expected, msg)
  • t.notDeepEqual (actual, expected, msg)
  • t.equal (actual, expected, msg)
  • t.notEqual (actual, expected, msg)
  • t.fail (msg)
  • t.ok (value, msg)
  • t.throws (fn, expected, message)
• Motivation
  • Zero dependencies
  • Small install size
• develop
  • Run the tests
  • Check type coverage
  • visual type report

Source code

The implementation is <250 loc, (<500 with comments) ( https://github.com/substrate-system/tapzero/blob/fork/index.js ) and very readable.

install

npm i -D @substrate-system/tapzero

Migrating from tape

import tape from 'tape'
// Tapzero exports an object with a test function property.
import { test } from '@substrate-system/tapzero'

tape('my test', (t) => {
  t.equal(2, 2, 'ok')
  t.end()
})

// Auto ending behavior on function completion
test('my test', (t) => {
  t.equal(2, 2, 'ok')
  // t.end() does not exist.
})

End automatically

Return a promise. The test will end when the promise resolves.

// tapzero "auto" ends async tests when the async function completes
tapzero('my cb test', async (t) => {
  await new Promise((resolve) => {
    t.equal(2, 2, 'ok')
    setTimeout(() => {
      // instead of calling t.end(), resolve a promise
      resolve()
    }, 10)
  })
})

Plan

Plan the number of assertions. The test will fail if it executes more or fewer than the planned number of assertions.

[!IMPORTANT]
If you use .plan, it must be called first, before executing any assertions.

tapzero('planning example', t => {
  // this test will fail if we execute more or fewer
  //   than planned assertions
  t.plan(2)
  t.ok('hello')
  t.equal(2, 2, 'two is two')
})

Callbacks + planning

Call .plan(), and the test will automatically wait until the right number of assertions have been made, or until the timeout (by default timeout is 5 seconds).

You can execute tests either in a callback function, or via promises + await.

[!NOTE]
The default timeout is 5 seconds.

import { test } from '@substrate-system/tapzero'

test('Plan', async t => {
  t.plan(3)

  setTimeout(() => {
    t.ok(true)
  }, 2000)  // default timeout is 5 seconds

  t.ok(true)
  await sleep(50)
  t.ok(true)
})

set a different timeout value

You can pass in a different timeout value to .plan, in milliseconds.

test('Set a longer timeout value', t => {
  t.plan(3, 10000)

  setTimeout(() => {
    t.ok(true)
  }, 6000)

  t.ok(true)
  t.ok(true)
})

API

No aliases, smaller API surface area

import { test } from '@substrate-system/tapzero'

test('example test name', async t => {
  // ...
})

tape('my test', (t) => {
  t.equals(2, 2)
  t.is(2, 2)
  t.isEqual(2, 2)
})

tapzero('my test', (t) => {
  // tapzero does not implement any aliases, very small surface area.
  t.equal(2, 2)
  t.equal(2, 2)
  t.equal(2, 2)
})

test(name, [fn])

Run a single named test case. The fn will be called with the t test object.

Tests run one at a time and complete when the fn completes. The fn can be async.

test.only(name, fn)

Like test(name, fn) except if you use .only this is the only test case that will run for the entire process, all other test cases using tape will be ignored.

test.plan(number, [timeout])

Plan the number of assertions. Takes a second argument, timeout, that is a number in milliseconds to wait for the test.

test.skip(name, [fn])

Creates a test case that will be skipped

t.deepEqual (actual, expected, msg)

Check that two objects have equal shapes.

t.notDeepEqual (actual, expected, msg)

Passes if the two given objects are not equal.

t.equal (actual, expected, msg)

Check that two given values are equal.

t.notEqual (actual, expected, msg)

Pass if the two values are not equal.

t.fail (msg)

Explicitly fail.

t.ok (value, msg)

Check that value is truthy.

t.throws (fn, expected, message)

Check that fn does throw an error.

Motivation

Small library, zero dependencies

Zero dependencies

$ package-size ./build/src/index.js zora baretest,assert qunit tape jasmine mocha

  package                      size       minified   gzipped
  ./build/src/index.js         8.97 KB    3.92 KB    1.53 KB
  zora@3.1.8                   32.44 KB   11.65 KB   4.08 KB
  baretest@1.0.0,assert@2.0.0  51.61 KB   16.48 KB   5.82 KB
  qunit@2.9.3                  195.83 KB  62.04 KB   20.38 KB
  tape@4.13.0                  304.71 KB  101.46 KB  28.8 KB
  jasmine@3.5.0                413.61 KB  145.2 KB   41.07 KB
  mocha@7.0.1                  811.55 KB  273.07 KB  91.61 KB

Small install size

	@substrate-system/tapzero	baretest	zora	pta	tape
pkg size
dep count

	Mocha	Ava	Jest	tap
pkg size
Min.js size
dep count

develop

Run the tests

npm test

Check type coverage

npm run coverage

visual type report

This will use the tool typescript-coverage-report, and open an HTML page in your default browser.

npm run report