Mini webpack-driven testing library.

index.js

const { runTest } = require('./t')

let testCache = {}

const ctxId = runDirtyTests()

module.hot.accept(ctxId, runDirtyTests)
module.hot.accept()
module.hot.dispose(() => { testCache = {} })

function runDirtyTests() {
  clearScreen()
  const ctx = require.context('.', false, /\.tests.js$/)
  for (const key of ctx.keys()) {
    const test = ctx(key)
    if (testCache[key] !== test) {
      testCache[key] = test
      runTest(key, test).then(result => console.dir(result, { depth: null }))
    }
  }
  return ctx.id
}

function clearScreen() {
  console.log('\x1Bc')
}

some.tests.js

module.exports = async t => {
  t.deepEqual('a', 'a')
  await sleep(1000)
  t.notEqual(1, 2)
  
  t('subtest', async t => {
    t.equal(1, 1)
    t.deepEqual(1, 1)
    await sleep(1000)
    t.equal('a', 'a')
    t('sub sub test', t => t.equal('sub', 'sub'))
  })
}

function sleep(ms) {
  return new Promise(ok => setTimeout(ok, ms))
}

t.js

import assert, { AssertionError } from 'assert'

export async function runTest(name, test) {
  const t = buildTester()
  t.__test = { name: name, assertions: [], subtests: [] }
  try {
    t.__test.result = { tag: 'ok', value: await test(t) }
  } catch (e) {
    t.__test.result = { tag: 'error', error: e }
  }
  t.__test.subtests = await Promise.all(t.__test.subtests)
  return t.__test
}

function buildTester() {
  const t = (name, test) => t.__test.subtests.push(runTest(name, test))
  return assertProxy(t)
}

function assertProxy(t) {
  return new Proxy(t, {
    get(target, name) {
      if (name in target) {
        return target[name]
      } else {
        return (...args) => {
          let assertion = { assertion: [name, ...args] }
          try { assert[name](...args) }
          catch (e) {
            if (e instanceof AssertionError) assertion.error = e
            else throw e
          }
          t.__test.assertions.push(assertion)
        }
      }
    }
  })
}