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

@@ -44,12 +44,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/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: 'foo', children: {alpha: 'bravo'}})
     },
     /`children` should be an array: `{ type: 'foo', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', children: ['one']})
     },
     /node should be an object: `'one'` in `{ type: 'foo', children: \[ 'one' ] }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'parent', children: [{type: 'text', value: 'alpha'}]})
   }, 'should not throw on vald children')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({
         type: 'foo',
@@ -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/literal.js

@@ -1,34 +1,33 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {literal} from '../index.js'
 
-test('literal()', (t) => {
-  t.throws(
+test('literal()', () => {
+  assert.throws(
     () => {
       literal({})
     },
     /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       literal({type: 'strong', children: []})
     },
     /literal should not have `children`: `{ type: 'strong', children: \[] }`$/,
     'should throw if the given node has `children`'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       literal({type: 'break'})
     },
     /literal should have `value`: `{ type: 'break' }`$/,
     'should throw if the given node has no `value`'
   )
 
-  t.doesNotThrow(() => {
+  assert.doesNotThrow(() => {
     literal({type: 'text', value: 'foo'})
   }, 'should not throw on valid text nodes')
-
-  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/non-defined.js

@@ -1,8 +1,9 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('non-defined', (t) => {
-  t.doesNotThrow(() => {
+test('non-defined', () => {
+  nodeAssert.doesNotThrow(() => {
     assert({
       type: 'element',
       properties: {
@@ -17,7 +18,7 @@ test('non-defined', (t) => {
     })
   }, 'should not throw if non-defined properties are found')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({
         type: 'break',
@@ -27,6 +28,4 @@ test('non-defined', (t) => {
     /non-specced property `data` should be JSON: `{ type: 'break', data: { foo: \[Function: Function] } }`$/,
     'should throw if non-defined properties are not serialisable'
   )
-
-  t.end()
 })

test/parent.js

@@ -1,34 +1,33 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {parent} from '../index.js'
 
-test('parent()', (t) => {
-  t.throws(
+test('parent()', () => {
+  assert.throws(
     () => {
       parent({})
     },
     /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       parent({type: 'text', value: 'foo'})
     },
     /parent should not have `value`: `{ type: 'text', value: 'foo' }`$/,
     'should throw if the given node has a `value`'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       parent({type: 'break'})
     },
     /parent should have `children`: `{ type: 'break' }`$/,
     'should throw if the given node has `children`'
   )
 
-  t.doesNotThrow(() => {
+  assert.doesNotThrow(() => {
     parent({type: 'strong', children: []})
   }, 'should not throw on valid void nodes')
-
-  t.end()
 })

test/position.js

@@ -1,102 +1,101 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('position', (t) => {
-  t.throws(
+test('position', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: 1})
     },
     /`position` should be an object: `{ type: 'foo', position: 1 }`$/,
     'should throw if given a non-object `position`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: null})
   }, 'should not throw if given a null `position`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {}})
   }, 'should not throw if given an empty `position` object')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {start: 1}})
     },
     /`position.start` should be an object: `{ type: 'foo', position: { start: 1 } }`$/,
     'should throw if given a non-object `position.start`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {start: null}})
   }, 'should not throw if given a null `position.start`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {}}})
   }, 'should not throw if given an empty `position.start` object')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {end: 1}})
     },
     /`position.end` should be an object: `{ type: 'foo', position: { end: 1 } }`$/,
     'should throw if given a non-object `position.end`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {end: null}})
   }, 'should not throw if given a null `position.end`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {}}})
   }, 'should not throw if given an empty `position.end` object')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {line: null}}})
   }, 'should not throw if given a `position.start.line` to `null`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {column: null}}})
   }, 'should not throw if given a `position.start.column` to `null`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {line: null}}})
   }, 'should not throw if given a `position.end.line` to `null`')
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {column: null}}})
   }, 'should not throw if given a `position.end.column` to `null`')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {start: {line: 0}}})
     },
     /`position.start.line` should be gte `1`: `{ type: 'foo', position: { start: { line: 0 } } }`$/,
     'should throw if `position.start.line` is less than 1'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {start: {column: 0}}})
     },
     /`position.start.column` should be gte `1`: `{ type: 'foo', position: { start: { column: 0 } } }`$/,
     'should throw if `position.start.column` is less than 1'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {end: {line: 0}}})
     },
     /`position.end.line` should be gte `1`: `{ type: 'foo', position: { end: { line: 0 } } }`$/,
     'should throw if `position.end.line` is less than 1'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'foo', position: {end: {column: 0}}})
     },
     /`position.end.column` should be gte `1`: `{ type: 'foo', position: { end: { column: 0 } } }`$/,
     'should throw if `position.end.column` is less than 1'
   )
-
-  t.end()
 })

test/type.js

@@ -1,42 +1,41 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('type', (t) => {
-  t.throws(
+test('type', () => {
+  nodeAssert.throws(
     () => {
       assert({})
     },
     /node should have a type: `{}`$/,
     'should throw if not given a `type` (#1)'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({value: 'foo'})
     },
     /node should have a type: `{ value: 'foo' }`$/,
     'should throw if not given a type (#2)'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 1})
     },
     /`type` should be a string: `{ type: 1 }`$/,
     'should throw if not given a non-string type'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: ''})
     },
     /`type` should not be empty: `{ type: '' }`$/,
     'should throw if given an empty string type'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'foo'})
   }, 'should not throw if given a non-empty type string')
-
-  t.end()
 })