tapzero

Zero dependency test framework

</summary> - 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