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,12 +40,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',
@@ -32,6 +33,4 @@ test('children', (t) => {
     /node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/,
     'should throw on invalid descendants'
   )
-
-  t.end()
 })

test/code.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('assert(code)', (t) => {
-  t.throws(
+test('assert(code)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'code'})
     },
     /literal should have `value`: `{ type: 'code' }`$/,
     'should throw if `code` is not a text'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'code', value: ''})
   }, 'should not throw if `code` has no extra properties')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'code', lang: 0, value: ''})
     },
     /`lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/,
     'should throw if `lang` is not a string'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'code', lang: 'js', meta: 1, value: ''})
     },
     /`meta` must be `string`: `{ type: 'code', lang: 'js', meta: 1, value: '' }`$/,
     'should throw if `meta` is not a string'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'code', meta: '', value: ''})
     },
     /code with `meta` must also have `lang`: `{ type: 'code', meta: '', value: '' }`$/,
     'should throw if `meta` is defined but not `lang`'
   )
-
-  t.end()
 })

test/definition.js

@@ -1,58 +1,57 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(definition)', (t) => {
-  t.throws(
+test('assert(definition)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'definition'})
     },
     /`identifier` must be `string`: `{ type: 'definition' }`$/,
     'should throw if `definition` has no `identifier`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'definition', identifier: '1'})
     },
     /`url` must be `string`: `{ type: 'definition', identifier: '1' }`$/,
     'should throw if `definition` has no `url`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'definition', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'definition', url: 1})
     },
     /`identifier` must be `string`: `{ type: 'definition', url: 1 }`$/,
     'should throw if `url` is not a `string`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'definition', identifier: '1', url: '1'})
   }, 'should not throw if `definition` has no other properties')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'definition', identifier: '1', url: '1', title: 1})
     },
     /`title` must be `string`: `{ type: 'definition', identifier: '1', url: '1', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'definition', identifier: '1', url: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'definition', identifier: '1', url: '1', label: 1 }`$/,
     'should throw if `label` is not a `string`'
   )
-
-  t.end()
 })

test/footnote-definition.js

@@ -1,36 +1,37 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(footnoteDefinition)', (t) => {
-  t.throws(
+test('assert(footnoteDefinition)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteDefinition'})
     },
     /parent should have `children`: `{ type: 'footnoteDefinition' }`$/,
     'should throw if `footnoteDefinition` is not a parent'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteDefinition', children: []})
     },
     /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/,
     'should throw if `footnoteDefinition` has no identifier'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteDefinition', identifier: 1, children: []})
     },
     /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'footnoteDefinition', identifier: '1', children: []})
   }, 'should not throw if `footnoteDefinition` has an identifier')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({
         type: 'footnoteDefinition',
@@ -42,6 +43,4 @@ test('assert(footnoteDefinition)', (t) => {
     /`label` must be `string`: `{ type: 'footnoteDefinition',\s+identifier: '1',\s+label: 1,\s+children: \[] }`$/,
     'should throw if `label` is not a `string`'
   )
-
-  t.end()
 })

test/footnote-reference.js

@@ -1,34 +1,33 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(footnoteReference)', (t) => {
-  t.throws(
+test('assert(footnoteReference)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteReference'})
     },
     /`identifier` must be `string`: `{ type: 'footnoteReference' }`$/,
     'should throw if `footnoteReference` has no `identifier`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteReference', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'footnoteReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'footnoteReference', identifier: '1'})
   }, 'should not throw if `footnoteReference` has no other properties')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'footnoteReference', identifier: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'footnoteReference', identifier: '1', label: 1 }`$/,
     'should throw if `label` is not a `string`'
   )
-
-  t.end()
 })

test/heading.js

@@ -1,34 +1,33 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(heading)', (t) => {
-  t.throws(
+test('assert(heading)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'heading'})
     },
     /parent should have `children`: `{ type: 'heading' }`$/,
     'should throw if a `heading` is not a parent'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'heading', depth: 0, children: []})
     },
     /`depth` should be gte `1`: `{ type: 'heading', depth: 0, children: \[] }`$/,
     'should throw if `depth` is lower than 1'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'heading', depth: 7, children: []})
     },
     /`depth` should be lte `6`: `{ type: 'heading', depth: 7, children: \[] }`$/,
     'should throw if `depth` is lower than 7'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'heading', depth: 1, children: []})
   }, 'should not throw if `heading` is between 0 and 7')
-
-  t.end()
 })

test/image-reference.js

@@ -1,58 +1,57 @@
-import test from 'tape'
+import nodeAssert from 'node:assert/strict'
+import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(imageReference)', (t) => {
-  t.throws(
+test('assert(imageReference)', () => {
+  nodeAssert.throws(
     () => {
       assert({type: 'imageReference'})
     },
     /`identifier` must be `string`: `{ type: 'imageReference' }`$/,
     'should throw if `imageReference` has no `identifier`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'imageReference', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'imageReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({type: 'imageReference', identifier: '1'})
   }, 'should not throw if `imageReference` has no other properties')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'imageReference', identifier: '1', alt: 1})
     },
     /`alt` must be `string`: `{ type: 'imageReference', identifier: '1', alt: 1 }`$/,
     'should throw if `alt` is not a `string`'
   )
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'imageReference', identifier: '1', referenceType: 1})
     },
     /`referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'imageReference', identifier: '1', referenceType: 1 }`$/,
     'should throw if `referenceType` is not a `string`'
   )
 
-  t.doesNotThrow(() => {
+  nodeAssert.doesNotThrow(() => {
     assert({
       type: 'imageReference',
       identifier: '1',
       referenceType: 'collapsed'
     })
   }, 'should not throw if `referenceType` is valid')
 
-  t.throws(
+  nodeAssert.throws(
     () => {
       assert({type: 'imageReference', identifier: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'imageReference', identifier: '1', label: 1 }`$/,
     'should throw if `label` is not a `string`'
   )
-
-  t.end()
 })