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

@@ -44,12 +44,11 @@
     "unist-util-visit-parents": "^5.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",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",
     "unist-builder": "^3.0.0",

test.js

@@ -1,46 +1,38 @@
 /**
  * @typedef {import('unist').Node} Node
  * @typedef {import('unist').Literal<string>} Literal
- * @typedef {import('unist').Parent} Parent
- *
- * @typedef {string} Type
- * @typedef {Record<string, unknown>} Props
- * @typedef {import('unist-util-is').TestFunctionAnything} TestFunctionAnything
  */
 
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {u} from 'unist-builder'
 import {remove} from './index.js'
 
-test('should compare nodes by partial properties', (t) => {
+test('should compare nodes by partial properties', () => {
   const tree = u('node', [u('leaf', '1'), u('leaf', '2')])
   const children = tree.children
   const first = tree.children[0]
 
   const next = remove(tree, {value: '2'})
 
-  t.equal(next, tree)
-  t.deepEqual(tree, u('node', [first]))
-  t.equal(tree.children, children)
-  t.equal(tree.children[0], first)
-
-  t.end()
+  assert.equal(next, tree)
+  assert.deepEqual(tree, u('node', [first]))
+  assert.equal(tree.children, children)
+  assert.equal(tree.children[0], first)
 })
 
-test('should remove nodes with children', (t) => {
+test('should remove nodes with children', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
   const children = tree.children
   const first = tree.children[0]
   const last = tree.children[1]
 
   const next = remove(tree, test)
 
-  t.equal(next, tree)
-  t.deepEqual(tree, u('root', [last]))
-  t.equal(tree.children, children)
-  t.equal(tree.children[0], last)
-
-  t.end()
+  assert.equal(next, tree)
+  assert.deepEqual(tree, u('root', [last]))
+  assert.equal(tree.children, children)
+  assert.equal(tree.children[0], last)
 
   /**
    * @param {Node} node
@@ -51,15 +43,13 @@ test('should remove nodes with children', (t) => {
   }
 })
 
-test('should return `null` if root node is removed', (t) => {
+test('should return `null` if root node is removed', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
-  t.equal(remove(tree, 'root'), null)
-
-  t.end()
+  assert.equal(remove(tree, 'root'), null)
 })
 
-test('should cascade-remove parent nodes', (t) => {
+test('should cascade-remove parent nodes', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
   const children = tree.children
   // @ts-expect-error it exists!
@@ -68,12 +58,10 @@ test('should cascade-remove parent nodes', (t) => {
 
   const next = remove(tree, test)
 
-  t.equal(next, tree)
-  t.deepEqual(tree, u('root', [last]))
-  t.equal(tree.children, children)
-  t.equal(tree.children[0], last)
-
-  t.end()
+  assert.equal(next, tree)
+  assert.deepEqual(tree, u('root', [last]))
+  assert.equal(tree.children, children)
+  assert.equal(tree.children[0], last)
 
   /**
    * @param {Node} node
@@ -84,57 +72,47 @@ test('should cascade-remove parent nodes', (t) => {
   }
 })
 
-test('should cascade-remove root nodes', (t) => {
+test('should cascade-remove root nodes', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   const next = remove(tree, 'leaf')
 
-  t.equal(next, null)
-
-  t.end()
+  assert.equal(next, null)
 })
 
-test('should not cascade-remove nodes that were empty initially', (t) => {
+test('should not cascade-remove nodes that were empty initially', () => {
   const tree = u('node', [u('node', []), u('node', [u('leaf')])])
 
   remove(tree, 'leaf')
 
-  t.deepEqual(tree, u('node', [u('node', [])]))
-
-  t.end()
+  assert.deepEqual(tree, u('node', [u('node', [])]))
 })
 
-test('should support type tests', (t) => {
+test('should support type tests', () => {
   const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   remove(tree, {cascade: false}, 'leaf')
 
-  t.deepEqual(tree, u('node', [u('node', [])]))
-
-  t.end()
+  assert.deepEqual(tree, u('node', [u('node', [])]))
 })
 
-test('should support function tests', (t) => {
+test('should support function tests', () => {
   const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   remove(tree, {cascade: false}, (node) => literal(node) && node.value === '1')
 
-  t.deepEqual(tree, u('node', [u('node', []), u('leaf', '2')]))
-
-  t.end()
+  assert.deepEqual(tree, u('node', [u('node', []), u('leaf', '2')]))
 })
 
-test('opts.cascade = true', (t) => {
+test('opts.cascade = true', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   const next = remove(tree, {cascade: true}, 'leaf')
 
-  t.equal(next, null)
-
-  t.end()
+  assert.equal(next, null)
 })
 
-test('opts.cascade = false', (t) => {
+test('opts.cascade = false', () => {
   const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
   const siblings = tree.children
   const node = siblings[0]
@@ -143,17 +121,14 @@ test('opts.cascade = false', (t) => {
 
   const next = remove(tree, {cascade: false}, 'leaf')
 
-  t.equal(next, tree)
-  t.deepEqual(tree, u('root', [u('node', [])]))
-  t.equal(tree.children, siblings)
-  t.equal(tree.children[0], node)
-  // @ts-expect-error it exists!
-  t.equal(tree.children[0].children, children)
-
-  t.end()
+  assert.equal(next, tree)
+  assert.deepEqual(tree, u('root', [u('node', [])]))
+  assert.equal(tree.children, siblings)
+  assert.equal(tree.children[0], node)
+  assert.equal(tree.children[0].children, children)
 })
 
-test('example from readme', (t) => {
+test('example from readme', () => {
   const tree = u('root', [
     u('leaf', '1'),
     u('node', [
@@ -164,12 +139,10 @@ test('example from readme', (t) => {
     u('leaf', '6')
   ])
 
-  t.deepEqual(
+  assert.deepEqual(
     remove(tree, 'leaf'),
     u('root', [u('node', [u('node', [u('other', '4')])])])
   )
-
-  t.end()
 })
 
 /**