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

@@ -44,20 +44,18 @@
     "unist-util-visit": "^4.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
+    "mdast-util-from-markdown": "^1.0.0",
+    "mdast-util-gfm": "^2.0.0",
+    "micromark-extension-gfm": "^2.0.0",
     "prettier": "^2.0.0",
-    "remark": "^14.0.0",
     "remark-cli": "^11.0.0",
-    "remark-gfm": "^3.0.0",
-    "remark-parse": "^10.0.0",
     "remark-preset-wooorm": "^9.0.0",
     "remark-usage": "^10.0.0",
-    "tape": "^5.0.0",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",
     "unified": "^10.0.0",
-    "unist-builder": "^3.0.0",
     "xo": "^0.53.0"
   },
   "scripts": {
@@ -79,6 +77,12 @@
   "xo": {
     "prettier": true,
     "overrides": [
+      {
+        "files": "test/**/*.js",
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      },
       {
         "files": "example.js",
         "rules": {
@@ -89,7 +93,7 @@
   },
   "remarkConfig": {
     "plugins": [
-      "preset-wooorm",
+      "remark-preset-wooorm",
       [
         "remark-usage",
         {

test/index.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {import('mdast').Root} Root
  * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('mdast').BlockContent} BlockContent
  * @typedef {import('mdast').List} List
  * @typedef {import('../index.js').Options} Options
  *
@@ -10,116 +11,131 @@
  * @typedef {Options & TestConfig} Config
  */
 
-import fs from 'node:fs'
-import path from 'node:path'
-import test from 'tape'
-import {unified} from 'unified'
-import remarkParse from 'remark-parse'
-import remarkGfm from 'remark-gfm'
+import assert from 'node:assert/strict'
+import fs from 'node:fs/promises'
+import test from 'node:test'
+import {fromMarkdown} from 'mdast-util-from-markdown'
+import {gfmFromMarkdown} from 'mdast-util-gfm'
+import {gfm} from 'micromark-extension-gfm'
 import {visit} from 'unist-util-visit'
-import {u} from 'unist-builder'
 import {toc} from '../index.js'
 
-const join = path.join
+test('mdast-util-toc', () => {
+  assert.equal(typeof toc, 'function', 'should be a function')
 
-test('mdast-util-toc', (t) => {
-  t.is(typeof toc, 'function', 'should be a function')
-
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       toc()
     },
     /Cannot read propert/,
     'should fail without node'
   )
-
-  t.end()
 })
 
-test('Fixtures', (t) => {
-  const root = join('test', 'fixtures')
-  const files = fs.readdirSync(root)
+test('Fixtures', async () => {
+  const root = new URL('fixtures/', import.meta.url)
+  const files = await fs.readdir(root)
   let index = -1
 
   while (++index < files.length) {
     const name = files[index]
 
     if (name.indexOf('.') === 0) continue
 
-    const input = fs.readFileSync(join(root, name, 'input.md'))
+    const input = await fs.readFile(new URL(name + '/input.md', root))
     /** @type {Config} */
     let config = {}
 
     try {
       config = JSON.parse(
-        String(fs.readFileSync(join(root, name, 'config.json')))
+        String(await fs.readFile(new URL(name + '/config.json', root)))
       )
     } catch {}
 
-    const processor = unified().use(remarkParse).use(remarkGfm)
     const {useCustomHProperty, ...options} = config
 
+    const tree = fromMarkdown(input, {
+      mdastExtensions: [gfmFromMarkdown()],
+      extensions: [gfm()]
+    })
+
     if (useCustomHProperty) {
-      processor.use(() => (tree) => {
-        const node = /** @type {Root} */ (tree)
-        visit(node, 'heading', (heading) => {
-          heading.data = {hProperties: {id: 'b'}}
-        })
+      visit(tree, 'heading', (heading) => {
+        heading.data = {hProperties: {id: 'b'}}
       })
     }
 
-    const tree = /** @type {Root} */ (processor.runSync(processor.parse(input)))
     const actual = toc(tree, options)
+
     /** @type {Root} */
     const expected = JSON.parse(
-      String(fs.readFileSync(join(root, name, 'output.json')))
+      String(await fs.readFile(new URL(name + '/output.json', root)))
     )
 
-    t.deepEqual(actual, expected, name)
+    assert.deepEqual(actual, expected, name)
   }
-
-  t.end()
 })
 
-test('processing nodes', (t) => {
-  const rootNode = /** @type {Root} */ (
-    u('root', [
-      u('heading', {depth: 1}, [u('text', 'Alpha')]),
-      u('heading', {depth: 2}, [u('text', 'Bravo')])
-    ])
-  )
-
-  const parentNode = /** @type {Blockquote} */ (
-    u('blockquote', rootNode.children)
-  )
-
-  const blockquoteNode = /** @type {Root} */ (
-    u('root', [
-      u('heading', {depth: 1}, [u('text', 'Charlie')]),
-      u('heading', {depth: 2}, [u('text', 'Delta')]),
-      u('blockquote', rootNode.children)
-    ])
-  )
+test('processing nodes', () => {
+  /** @type {Array<BlockContent>} */
+  const fragment = [
+    {type: 'heading', depth: 1, children: [{type: 'text', value: 'Alpha'}]},
+    {type: 'heading', depth: 2, children: [{type: 'text', value: 'Bravo'}]}
+  ]
 
   /** @type {List} */
-  const expectedRootMap = u('list', {ordered: false, spread: true}, [
-    u('listItem', {spread: true}, [
-      u('paragraph', [
-        u('link', {title: null, url: '#alpha'}, [u('text', 'Alpha')])
-      ]),
-      u('list', {ordered: false, spread: false}, [
-        u('listItem', {spread: false}, [
-          u('paragraph', [
-            u('link', {title: null, url: '#bravo'}, [u('text', 'Bravo')])
-          ])
-        ])
-      ])
-    ])
-  ])
-
-  t.deepEqual(
-    toc(rootNode),
+  const expectedRootMap = {
+    type: 'list',
+    ordered: false,
+    spread: true,
+    children: [
+      {
+        type: 'listItem',
+        spread: true,
+        children: [
+          {
+            type: 'paragraph',
+            children: [
+              {
+                type: 'link',
+                title: null,
+                url: '#alpha',
+                children: [{type: 'text', value: 'Alpha'}]
+              }
+            ]
+          },
+          {
+            type: 'list',
+            ordered: false,
+            spread: false,
+            children: [
+              {
+                type: 'listItem',
+                spread: false,
+                children: [
+                  {
+                    type: 'paragraph',
+                    children: [
+                      {
+                        type: 'link',
+                        title: null,
+                        url: '#bravo',
+                        children: [{type: 'text', value: 'Bravo'}]
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+
+  assert.deepEqual(
+    toc({type: 'root', children: fragment}),
     {
       index: null,
       endIndex: null,
@@ -128,8 +144,8 @@ test('processing nodes', (t) => {
     'can process root nodes'
   )
 
-  t.deepEqual(
-    toc(parentNode),
+  assert.deepEqual(
+    toc({type: 'blockquote', children: fragment}),
     {
       index: null,
       endIndex: null,
@@ -138,15 +154,31 @@ test('processing nodes', (t) => {
     'can process non-root nodes'
   )
 
-  t.deepEqual(
-    toc(blockquoteNode, {parents: 'blockquote'}),
+  assert.deepEqual(
+    toc(
+      {
+        type: 'root',
+        children: [
+          {
+            type: 'heading',
+            depth: 1,
+            children: [{type: 'text', value: 'Charlie'}]
+          },
+          {
+            type: 'heading',
+            depth: 2,
+            children: [{type: 'text', value: 'Delta'}]
+          },
+          {type: 'blockquote', children: fragment}
+        ]
+      },
+      {parents: 'blockquote'}
+    ),
     {
       index: null,
       endIndex: null,
       map: expectedRootMap
     },
     'can process custom parent nodes'
   )
-
-  t.end()
 })