commit: b98b400ab7874bc2ae7eb9dce0e0580fcaeba176
parent 48cb1951146d12eba4652559f3b2db0f752bff09
Author: Haelwenn (lanodan) Monnier <contact@hacktivis.me>
Date: Sun, 21 Sep 2025 06:44:32 +0200
Create tape context instead of overwriting node:test
Fixes running tape-lite on NodeJS v22.13.1
Diffstat:
| M | index.js | 269 | +++++++++++++++++++++++++++++++++++++++++-------------------------------------- |
1 file changed, 140 insertions(+), 129 deletions(-)
diff --git a/index.js b/index.js
@@ -3,152 +3,161 @@
'use strict';
-const test = require('node:test');
+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 = [];
-// test([name], [opts], cb)
-module.exports = function(name, opts, cb) {
- function setup_cb(t)
- {
- const assert = require('node:assert/strict');
-
- // t.plan(n)
- t.plan = (n) => console.log("t.plan called with:", n);
-
- // t.end(err)
- t.end = (err) => console.log("t.end called with:", err);
-
- // t.teardown(cb) → after([fn][, options])
- t.teardown = test.after;
-
- // t.fail(msg)
- t.fail = assert.fail;
-
- // t.pass(msg) → context.skip([message])
- // technically not the same thing but close enough
- t.pass = t.skip;
-
- // t.timeoutAfter(ms)
-
- // t.skip(msg) → context.skip([message])
-
- // t.ok(value, msg) → assert.ok(value[, message])
- // Aliases: t.true(), t.assert()
- t.ok = assert.ok;
- t.true = t.ok;
- t.assert = t.ok;
-
- // t.notOk(value, msg) → assert.ok(!value[, message])
- // Aliases: t.false(), t.notok()
- t.notOk = notOk;
- t.false = t.notOk;
- t.notok = t.notOk;
-
- // t.error(err, msg) → assert.ifError(value)
- // Aliases: t.ifError(), t.ifErr(), t.iferror()
- t.error = (err, msg) => assert.ifError(err);
- t.ifError = t.error;
- t.ifErr = t.error;
- t.iferror = t.error;
-
- // t.equal(actual, expected, msg) → assert.equal(actual, expected[, message])
- // Aliases: t.equals(), t.isEqual(), t.strictEqual(), t.strictEquals(), t.is()
- t.equal = assert.strictEqual;
- t.equals = t.equal;
- t.isEqual = t.equal;
- t.strictEqual = t.equal;
- t.strictEquals = t.equal;
- t.is = t.equal;
-
- // 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()
- t.notEqual = assert.notStrictEqual;
- t.notEquals = t.notEqual;
- t.doesNotEqual = t.notEqual;
- t.isInequal = t.notEqual;
- t.notStrictEqual = t.notEqual;
- t.notStrictEquals = t.notEqual;
- t.isNot = t.notEqual;
- t.not = t.notEqual;
-
- // t.looseEqual(actual, expected, msg) → assert.Equal(actual, expected[, message])
- // Aliases: t.looseEquals()
- t.looseEqual = assert.Equal;
- t.looseEquals = t.looseEqual;
-
- // t.notLooseEqual(actual, expected, msg) → assert.notEqual(actual, expected[, message])
- // Aliases: t.notLooseEquals()
- t.notLooseEqual = assert.notEqual;
- t.notLooseEquals = t.notLooseEqual;
-
- // t.deepEqual(actual, expected, msg) → assert.deepStrictEqual(actual, expected[, message])
- // Aliases: t.deepEquals(), t.isEquivalent(), t.same()
- t.deepEqual = assert.deepStrictEqual;
- t.deepEquals = t.deepEqual;
- t.isEquivalent = t.deepEqual;
- t.same = t.deepEqual;
-
- // 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()
- t.notDeepEqual = assert.notDeepStrictEqual;
- t.notDeepEquals = t.notDeepEqual;
- t.notEquivalent = t.notDeepEqual;
- t.notDeeply = t.notDeepEqual;
- t.notSame = t.notDeepEqual;
- t.isNotDeepEqual = t.notDeepEqual;
- t.isNotDeeply = t.notDeepEqual;
- t.isNotEquivalent = t.notDeepEqual;
- t.isInequivalent = t.notDeepEqual;
-
- // t.deepLooseEqual(actual, expected, msg) → assert.deepEqual(actual, expected[, message])
- t.deepLooseEqual = assert.deepEqual;
-
- // t.notDeepLooseEqual(actual, expected, msg) → assert.notDeepEqual(actual, expected[, message])
- // Aliases: t.notLooseEqual(), t.notLooseEquals()
- t.notDeepLooseEqual = assert.notDeepEqual;
- t.notLooseEqual = t.notDeepLooseEqual;
- t.notLooseEquals = t.notDeepLooseEqual;
-
- // t.throws(fn, expected, msg) → assert.throws(fn[, error][, message])
- t.throws = assert.throws;
-
- // t.doesNotThrow(fn, expected, msg)
-
- // t.test(name, [opts], cb)
-
- // t.comment(message)
- t.comment = (msg) => console.log("t.comment called with:", msg);
-
- // t.match(string, regexp, message) → assert.match(string, regexp[, message])
- t.match = assert.match;
-
- // t.doesNotMatch(string, regexp, message) → assert.doesNotMatch(string, regexp[, message])
- t.doesNotMatch = assert.doesNotMatch;
-
- // npm:tap compatibility
- t.strictSame = t.same;
- };
+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((t) => {
- setup_cb(t);
+ test((node_t) => {
+ var t = setup_context(node_t);
arguments[0](t)
});
break;
case 2:
- test(arguments[0], (t) => {
- setup_cb(t);
+ test(arguments[0], (node_t) => {
+ var t = setup_context(node_t);
arguments[1](t)
});
break;
case 3:
- test(arguments[0], arguments[1], (t) => {
- setup_cb(t);
+ test(arguments[0], arguments[1], (node_t) => {
+ var t = setup_context(node_t);
arguments[2](t)
});
break;
@@ -157,6 +166,8 @@ module.exports = function(name, opts, cb) {
}
};
+module.exports = tape_t.test;
+
// test.skip([name], [opts], cb)
// test.onFinish(fn)
