Use Node test runner

Author: wooorm

.github/workflows/main.yml

@@ -17,5 +17,5 @@ jobs:
     strategy:
       matrix:
         node:
-          - lts/fermium
+          - lts/gallium
           - node

package.json

@@ -40,14 +40,13 @@
   "devDependencies": {
     "@types/lodash": "^4.0.0",
     "@types/mdast": "^3.0.0",
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "fast-check": "^3.0.0",
     "lodash": "^4.0.0",
     "prettier": "^2.0.0",
     "remark-cli": "^11.0.0",
     "remark-preset-wooorm": "^9.0.0",
-    "tape": "^5.0.0",
     "tsd": "^0.25.0",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",

test/main.js

@@ -3,14 +3,15 @@
  * @typedef {import('unist').Parent} Parent
  */
 
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {is} from '../index.js'
 
-test('unist-util-is', (t) => {
+test('is', async (t) => {
   const node = {type: 'strong'}
   const parent = {type: 'paragraph', children: []}
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       is(null, false)
@@ -19,23 +20,23 @@ test('unist-util-is', (t) => {
     'should throw when `test` is invalid'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       is(node, null, -1, parent)
     },
     /Expected positive finite index/,
     'should throw when `index` is invalid (#1)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       is(node, null, Number.POSITIVE_INFINITY, parent)
     },
     /Expected positive finite index/,
     'should throw when `index` is invalid (#2)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       is(node, null, false, parent)
@@ -44,7 +45,7 @@ test('unist-util-is', (t) => {
     'should throw when `index` is invalid (#3)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       is(node, null, 0, {})
@@ -53,7 +54,7 @@ test('unist-util-is', (t) => {
     'should throw when `parent` is invalid (#1)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       is(node, null, 0, {type: 'paragraph'})
@@ -62,7 +63,7 @@ test('unist-util-is', (t) => {
     'should throw when `parent` is invalid (#2)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error: both `index` and `parent` are needed.
       is(node, null, 0)
@@ -71,27 +72,31 @@ test('unist-util-is', (t) => {
     'should throw `parent` xor `index` are given (#1)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error: both `index` and `parent` are needed.
       is(node, null, null, parent)
     },
     /Expected both parent and index/,
     'should throw `parent` xor `index` are given (#2)'
   )
-  t.notok(is(), 'should not fail without node')
-  t.ok(is(node), 'should check if given a node (#1)')
-  t.notok(is({children: []}, null), 'should check if given a node (#2)')
+  assert.ok(!is(), 'should not fail without node')
+  assert.ok(is(node), 'should check if given a node (#1)')
+  assert.ok(!is({children: []}, null), 'should check if given a node (#2)')
 
-  t.ok(is(node, 'strong'), 'should match types (#1)')
-  t.notok(is(node, 'emphasis'), 'should match types (#2)')
+  assert.ok(is(node, 'strong'), 'should match types (#1)')
+  assert.ok(!is(node, 'emphasis'), 'should match types (#2)')
 
-  t.ok(is(node, node), 'should match partially (#1)')
-  t.ok(is(node, {type: 'strong'}), 'should match partially (#2)')
-  t.ok(is(parent, {type: 'paragraph'}), 'should match partially (#3)')
-  t.notok(is(node, {type: 'paragraph'}), 'should match partially (#4)')
+  assert.ok(is(node, node), 'should match partially (#1)')
+  assert.ok(is(node, {type: 'strong'}), 'should match partially (#2)')
+  assert.ok(is(parent, {type: 'paragraph'}), 'should match partially (#3)')
+  assert.ok(!is(node, {type: 'paragraph'}), 'should match partially (#4)')
+
+  await t.test('should accept a test', () => {
+    assert.ok(!is(node, test))
+    assert.ok(!is(node, test, 0, parent))
+    assert.ok(is(node, test, 5, parent))
 
-  t.test('should accept a test', (t) => {
     /**
      * @param {unknown} _
      * @param {number | null | undefined} n
@@ -100,18 +105,14 @@ test('unist-util-is', (t) => {
     function test(_, n) {
       return n === 5
     }
-
-    t.notok(is(node, test))
-    t.notok(is(node, test, 0, parent))
-    t.ok(is(node, test, 5, parent))
-
-    t.end()
   })
 
-  t.test('should call test', (t) => {
+  await t.test('should call test', () => {
     const context = {foo: 'bar'}
+    let calls = 0
 
-    t.plan(4)
+    is(node, test, 5, parent, context)
+    assert.equal(calls, 1)
 
     /**
      * @this {context}
@@ -120,24 +121,23 @@ test('unist-util-is', (t) => {
      * @param {Parent | null | undefined} c
      */
     function test(a, b, c) {
-      t.equal(this, context)
-      t.equal(a, node)
-      t.equal(b, 5)
-      t.equal(c, parent)
+      assert.equal(this, context)
+      assert.equal(a, node)
+      assert.equal(b, 5)
+      assert.equal(c, parent)
+      calls++
     }
-
-    is(node, test, 5, parent, context)
   })
 
-  t.ok(is(node, ['strong', 'emphasis']), 'should match arrays (#1)')
-  t.notok(is(node, ['b', 'i']), 'should match arrays (#2)')
+  assert.ok(is(node, ['strong', 'emphasis']), 'should match arrays (#1)')
+  assert.ok(!is(node, ['b', 'i']), 'should match arrays (#2)')
 
-  t.test('should match arrays (#3)', (t) => {
+  await t.test('should match arrays (#3)', () => {
     const context = {foo: 'bar'}
+    let calls = 0
 
-    t.plan(5)
-
-    t.ok(is(node, [test, 'strong'], 5, parent, context))
+    assert.ok(is(node, [test, 'strong'], 5, parent, context))
+    assert.equal(calls, 1)
 
     /**
      * @this {context}
@@ -147,13 +147,12 @@ test('unist-util-is', (t) => {
      * @returns {boolean}
      */
     function test(a, b, c) {
-      t.equal(this, context)
-      t.equal(a, node)
-      t.equal(b, 5)
-      t.equal(c, parent)
+      assert.equal(this, context)
+      assert.equal(a, node)
+      assert.equal(b, 5)
+      assert.equal(c, parent)
+      calls++
       return false
     }
   })
-
-  t.end()
 })

test/property.js

@@ -1,17 +1,13 @@
-/**
- * @typedef {import('unist').Node} Node
- */
-
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import fc from 'fast-check'
 import lodash from 'lodash'
 import {is} from '../index.js'
 
 const {isObject, isPlainObject, pick, cloneDeep} = lodash
 
-test('unist-util-is properties', (t) => {
-  t.plan(4)
-  t.doesNotThrow(
+test('properties', () => {
+  assert.doesNotThrow(
     () =>
       fc.assert(
         // @ts-expect-error: fine.
@@ -22,7 +18,7 @@ test('unist-util-is properties', (t) => {
     'should see any object w/ a non-empty `type` as a node'
   )
 
-  t.doesNotThrow(
+  assert.doesNotThrow(
     () =>
       fc.assert(
         fc.property(
@@ -37,7 +33,7 @@ test('unist-util-is properties', (t) => {
     'should see any object w/o a `type` as a non-node'
   )
 
-  t.doesNotThrow(
+  assert.doesNotThrow(
     () =>
       fc.assert(
         // @ts-expect-error: fine.
@@ -48,7 +44,7 @@ test('unist-util-is properties', (t) => {
     'should match types'
   )
 
-  t.doesNotThrow(
+  assert.doesNotThrow(
     () =>
       fc.assert(
         fc.property(