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

@@ -39,12 +39,11 @@
     "zwitch": "^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/children.js

@@ -1,28 +1,29 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('children', (t) => {
-  t.throws(
+test('children', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'paragraph', children: {alpha: 'bravo'}})
     },
     /`children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'paragraph', children: ['one']})
     },
     /node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'paragraph', children: [{type: 'text', value: 'alpha'}]})
   }, 'should not throw on vald children')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({
         type: 'paragraph',
@@ -37,6 +38,4 @@ test('children', (t) => {
     /node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/,
     'should throw on invalid descendants'
   )
-
-  t.end()
 })

test/comment.js

@@ -1,18 +1,17 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(comment)', (t) => {
-  t.throws(
+test('assert(comment)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'comment'})
     },
     /literal should have `value`: `{ type: 'comment' }`$/,
     'should throw if a `comment` doesn’t have a value'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'comment', value: 'Alpha'})
   }, 'should allow `value`')
-
-  t.end()
 })

test/doctype.js

@@ -1,10 +1,9 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(doctype)', (t) => {
-  t.doesNotThrow(() => {
+test('assert(doctype)', () => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'doctype'})
   }, 'should allow doctypes')
-
-  t.end()
 })

test/element.js

@@ -1,30 +1,29 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(element)', (t) => {
-  t.throws(
+test('assert(element)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'element'})
     },
     /parent should have `children`: `{ type: 'element' }`$/,
     'should throw if a `element` is not a parent'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'element', children: []})
     },
     /`element` should have a `tagName`: `{ type: 'element', children: \[] }`$/,
     'should throw if a `element` has no `tagName`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'element', tagName: '', children: []})
     },
     /`element.tagName` should not be empty: `{ type: 'element', tagName: '', children: \[] }`$/,
     'should throw if a `element` has an empty `tagName`'
   )
-
-  t.end()
 })

test/node.js

@@ -1,38 +1,37 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('node', (t) => {
-  t.throws(
+test('node', () => {
+  nodeAssert.throws(
     () => {
       assert()
     },
     /node should be an object: `undefined`$/,
     'should throw if not given a node (#1)'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert(null)
     },
     /node should be an object: `null`$/,
     'should throw if not given a node (#2)'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert('foo')
     },
     /node should be an object: `'foo'`$/,
     'should throw if given a non-node (#1)'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert(6)
     },
     /node should be an object: `6`$/,
     'should throw if not given a non-node (#2)'
   )
-
-  t.end()
 })

test/parent.js

@@ -1,22 +1,21 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {parent} from '../index.js'
 
-test('parent', (t) => {
-  t.throws(
+test('parent', () => {
+  nodeAssert.throws(
     () => {
       parent()
     },
     /node should be an object: `undefined`$/,
     'should throw if not given a node'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       parent({type: 'x'})
     },
     /parent should have `children`/,
     'should throw if not given a parent'
   )
-
-  t.end()
 })

test/root.js

@@ -1,22 +1,21 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(root)', (t) => {
-  t.throws(
+test('assert(root)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'root'})
     },
     /parent should have `children`: `{ type: 'root' }`$/,
     'should throw if a `root` is not a parent'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'root', children: [{type: 'root', children: []}]})
     },
     /`root` should not have a parent: `{ type: 'root', children: \[] }` in `{ type: 'root', children: \[ { type: 'root', children: \[] } ] }`$/,
     'should throw if a `root` has a parent'
   )
-
-  t.end()
 })

test/text.js

@@ -1,18 +1,17 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(text)', (t) => {
-  t.throws(
+test('assert(text)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'text'})
     },
     /literal should have `value`: `{ type: 'text' }`$/,
     'should throw if a `text` doesn’t have a value'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'text', value: 'Alpha'})
   }, 'should allow `value`')
-
-  t.end()
 })