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

@@ -52,7 +52,7 @@
     "unist-util-visit": "^4.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "hast-util-from-html": "^1.0.0",
     "hastscript": "^7.0.0",
@@ -65,7 +65,6 @@
     "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/index.js

@@ -4,7 +4,8 @@
 
 import fs from 'node:fs/promises'
 import process from 'node:process'
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {isHidden} from 'is-hidden'
 import {h} from 'hastscript'
 import {fromHtml} from 'hast-util-from-html'
@@ -18,46 +19,46 @@ import {removePosition} from 'unist-util-remove-position'
 import {toMdast} from '../index.js'
 import * as mod from '../index.js'
 
-test('core', (t) => {
-  t.deepEqual(
+test('core', () => {
+  assert.deepEqual(
     Object.keys(mod).sort(),
     ['defaultHandlers', 'defaultNodeHandlers', 'toMdast'],
     'should expose the public api'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(u('root', [h('strong', 'Alpha')])),
     u('root', [u('strong', [u('text', 'Alpha')])]),
     'should transform hast to mdast'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(u('doctype', {name: 'html'})),
     u('root', []),
     'should transform a node w/o mdast representation to an empty root'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(h('q', 'things')),
     {type: 'root', children: [{type: 'text', value: '"things"'}]},
     'should transform a node w/o multiple representations to a root'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toMdast(u('root', [u('unknown', 'text')])),
     u('root', [u('text', 'text')]),
     'should transform unknown texts to `text`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toMdast(u('root', [u('unknown', [h('em')])])),
     u('root', [u('emphasis', [])]),
     'should unwrap unknown parents'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toMdast(u('root', [u('unknown')])),
     u('root', []),
@@ -69,7 +70,7 @@ test('core', (t) => {
     end: {line: 1, column: 6, offset: 5}
   }
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({
       type: 'root',
       children: [
@@ -97,37 +98,37 @@ test('core', (t) => {
     'should support positional information'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'a', children: []}),
     {type: 'link', url: '', title: null, children: []},
     'should support an `a` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'iframe', children: []}),
     {type: 'root', children: []},
     'should support an `iframe` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'img', children: []}),
     {type: 'image', url: '', title: null, alt: ''},
     'should support an `img` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'input', children: []}),
     {type: 'root', children: []},
     'should support an `input` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'select', children: []}),
     {type: 'root', children: []},
     'should support a `select` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({
       type: 'element',
       tagName: 'select',
@@ -138,27 +139,27 @@ test('core', (t) => {
     'should support an `option` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast({type: 'element', tagName: 'video', children: []}),
     {type: 'link', title: null, url: '', children: []},
     'should support a `video` w/o `properties`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error: `children` missing.
     toMdast({type: 'root'}),
     {type: 'root', children: []},
     'should support a `root` node w/o `children`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error: `children` missing.
     toMdast({type: 'element', tagName: 'div'}),
     {type: 'root', children: []},
     'should support an `element` node w/o `children`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(h(null, [h('div', 'Alpha')]), {
       handlers: {
         div() {
@@ -170,13 +171,13 @@ test('core', (t) => {
     'should support `handlers`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(h(null, h('p', 'Alpha\nBeta'))),
     u('root', [u('paragraph', [u('text', 'Alpha Beta')])]),
     'should collapse newline to a single space'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(h(null, h('p', 'Alpha\nBeta')), {newlines: true}),
     u('root', [u('paragraph', [u('text', 'Alpha\nBeta')])]),
     'should support `newlines: true`'
@@ -189,7 +190,7 @@ test('core', (t) => {
     '.'
   ])
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(phrasingTree),
     u('root', [
       u('strong', [u('text', 'Importance')]),
@@ -200,7 +201,7 @@ test('core', (t) => {
     'should infer document if not needed'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toMdast(phrasingTree, {document: true}),
     u('root', [
       u('paragraph', [
@@ -240,7 +241,7 @@ test('core', (t) => {
 
   // Reference check: `text`s are wrapped in `paragraph`s because the unknown
   // node is seen as “block”
-  t.deepEqual(
+  assert.deepEqual(
     referenceTree.type === 'root' &&
       referenceTree.children.length === 3 &&
       referenceTree.children[0].type === 'paragraph',
@@ -249,18 +250,16 @@ test('core', (t) => {
   )
 
   // Actual check: no `paragraph` is added because `hName` is added.
-  t.deepEqual(
+  assert.deepEqual(
     explicitTree.type === 'root' &&
       explicitTree.children.length === 3 &&
       explicitTree.children[0].type !== 'paragraph',
     true,
     'should support `node.data.hName` to infer phrasing (2)'
   )
-
-  t.end()
 })
 
-test('fixtures', async (t) => {
+test('fixtures', async () => {
   const fixtures = new URL('fixtures/', import.meta.url)
   const folders = await fs.readdir(fixtures)
 
@@ -269,72 +268,69 @@ test('fixtures', async (t) => {
       continue
     }
 
-    t.test(folder, async (t) => {
-      const configUrl = new URL(folder + '/index.json', fixtures)
-      const inputUrl = new URL(folder + '/index.html', fixtures)
-      const expectedUrl = new URL(folder + '/index.md', fixtures)
-      const input = String(await fs.readFile(inputUrl))
-        // Replace middots with spaces (useful for trailing spaces).
-        .replace(/·/g, ' ')
-      /** @type {({stringify?: boolean, tree?: boolean} & Options) | undefined} */
-      let config
-
-      try {
-        config = JSON.parse(String(await fs.readFile(configUrl)))
-      } catch {}
-
-      const hast = fromHtml(input)
-      const mdast = toMdast(hast, config)
-      removePosition(mdast, true)
-
-      t.doesNotThrow(() => {
-        mdastAssert(mdast)
-      }, 'should produce valid mdast nodes')
-
-      // Ignore the invalid base test.
-      if (folder === 'base-invalid') {
-        t.end()
-        return
-      }
-
-      const actual = toMarkdown(mdast, {
-        extensions: [gfmToMarkdown()],
-        fences: true
-      })
-      /** @type {string} */
-      let expected
+    const configUrl = new URL(folder + '/index.json', fixtures)
+    const inputUrl = new URL(folder + '/index.html', fixtures)
+    const expectedUrl = new URL(folder + '/index.md', fixtures)
+    const input = String(await fs.readFile(inputUrl))
+      // Replace middots with spaces (useful for trailing spaces).
+      .replace(/·/g, ' ')
+    /** @type {({stringify?: boolean, tree?: boolean} & Options) | undefined} */
+    let config
+
+    try {
+      config = JSON.parse(String(await fs.readFile(configUrl)))
+    } catch {}
+
+    const hast = fromHtml(input)
+    const mdast = toMdast(hast, config)
+    removePosition(mdast, true)
+
+    assert.doesNotThrow(() => {
+      mdastAssert(mdast)
+    }, folder + ': should produce valid mdast nodes')
+
+    // Ignore the invalid base test.
+    if (folder === 'base-invalid') {
+      continue
+    }
 
-      try {
-        if ('UPDATE' in process.env) {
-          throw new Error('Update!')
-        }
+    const actual = toMarkdown(mdast, {
+      extensions: [gfmToMarkdown()],
+      fences: true
+    })
+    /** @type {string} */
+    let expected
 
-        expected = String(await fs.readFile(expectedUrl))
-      } catch {
-        expected = actual
-        await fs.writeFile(expectedUrl, actual)
+    try {
+      if ('UPDATE' in process.env) {
+        throw new Error('Update!')
       }
 
-      if (!config || config.stringify !== false) {
-        t.deepEqual(actual, expected, 'should produce the same documents')
-      }
+      expected = String(await fs.readFile(expectedUrl))
+    } catch {
+      expected = actual
+      await fs.writeFile(expectedUrl, actual)
+    }
 
-      if (!config || config.tree !== false) {
-        const expectedMdast = fromMarkdown(expected, {
-          extensions: [gfm()],
-          mdastExtensions: [gfmFromMarkdown()]
-        })
-        removePosition(expectedMdast, true)
-        t.deepEqual(
-          mdast,
-          expectedMdast,
-          'should produce the same tree as remark'
-        )
-      }
+    if (!config || config.stringify !== false) {
+      assert.deepEqual(
+        actual,
+        expected,
+        folder + ': should produce the same documents'
+      )
+    }
 
-      t.end()
-    })
+    if (!config || config.tree !== false) {
+      const expectedMdast = fromMarkdown(expected, {
+        extensions: [gfm()],
+        mdastExtensions: [gfmFromMarkdown()]
+      })
+      removePosition(expectedMdast, true)
+      assert.deepEqual(
+        mdast,
+        expectedMdast,
+        folder + ': should produce the same tree as remark'
+      )
+    }
   }
-
-  t.end()
 })