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

@@ -48,15 +48,14 @@
     "@types/xast": "^1.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "esast-util-from-js": "^1.0.0",
     "estree-util-build-jsx": "^2.0.0",
     "estree-util-to-js": "^1.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/core.js

@@ -1,16 +1,17 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {x} from '../index.js'
 
-test('xastscript', (t) => {
-  t.equal(typeof x, 'function', 'should expose a function')
+test('xastscript', () => {
+  assert.equal(typeof x, 'function', 'should expose a function')
 
-  t.deepEqual(
+  assert.deepEqual(
     x(),
     {type: 'root', children: []},
     'should create a root when w/o `name`'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       x(1)
@@ -19,31 +20,31 @@ test('xastscript', (t) => {
     'should throw w/ incorrect `name`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y'),
     {type: 'element', name: 'y', attributes: {}, children: []},
     'should create an element when given `name`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('Y'),
     {type: 'element', name: 'Y', attributes: {}, children: []},
     'should treat `name` case-sensitive'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {a: 'b'}),
     {type: 'element', name: 'y', attributes: {a: 'b'}, children: []},
     'should create an element with given attributes'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {a: null, b: undefined, c: Number.NaN}),
     {type: 'element', name: 'y', attributes: {}, children: []},
     'should ignore null, undefined, and NaN attribute values'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {}, x('z')),
     {
       type: 'element',
@@ -54,7 +55,7 @@ test('xastscript', (t) => {
     'should add a child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {}, [x('a'), x('b')]),
     {
       type: 'element',
@@ -68,7 +69,7 @@ test('xastscript', (t) => {
     'should add children as an array'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error Deeply nested children are not typed.
     x('y', {}, [[[x('a')]], [[[[x('b')]], x('c')]]]),
     {
@@ -84,7 +85,7 @@ test('xastscript', (t) => {
     'should add children in a deeply nested array'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {}, x('a'), x('b')),
     {
       type: 'element',
@@ -98,7 +99,7 @@ test('xastscript', (t) => {
     'should add children as arguments'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {}, 'a', 1),
     {
       type: 'element',
@@ -112,13 +113,13 @@ test('xastscript', (t) => {
     'should add strings and numbers as literals'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', {}, null, undefined),
     {type: 'element', name: 'y', attributes: {}, children: []},
     'should ignore null and undefined children'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       x('y', {}, {})
@@ -127,7 +128,7 @@ test('xastscript', (t) => {
     'should throw on invalid children'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', 'z'),
     {
       type: 'element',
@@ -138,7 +139,7 @@ test('xastscript', (t) => {
     'should support omitting attributes when given a string for a child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', 1),
     {
       type: 'element',
@@ -149,7 +150,7 @@ test('xastscript', (t) => {
     'should support omitting attributes when given a number for a child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('y', ['a', 1]),
     {
       type: 'element',
@@ -163,19 +164,19 @@ test('xastscript', (t) => {
     'should support omitting attributes when given an array for a child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x(null, '1'),
     {type: 'root', children: [{type: 'text', value: '1'}]},
     'should create a root with a textual child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x(null, 1),
     {type: 'root', children: [{type: 'text', value: '1'}]},
     'should create a root with a numerical child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x(null, x('a')),
     {
       type: 'root',
@@ -184,7 +185,7 @@ test('xastscript', (t) => {
     'should create a root with a node child'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     x('a', {}, [x(null, x('b'))]),
     {
       type: 'element',
@@ -194,6 +195,4 @@ test('xastscript', (t) => {
     },
     'should create a node w/ by unraveling roots'
   )
-
-  t.end()
 })

test/jsx.jsx

@@ -1,91 +1,92 @@
 /** @jsxImportSource xastscript */
 
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {u} from 'unist-builder'
 import {x} from '../index.js'
 
-test('name', (t) => {
-  t.deepEqual(<a />, x('a'), 'should support a self-closing element')
+test('name', () => {
+  assert.deepEqual(<a />, x('a'), 'should support a self-closing element')
 
-  t.deepEqual(<a>b</a>, x('a', 'b'), 'should support a value as a child')
+  assert.deepEqual(<a>b</a>, x('a', 'b'), 'should support a value as a child')
 
   const A = 'a'
 
   // Note: this file is a template, generated with different runtimes.
   // @ts-ignore: TS (depending on this build) sometimes doesn’t understand.
-  t.deepEqual(<A />, x(A), 'should support an uppercase tag name')
+  assert.deepEqual(<A />, x(A), 'should support an uppercase tag name')
 
-  t.deepEqual(
+  assert.deepEqual(
     <a>{1 + 1}</a>,
     x('a', '2'),
     'should support expressions as children'
   )
 
-  t.deepEqual(<></>, u('root', []), 'should support a fragment')
+  assert.deepEqual(<></>, u('root', []), 'should support a fragment')
 
-  t.deepEqual(
+  assert.deepEqual(
     <>a</>,
     u('root', [u('text', 'a')]),
     'should support a fragment with text'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <>
       <a />
     </>,
     u('root', [x('a')]),
     'should support a fragment with an element'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <>{-1}</>,
     u('root', [u('text', '-1')]),
     'should support a fragment with an expression'
   )
 
   const com = {acme: {a: 'A', b: 'B'}}
 
-  t.deepEqual(
+  assert.deepEqual(
     // Note: this file is a template, generated with different runtimes.
     // @ts-ignore: TS (depending on this build) sometimes doesn’t understand.
     <com.acme.a />,
     x(com.acme.a),
     'should support members as names (`a.b`)'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a b />,
     x('a', {b: 'true'}),
     'should support a boolean attribute'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a b="" />,
     x('a', {b: ''}),
     'should support a double quoted attribute'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a b='"' />,
     x('a', {b: '"'}),
     'should support a single quoted attribute'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a b={1 + 1} />,
     x('a', {b: '2'}),
     'should support expression value attributes'
   )
 
   const props = {a: 1, b: 2}
 
-  t.deepEqual(
+  assert.deepEqual(
     <a {...props} />,
     x('a', props),
     'should support expression spread attributes'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a>
       <b />c<d>e</d>
       {1 + 1}
@@ -94,7 +95,7 @@ test('name', (t) => {
     'should support text, elements, and expressions in JSX'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     <a>
       <>{1}</>
     </a>,
@@ -107,7 +108,7 @@ test('name', (t) => {
     ['Chrome', 'A chemical element.']
   ]
 
-  t.deepEqual(
+  assert.deepEqual(
     <dl>
       {dl.map(([title, definition]) => (
         <>
@@ -124,6 +125,4 @@ test('name', (t) => {
     ]),
     'should support a fragment in an element (#2)'
   )
-
-  t.end()
 })