tape-lite

index.js (5392B)

// SPDX-FileCopyrightText: 2023 Haelwenn (lanodan) Monnier <contact+tape-lite@hacktivis.me>
// SPDX-License-Identifier: MIT
'use strict';
const test   = require('node:test');
const assert = require('node:assert/strict');
function notOk(value, msg) { return assert.ok(!value, msg); };
// TODO: Handle message
function _error(err, msg) { return assert.ifError(err); };
var onFailure = [];
var tape_t = {
	// t.plan(n)
	"plan" : (n) => console.log("t.plan called with:", n),
	// t.end(err)
	"end" : (err) => console.log("t.end called with:", err),
	// t.teardown(cb) → after([fn][, options])
	"teardown" : test.after,
	// t.fail(msg)
	"fail" : assert.fail,
	// t.ok(value, msg) → assert.ok(value[, message])
	// Aliases: t.true(), t.assert()
	"ok": assert.ok,
	"true": assert.ok,
	"assert": assert.ok,
	// t.notOk(value, msg) → assert.ok(!value[, message])
	// Aliases: t.false(), t.notok()
	"notOk": notOk,
	"false": notOk,
	"notok": notOk,
	// t.error(err, msg) → assert.ifError(value)
	// Aliases: t.ifError(), t.ifErr(), t.iferror()
	"error": _error,
	"ifError": _error,
	"ifErr": _error,
	"iferror": _error,
	// t.equal(actual, expected, msg) → assert.equal(actual, expected[, message])
	// Aliases: t.equals(), t.isEqual(), t.strictEqual(), t.strictEquals(), t.is()
	"equal": assert.strictEqual,
	"equals": assert.strictEqual,
	"isEqual": assert.strictEqual,
	"strictEqual": assert.strictEqual,
	"strictEquals": assert.strictEqual,
	"is": assert.strictEqual,
	// t.notEqual(actual, expected, msg) → assert.notStrictEqual(actual, expected[, message])
	// Aliases: t.notEquals(), t.isNotEqual(), t.doesNotEqual(), t.isInequal(), t.notStrictEqual(), t.notStrictEquals(), t.isNot(), t.not()
	"notEqual": assert.notStrictEqual,
	"notEquals": assert.notStrictEqual,
	"doesNotEqual": assert.notStrictEqual,
	"isInequal": assert.notStrictEqual,
	"notStrictEqual": assert.notStrictEqual,
	"notStrictEquals": assert.notStrictEqual,
	"isNot": assert.notStrictEqual,
	"not": assert.notStrictEqual,
	// t.looseEqual(actual, expected, msg) → assert.Equal(actual, expected[, message])
	// Aliases: t.looseEquals()
	looseEqual: assert.Equal,
	looseEquals: assert.Equal,
	// t.notLooseEqual(actual, expected, msg) → assert.notEqual(actual, expected[, message])
	// Aliases: t.notLooseEquals()
	notLooseEqual: assert.notEqual,
	notLooseEquals: assert.notEqual,
	// t.deepEqual(actual, expected, msg) → assert.deepStrictEqual(actual, expected[, message])
	// Aliases: t.deepEquals(), t.isEquivalent(), t.same()
	deepEqual: assert.deepStrictEqual,
	deepEquals: assert.deepStrictEqual,
	isEquivalent: assert.deepStrictEqual,
	same: assert.deepStrictEqual,
	// t.notDeepEqual(actual, expected, msg) → assert.notDeepStrictEqual(actual, expected[, message])
	// Aliases: t.notDeepEquals, t.notEquivalent(), t.notDeeply(), t.notSame(), t.isNotDeepEqual(), t.isNotDeeply(), t.isNotEquivalent(), t.isInequivalent()
	notDeepEqual: assert.notDeepStrictEqual,
	notDeepEquals: assert.notDeepStrictEqual,
	notEquivalent: assert.notDeepStrictEqual,
	notDeeply: assert.notDeepStrictEqual,
	notSame: assert.notDeepStrictEqual,
	isNotDeepEqual: assert.notDeepStrictEqual,
	isNotDeeply: assert.notDeepStrictEqual,
	isNotEquivalent: assert.notDeepStrictEqual,
	isInequivalent: assert.notDeepStrictEqual,
	// t.deepLooseEqual(actual, expected, msg) → assert.deepEqual(actual, expected[, message])
	deepLooseEqual: assert.deepEqual,
	// t.notDeepLooseEqual(actual, expected, msg) → assert.notDeepEqual(actual, expected[, message])
	// Aliases: t.notLooseEqual(), t.notLooseEquals()
	notDeepLooseEqual: assert.notDeepEqual,
	notLooseEqual: assert.notDeepEqual,
	notLooseEquals: assert.notDeepEqual,
	// t.comment(message)
	comment: (msg) => console.log("t.comment called with:", msg),
	// t.match(string, regexp, message) → assert.match(string, regexp[, message])
	"match" : assert.match,
	// t.doesNotMatch(string, regexp, message) → assert.doesNotMatch(string, regexp[, message])
	doesNotMatch: assert.doesNotMatch,
	// npm:tap compatibility
	strictSame: assert.deepStrictEqual,
	// clang-format off
	// t.throws(fn, expected, msg) → assert.throws(fn[, error][, message])
	"throws": assert.throws,
	// clang-format on
	// t.doesNotThrow(fn, expected, msg)
};
function setup_context(node_t)
{
	var t = tape_t;
	// t.pass(msg) → context.skip([message])
	// technically not the same thing but close enough
	//"pass": t.skip,
	t.pass = node_t.skip;
	// t.skip(msg) → context.skip([message])
	t.pass = node_t.skip;
	// t.timeoutAfter(ms)
	return t;
};
// test([name], [opts], cb)
tape_t.test = function(name, opts, cb) {
	switch(arguments.length)
	{
	case 1:
		test((node_t) => {
			var t = setup_context(node_t);
			arguments[0](t)
		});
		break;
	case 2:
		test(arguments[0], (node_t) => {
			var t = setup_context(node_t);
			arguments[1](t)
		});
		break;
	case 3:
		test(arguments[0], arguments[1], (node_t) => {
			var t = setup_context(node_t);
			arguments[2](t)
		});
		break;
	default:
		abort();
	}
};
module.exports = tape_t.test;
// test.skip([name], [opts], cb)
// test.onFinish(fn)
module.exports.onFinish = test.after;
// test.onFailure(fn)
module.exports.onFailure = (fn) => {
	onFailure.push(fn);
	// TODO: Call each on event:fail
};
// var htest = test.createHarness()
// test.only([name], [opts], cb)
// var stream = test.createStream(opts)