Use Node test runner

Author: wooorm

.github/workflows/main.yml

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

package.json

@@ -36,12 +36,11 @@
     "@types/unist": "^2.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.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.js

@@ -3,14 +3,15 @@
  * @typedef {import('hast').Element} Element
  */
 
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {isElement} from './index.js'
 
-test('isElement', (t) => {
-  t.equal(isElement(), false, 'should return `false` without node')
-  t.equal(isElement(null), false, 'should return `false` with `null`')
+test('isElement', async (t) => {
+  assert.equal(isElement(), false, 'should return `false` without node')
+  assert.equal(isElement(null), false, 'should return `false` with `null`')
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       isElement(null, true)
@@ -19,100 +20,94 @@ test('isElement', (t) => {
     'should throw when the second parameter is invalid'
   )
 
-  t.test('isElement(node)', (st) => {
-    st.equal(
+  await t.test('isElement(node)', () => {
+    assert.equal(
       isElement({type: 'text'}),
       false,
       'should return `false` when without `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element'}),
       false,
       'should return `false` when with invalid `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'div'}),
       true,
       'should return `true` when with valid `element`'
     )
-
-    st.end()
   })
 
-  t.test('isElement(node, tagName)', (st) => {
-    st.equal(
+  await t.test('isElement(node, tagName)', () => {
+    assert.equal(
       isElement({type: 'text'}, 'div'),
       false,
       'should return `false` when without `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element'}, 'div'),
       false,
       'should return `false` when with invalid `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'strong'}, 'div'),
       false,
       'should return `false` when without matching `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'div'}, 'div'),
       true,
       'should return `true` when with matching `element`'
     )
-
-    st.end()
   })
 
-  t.test('isElement(node, tagNames)', (st) => {
-    st.equal(
+  await t.test('isElement(node, tagNames)', () => {
+    assert.equal(
       isElement({type: 'text'}, ['div']),
       false,
       'should return `false` when without `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element'}, ['div']),
       false,
       'should return `false` when with invalid `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'strong'}, ['div']),
       false,
       'should return `false` when without matching `element`'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'div'}, ['div', 'strong', 'em']),
       true,
       'should return `true` when with matching `element` (#1)'
     )
 
-    st.equal(
+    assert.equal(
       isElement({type: 'element', tagName: 'em'}, ['div', 'strong', 'em']),
       true,
       'should return `true` when with matching `element` (#2)'
     )
-
-    st.end()
   })
 
-  t.test('isElement(node, test)', (st) => {
-    st.equal(
+  await t.test('isElement(node, test)', () => {
+    assert.equal(
       isElement({type: 'text'}, () => {
         throw new Error('!')
       }),
       false,
       'should not call `test` if the given node is not an element'
     )
 
-    st.equal(
+    assert.equal(
       isElement(
         {type: 'element', tagName: 'a', children: []},
         (node) => node.children.length === 0
@@ -121,7 +116,7 @@ test('isElement', (t) => {
       'should call `test` if the given node is a valid element (1)'
     )
 
-    st.equal(
+    assert.equal(
       isElement(
         {type: 'element', tagName: 'a', children: [{type: 'text'}]},
         (node) => node.children.length === 0
@@ -136,7 +131,7 @@ test('isElement', (t) => {
       children: [{type: 'element', tagName: 'a', children: []}]
     }
 
-    st.equal(
+    assert.equal(
       isElement(
         root.children[0],
         /**
@@ -146,10 +141,10 @@ test('isElement', (t) => {
          * @param {Parent|undefined|null} parent
          */
         function (node, index, parent) {
-          st.equal(node, root.children[0], 'should pass `node` to test')
-          st.equal(index, 0, 'should pass `index` to test')
-          st.equal(parent, root, 'should pass `parent` to test')
-          st.equal(this, ctx, 'should pass `context` to test')
+          assert.equal(node, root.children[0], 'should pass `node` to test')
+          assert.equal(index, 0, 'should pass `index` to test')
+          assert.equal(parent, root, 'should pass `parent` to test')
+          assert.equal(this, ctx, 'should pass `context` to test')
         },
         0,
         root,
@@ -159,23 +154,23 @@ test('isElement', (t) => {
       'should call `test` if the given node is a valid element (2)'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         isElement(root.children[0], () => {}, 0)
       },
       /Expected both parent and index/,
       'should throw if `index` is passed but not `parent`'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         isElement(root.children[0], () => {}, undefined, root)
       },
       /Expected both parent and index/,
       'should throw if `parent` is passed but not `index`'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         // @ts-expect-error runtime.
         isElement(root.children[0], () => {}, false)
@@ -184,23 +179,23 @@ test('isElement', (t) => {
       'should throw if `index` is not a number'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         isElement(root.children[0], () => {}, -1)
       },
       /Expected positive finite index for child node/,
       'should throw if `index` is negative'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         isElement(root.children[0], () => {}, Number.POSITIVE_INFINITY)
       },
       /Expected positive finite index for child node/,
       'should throw if `index` is infinity'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         // @ts-expect-error runtime.
         isElement(root.children[0], () => {}, 0, true)
@@ -209,17 +204,13 @@ test('isElement', (t) => {
       'should throw if `parent` is not a node'
     )
 
-    st.throws(
+    assert.throws(
       () => {
         // @ts-expect-error runtime.
         isElement(root.children[0], () => {}, 0, {type: 'root'})
       },
       /Expected parent node/,
       'should throw if `parent` is not a parent'
     )
-
-    st.end()
   })
-
-  t.end()
 })