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

@@ -45,7 +45,7 @@
     "vfile-message": "^3.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "is-hidden": "^2.0.0",
     "prettier": "^2.0.0",
@@ -76,7 +76,15 @@
     "prettier": true,
     "rules": {
       "unicorn/prefer-code-point": "off"
-    }
+    },
+    "overrides": [
+      {
+        "files": "test/**/*.js",
+        "rules": {
+          "no-await-in-loop": 0
+        }
+      }
+    ]
   },
   "remarkConfig": {
     "plugins": [

test/index.js

@@ -1,25 +1,22 @@
 /**
- * @typedef {import('../lib/index.js').Node} Node
- *
- *
+ * @typedef {import('xast').Root} Root
  */
 
-import fs from 'node:fs'
-import path from 'node:path'
-import test from 'tape'
+import assert from 'node:assert/strict'
+import fs from 'node:fs/promises'
+import process from 'node:process'
+import test from 'node:test'
 import {isHidden} from 'is-hidden'
 import {fromXml} from '../index.js'
 
-const join = path.join
-
-test('xast-util-from-xml', (t) => {
-  t.equal(typeof fromXml, 'function', 'should expose a function')
+test('fromXml', () => {
+  assert.equal(typeof fromXml, 'function', 'should expose a function')
 
   try {
     fromXml('<root unquoted=attribute>')
-    t.fail('should fail (1)')
+    assert.fail('should fail (1)')
   } catch (error) {
-    t.equal(
+    assert.equal(
       String(error),
       '1:17: Unquoted attribute value',
       'should throw messages'
@@ -28,9 +25,9 @@ test('xast-util-from-xml', (t) => {
 
   try {
     fromXml('<!ENTITY>')
-    t.fail('should fail (2)')
+    assert.fail('should fail (2)')
   } catch (error) {
-    t.deepLooseEqual(
+    assert.equal(
       String(error),
       '1:10: Unexpected SGML declaration',
       'should throw for SGML directives'
@@ -39,9 +36,9 @@ test('xast-util-from-xml', (t) => {
 
   try {
     fromXml('<root>&foo;</root>')
-    t.fail('should fail (3)')
+    assert.fail('should fail (3)')
   } catch (error) {
-    t.deepLooseEqual(
+    assert.equal(
       String(error),
       '1:12: Invalid character entity',
       'should throw for unknown entities (1)'
@@ -50,9 +47,9 @@ test('xast-util-from-xml', (t) => {
 
   try {
     fromXml('<root>&copy;</root>')
-    t.fail('should fail (4)')
+    assert.fail('should fail (4)')
   } catch (error) {
-    t.deepLooseEqual(
+    assert.equal(
       String(error),
       '1:13: Invalid character entity',
       'should throw for unknown entities (2)'
@@ -61,182 +58,181 @@ test('xast-util-from-xml', (t) => {
 
   try {
     fromXml('<root><a><b><c/></a></b></root>')
-    t.fail('should fail (5)')
+    assert.fail('should fail (5)')
   } catch (error) {
-    t.deepLooseEqual(
+    assert.equal(
       String(error),
       '1:21: Unexpected close tag',
       'should throw on invalid nesting'
     )
   }
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!doctype>')
     },
     /1:11: Expected doctype name/,
     'should throw on missing doctype name'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!doctype !>')
     },
     /1:13: Expected start of doctype name/,
     'should throw on invalid doctype name'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name[<!ELEMENT greeting (#PCDATA)>]>')
     },
     /1:47: Unexpected internal subset/,
     'should throw on internal subset directly after doctype name'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name [<!ELEMENT greeting (#PCDATA)>]>')
     },
     /1:48: Unexpected internal subset/,
     'should throw on internal subset after doctype name'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name!>')
     },
     /1:17: Expected doctype name character, whitespace, or doctype end/,
     'should throw on invalid character directly after doctype'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name !>')
     },
     /1:18: Expected external identifier \(`PUBLIC` or `SYSTEM`\), whitespace, or doctype end/,
     'should throw on invalid character after doctype'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name PUB>')
     },
     /1:20: Expected external identifier \(`PUBLIC` or `SYSTEM`\)/,
     'should throw on invalid external identifier (1)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEm>')
     },
     /1:23: Expected external identifier \(`PUBLIC` or `SYSTEM`\)/,
     'should throw on invalid external identifier (2)'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name PUBLIC>')
     },
     /1:23: Expected whitespace after `PUBLIC`/,
     'should throw on missing whitespace after public identifier'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name PUBLIC !>')
     },
     /1:25: Expected quote or apostrophe to start public literal/,
     'should throw on invalid character after public identifier'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name PUBLIC "🤔">')
     },
     /1:28: Expected pubid character in public literal/,
     'should throw on invalid character in public identifier'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name PUBLIC "literal"!>')
     },
     /1:34: Expected whitespace after public literal/,
     'should throw on invalid character after public literal'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEM>')
     },
     /1:23: Expected whitespace after `SYSTEM`/,
     'should throw on missing whitespace after system identifier'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEM !>')
     },
     /1:25: Expected quote or apostrophe to start system literal/,
     'should throw on invalid character after system identifier'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEM "asd>')
     },
     /1:28: Unexpected end/,
     'should throw on unended system literal'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEM "asd" [<!ELEMENT greeting (#PCDATA)>]>')
     },
     /1:61: Unexpected internal subset/,
     'should throw on internal subset after external id'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromXml('<!DOCTYPE name SYSTEM "asd" !>')
     },
     /1:31: Expected whitespace or end of doctype/,
     'should throw on unexpected character after external id'
   )
-
-  t.end()
 })
 
-test('fixtures', (t) => {
-  const base = join('test', 'fixtures')
-  const files = fs.readdirSync(base)
+test('fixtures', async () => {
+  const base = new URL('fixtures/', import.meta.url)
+  const files = await fs.readdir(base)
   let index = -1
 
   while (++index < files.length) {
-    if (!isHidden(files[index])) {
-      each(files[index])
-    }
-  }
+    const folder = files[index]
 
-  t.end()
+    if (isHidden(folder)) continue
 
-  function each(/** @type {string} */ fixture) {
-    const input = fs.readFileSync(join(base, fixture, 'index.xml'))
-    const fp = join(base, fixture, 'index.json')
+    const inputUrl = new URL(folder + '/index.xml', base)
+    const treeUrl = new URL(folder + '/index.json', base)
+    const input = await fs.readFile(inputUrl)
     const actual = fromXml(input)
-    /** @type {Node} */
+    /** @type {Root} */
     let expected
 
     try {
-      expected = JSON.parse(String(fs.readFileSync(fp)))
+      expected = JSON.parse(String(await fs.readFile(treeUrl)))
+
+      if ('UPDATE' in process.env) {
+        throw new Error('Update')
+      }
     } catch {
-      // New fixture.
-      fs.writeFileSync(fp, JSON.stringify(actual, null, 2) + '\n')
-      return
+      // New folder.
+      await fs.writeFile(treeUrl, JSON.stringify(actual, null, 2) + '\n')
+      continue
     }
 
-    t.deepEqual(actual, expected, fixture)
+    assert.deepEqual(actual, expected, folder)
   }
 })