Use Node test runner

Author: wooorm

package.json

@@ -39,12 +39,11 @@
     "vfile": "^5.1.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",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",
     "xo": "^0.53.0"

test.js

@@ -4,132 +4,119 @@ import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
 import {fileURLToPath, URL} from 'node:url'
-import test from 'tape'
+import test from 'node:test'
 import buffer from 'is-buffer'
 import {toVFile, read, readSync, write, writeSync} from './index.js'
 
 const join = path.join
 
 const fixture = fs.readFileSync('readme.md', 'utf8')
 
-test('toVFile()', (t) => {
-  t.test('should accept a string as `.path`', (t) => {
+test('toVFile()', async (t) => {
+  await t.test('should accept a string as `.path`', () => {
     const file = toVFile(join('foo', 'bar', 'baz.qux'))
 
-    t.equal(file.path, join('foo', 'bar', 'baz.qux'))
-    t.equal(file.basename, 'baz.qux')
-    t.equal(file.stem, 'baz')
-    t.equal(file.extname, '.qux')
-    t.equal(file.dirname, join('foo', 'bar'))
-    t.equal(file.value, undefined)
-    t.end()
+    assert.equal(file.path, join('foo', 'bar', 'baz.qux'))
+    assert.equal(file.basename, 'baz.qux')
+    assert.equal(file.stem, 'baz')
+    assert.equal(file.extname, '.qux')
+    assert.equal(file.dirname, join('foo', 'bar'))
+    assert.equal(file.value, undefined)
   })
 
-  t.test('should accept a buffer as `.path`', (t) => {
+  await t.test('should accept a buffer as `.path`', () => {
     const file = toVFile(Buffer.from('readme.md'))
 
-    t.equal(file.path, 'readme.md')
-    t.equal(file.value, undefined)
-    t.end()
+    assert.equal(file.path, 'readme.md')
+    assert.equal(file.value, undefined)
   })
 
-  t.test('should accept an object', (t) => {
+  await t.test('should accept an object', () => {
     const file = toVFile({
       dirname: join('foo', 'bar'),
       stem: 'baz',
       extname: '.qux'
     })
 
-    t.equal(file.path, join('foo', 'bar', 'baz.qux'))
-    t.equal(file.basename, 'baz.qux')
-    t.equal(file.stem, 'baz')
-    t.equal(file.extname, '.qux')
-    t.equal(file.dirname, join('foo', 'bar'))
-    t.equal(file.value, undefined)
-    t.end()
+    assert.equal(file.path, join('foo', 'bar', 'baz.qux'))
+    assert.equal(file.basename, 'baz.qux')
+    assert.equal(file.stem, 'baz')
+    assert.equal(file.extname, '.qux')
+    assert.equal(file.dirname, join('foo', 'bar'))
+    assert.equal(file.value, undefined)
   })
 
-  t.test('should accept a vfile', (t) => {
+  await t.test('should accept a vfile', () => {
     const first = toVFile()
     const second = toVFile(first)
 
-    t.equal(first, second)
-    t.end()
+    assert.equal(first, second)
   })
 
-  t.test('should accept a WHATWG URL object', (t) => {
+  await t.test('should accept a WHATWG URL object', () => {
     const dir = fileURLToPath(new URL('./', import.meta.url))
     const file = toVFile(new URL('baz.qux', import.meta.url))
 
-    t.equal(file.path, join(dir, 'baz.qux'))
-    t.equal(file.basename, 'baz.qux')
-    t.equal(file.stem, 'baz')
-    t.equal(file.extname, '.qux')
-    t.equal(file.dirname, dir.replace(/[/\\]$/, ''))
-    t.equal(file.value, undefined)
-    t.end()
+    assert.equal(file.path, join(dir, 'baz.qux'))
+    assert.equal(file.basename, 'baz.qux')
+    assert.equal(file.stem, 'baz')
+    assert.equal(file.extname, '.qux')
+    assert.equal(file.dirname, dir.replace(/[/\\]$/, ''))
+    assert.equal(file.value, undefined)
   })
 })
 
-test('toVFile.readSync', (t) => {
-  t.equal(toVFile.readSync, readSync, 'should export as an identifier')
+test('toVFile.readSync', async (t) => {
+  assert.equal(toVFile.readSync, readSync, 'should export as an identifier')
 
-  t.test('should fail without path', (t) => {
-    t.throws(() => {
+  await t.test('should fail without path', () => {
+    assert.throws(() => {
       // @ts-expect-error runtime.
       toVFile.readSync()
     }, /path/i)
-
-    t.end()
   })
 
-  t.test('should work (buffer without encoding)', (t) => {
+  await t.test('should work (buffer without encoding)', () => {
     const file = toVFile.readSync('readme.md')
 
-    t.equal(file.path, 'readme.md')
-    t.ok(buffer(file.value))
-    t.equal(file.toString(), fixture)
-    t.end()
+    assert.equal(file.path, 'readme.md')
+    assert.ok(buffer(file.value))
+    assert.equal(file.toString(), fixture)
   })
 
-  t.test('should work (string with encoding)', (t) => {
+  await t.test('should work (string with encoding)', () => {
     const file = toVFile.readSync('readme.md', 'utf8')
 
-    t.equal(file.path, 'readme.md')
-    t.equal(typeof file.value, 'string')
-    t.equal(file.toString(), fixture)
-    t.end()
+    assert.equal(file.path, 'readme.md')
+    assert.equal(typeof file.value, 'string')
+    assert.equal(file.toString(), fixture)
   })
 
-  t.throws(
+  assert.throws(
     () => {
       toVFile.readSync('missing.md')
     },
     /ENOENT/,
     'should throw on non-existing files'
   )
 
-  t.test('should honor file.cwd when file.path is relative', (t) => {
+  await t.test('should honor file.cwd when file.path is relative', () => {
     const cwd = path.join(process.cwd(), 'lib')
     const file = toVFile.readSync({path: 'index.js', cwd}, 'utf8')
 
-    t.equal(typeof file.value, 'string')
-
-    t.end()
+    assert.equal(typeof file.value, 'string')
   })
 
-  t.test(
+  await t.test(
     'should honor file.cwd when file.path is relative, even with relative cwd',
-    (t) => {
+    () => {
       const file = toVFile.readSync({path: 'index.js', cwd: 'lib'}, 'utf8')
 
-      t.equal(typeof file.value, 'string')
-
-      t.end()
+      assert.equal(typeof file.value, 'string')
     }
   )
 
-  t.throws(
+  assert.throws(
     () => {
       toVFile.readSync({
         path: path.join(process.cwd(), 'core.js'),
@@ -141,149 +128,135 @@ test('toVFile.readSync', (t) => {
   )
 })
 
-test('toVFile.read', (t) => {
-  t.equal(toVFile.read, read, 'should export as an identifier')
-
-  t.test('should pass an error without path', (t) => {
-    t.plan(1)
+test('toVFile.read', async (t) => {
+  assert.equal(toVFile.read, read, 'should export as an identifier')
 
-    // @ts-expect-error: not a path.
-    toVFile.read(null, (error) => {
-      t.ok(/path/i.test(String(error)))
+  await t.test('should pass an error without path', async () => {
+    await new Promise((ok) => {
+      // @ts-expect-error: not a path.
+      toVFile.read(null, (error) => {
+        assert.ok(/path/i.test(String(error)))
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should work (buffer without encoding)', (t) => {
-    t.plan(4)
-
-    toVFile.read('readme.md', (error, file) => {
-      t.ifErr(error)
-      assert(file, 'expected file')
-      t.equal(file.path, 'readme.md')
-      t.ok(buffer(file.value))
-      t.equal(file.toString(), fixture)
+  await t.test('should work (buffer without encoding)', async () => {
+    await new Promise((ok) => {
+      toVFile.read('readme.md', (error, file) => {
+        assert.ifError(error)
+        assert(file, 'expected file')
+        assert.equal(file.path, 'readme.md')
+        assert.ok(buffer(file.value))
+        assert.equal(file.toString(), fixture)
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should work in promise mode (buffer without encoding)', (t) => {
-    t.plan(3)
+  await t.test(
+    'should work in promise mode (buffer without encoding)',
+    async () => {
+      const result = await toVFile.read('readme.md')
+      assert.equal(result.path, 'readme.md')
+      assert.ok(buffer(result.value))
+      assert.equal(result.toString(), fixture)
+    }
+  )
 
-    toVFile
-      .read('readme.md')
-      .then((result) => {
-        t.equal(result.path, 'readme.md')
-        t.ok(buffer(result.value))
-        t.equal(result.toString(), fixture)
-      })
-      .catch(() => {
-        t.fail('should resolve, not reject')
+  await t.test('should work (string with encoding)', async () => {
+    await new Promise((ok) => {
+      toVFile.read('readme.md', 'utf8', (error, file) => {
+        assert.ifError(error)
+        assert(file, 'expected file')
+        assert.equal(file.path, 'readme.md')
+        assert.equal(typeof file.value, 'string')
+        assert.equal(file.toString(), fixture)
+        ok(undefined)
       })
-  })
-
-  t.test('should work (string with encoding)', (t) => {
-    t.plan(4)
-
-    toVFile.read('readme.md', 'utf8', (error, file) => {
-      t.ifErr(error)
-      assert(file, 'expected file')
-      t.equal(file.path, 'readme.md')
-      t.equal(typeof file.value, 'string')
-      t.equal(file.toString(), fixture)
     })
   })
 
-  t.test('should work in promise mode (string with encoding)', (t) => {
-    t.plan(3)
-
-    toVFile
-      .read('readme.md', 'utf8')
-      .then((result) => {
-        t.equal(result.path, 'readme.md')
-        t.equal(typeof result.value, 'string')
-        t.equal(result.toString(), fixture)
-      })
-      .catch(() => {
-        t.fail('should resolve, not reject')
-      })
-  })
+  await t.test(
+    'should work in promise mode (string with encoding)',
+    async () => {
+      const result = await toVFile.read('readme.md', 'utf8')
 
-  t.test('should return an error on non-existing files', (t) => {
-    t.plan(3)
+      assert.equal(result.path, 'readme.md')
+      assert.equal(typeof result.value, 'string')
+      assert.equal(result.toString(), fixture)
+    }
+  )
 
-    toVFile.read('missing.md', 'utf8', (error, file) => {
-      assert(error, 'expected error')
-      t.equal(file, undefined)
-      t.ok(error instanceof Error)
-      t.ok(/ENOENT/.test(error.message))
+  await t.test('should return an error on non-existing files', async () => {
+    await new Promise((ok) => {
+      toVFile.read('missing.md', 'utf8', (error, file) => {
+        assert(error, 'expected error')
+        assert.equal(file, undefined)
+        assert.ok(error instanceof Error)
+        assert.ok(/ENOENT/.test(error.message))
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should reject on non-existing files in promise mode', (t) => {
-    t.plan(2)
-
-    toVFile
-      .read('missing.md')
-      .then(() => {
-        t.fail('should reject, not resolve')
-      })
-      .catch((/** @type {Error} */ error) => {
-        t.ok(error instanceof Error)
-        t.ok(/ENOENT/.test(error.message))
-      })
-  })
+  await t.test(
+    'should reject on non-existing files in promise mode',
+    async () => {
+      try {
+        await toVFile.read('missing.md')
+        assert.fail('should reject, not resolve')
+      } catch (error) {
+        assert.ok(error instanceof Error)
+        assert.ok(/ENOENT/.test(error.message))
+      }
+    }
+  )
 })
 
-test('toVFile.writeSync', (t) => {
+test('toVFile.writeSync', async (t) => {
   const filePath = 'fixture.txt'
   const invalidFilePath = join('invalid', 'path', 'to', 'fixture.txt')
 
-  t.equal(toVFile.writeSync, writeSync, 'should export as an identifier')
+  assert.equal(toVFile.writeSync, writeSync, 'should export as an identifier')
 
-  t.test('should fail without path', (t) => {
-    t.throws(() => {
+  await t.test('should fail without path', () => {
+    assert.throws(() => {
       // @ts-expect-error runtime.
       toVFile.writeSync()
     }, /path/i)
-
-    t.end()
   })
 
-  t.test('should work (buffer without encoding)', (t) => {
+  await t.test('should work (buffer without encoding)', () => {
     const result = toVFile.writeSync({
       path: filePath,
       value: Buffer.from('föo')
     })
 
-    t.equal(result.path, filePath)
-    t.equal(String(result), 'föo')
-    t.equal(fs.readFileSync(filePath, 'utf8'), 'föo')
-
-    t.end()
+    assert.equal(result.path, filePath)
+    assert.equal(String(result), 'föo')
+    assert.equal(fs.readFileSync(filePath, 'utf8'), 'föo')
   })
 
-  t.test('should work (string)', (t) => {
+  await t.test('should work (string)', () => {
     const result = toVFile.writeSync({path: filePath, value: 'bär'})
 
-    t.equal(result.path, filePath)
-    t.equal(String(result), 'bär')
-    t.equal(fs.readFileSync(filePath, 'utf8'), 'bär')
-
-    t.end()
+    assert.equal(result.path, filePath)
+    assert.equal(String(result), 'bär')
+    assert.equal(fs.readFileSync(filePath, 'utf8'), 'bär')
   })
 
-  t.test('should work (null)', (t) => {
+  await t.test('should work (null)', () => {
     const result = toVFile.writeSync(filePath)
 
-    t.equal(result.path, filePath)
-    t.equal(String(result), '')
-    t.equal(fs.readFileSync(filePath, 'utf8'), '')
+    assert.equal(result.path, filePath)
+    assert.equal(String(result), '')
+    assert.equal(fs.readFileSync(filePath, 'utf8'), '')
 
     fs.unlinkSync(filePath)
-
-    t.end()
   })
 
-  t.throws(
+  assert.throws(
     () => {
       toVFile.writeSync(invalidFilePath)
     },
@@ -292,143 +265,132 @@ test('toVFile.writeSync', (t) => {
   )
 })
 
-test('toVFile.write', (t) => {
+test('toVFile.write', async (t) => {
   const filePath = 'fixture.txt'
   const invalidFilePath = join('invalid', 'path', 'to', 'fixture.txt')
 
-  t.equal(toVFile.write, write, 'should export as an identifier')
-
-  t.test('should pass an error without path', (t) => {
-    t.plan(1)
+  assert.equal(toVFile.write, write, 'should export as an identifier')
 
-    // @ts-expect-error: missing path.
-    toVFile.write(null, (error) => {
-      t.ok(/path/i.test(String(error)))
+  await t.test('should pass an error without path', async () => {
+    await new Promise((ok) => {
+      // @ts-expect-error: missing path.
+      toVFile.write(null, (error) => {
+        assert.ok(/path/i.test(String(error)))
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should work (buffer without encoding)', (t) => {
+  await t.test('should work (buffer without encoding)', async () => {
     const file = {path: filePath, value: Buffer.from('bäz')}
 
-    t.plan(3)
-
-    toVFile.write(file, (error, result) => {
-      t.ifErr(error)
-      assert(result, 'expected result')
-      t.equal(result.path, filePath)
-      t.equal(fs.readFileSync(filePath, 'utf8'), 'bäz')
+    await new Promise((ok) => {
+      toVFile.write(file, (error, result) => {
+        assert.ifError(error)
+        assert(result, 'expected result')
+        assert.equal(result.path, filePath)
+        assert.equal(fs.readFileSync(filePath, 'utf8'), 'bäz')
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should work (string)', (t) => {
+  await t.test('should work (string)', async () => {
     const file = {path: filePath, value: 'qüx'}
 
-    t.plan(3)
-
-    toVFile.write(file, (error, result) => {
-      t.ifErr(error)
-      assert(result, 'expected result')
-      t.equal(result.path, filePath)
-      t.equal(fs.readFileSync(filePath, 'utf8'), 'qüx')
+    await new Promise((ok) => {
+      toVFile.write(file, (error, result) => {
+        assert.ifError(error)
+        assert(result, 'expected result')
+        assert.equal(result.path, filePath)
+        assert.equal(fs.readFileSync(filePath, 'utf8'), 'qüx')
+        ok(undefined)
+      })
     })
   })
 
-  t.test('should work in promise mode (string)', (t) => {
-    t.plan(2)
-
-    toVFile
-      .write({path: filePath, value: 'qüx-promise'})
-      .then((result) => {
-        t.equal(result.path, filePath)
-        t.equal(fs.readFileSync(filePath, 'utf8'), 'qüx-promise')
-      })
-      .catch(() => {
-        t.fail('should resolve, not reject')
-      })
+  await t.test('should work in promise mode (string)', async () => {
+    const result = await toVFile.write({path: filePath, value: 'qüx-promise'})
+    assert.equal(result.path, filePath)
+    assert.equal(fs.readFileSync(filePath, 'utf8'), 'qüx-promise')
   })
 
-  t.test('should work (string with encoding)', (t) => {
+  await t.test('should work (string with encoding)', async () => {
     const file = {path: filePath, value: '62c3a472'}
 
-    t.plan(3)
-
-    toVFile.write(file, 'hex', (error, result) => {
-      t.ifErr(error)
-      assert(result, 'expected result')
-      t.equal(result.path, filePath)
-      t.equal(fs.readFileSync(filePath, 'utf8'), 'bär')
-    })
-  })
-
-  t.test('should work in promise mode (string with encoding)', (t) => {
-    t.plan(2)
-
-    toVFile
-      .write({path: filePath, value: '62c3a4722d70726f6d697365'}, 'hex')
-      .then((result) => {
-        t.equal(result.path, filePath)
-        t.equal(fs.readFileSync(filePath, 'utf8'), 'bär-promise')
+    await new Promise((ok) => {
+      toVFile.write(file, 'hex', (error, result) => {
+        assert.ifError(error)
+        assert(result, 'expected result')
+        assert.equal(result.path, filePath)
+        assert.equal(fs.readFileSync(filePath, 'utf8'), 'bär')
+        ok(undefined)
       })
-      .catch(() => {
-        t.fail('should resolve, not reject')
-      })
-  })
-
-  t.test('should work (null)', (t) => {
-    t.plan(3)
-
-    toVFile.write(filePath, (error, result) => {
-      const doc = fs.readFileSync(filePath, 'utf8')
-
-      fs.unlinkSync(filePath)
-
-      assert(result, 'expected result')
-      t.ifErr(error)
-      t.equal(result.path, filePath)
-      t.equal(doc, '')
     })
   })
 
-  t.test('should work in promise mode (null)', (t) => {
-    t.plan(2)
+  await t.test(
+    'should work in promise mode (string with encoding)',
+    async () => {
+      const result = await toVFile.write(
+        {path: filePath, value: '62c3a4722d70726f6d697365'},
+        'hex'
+      )
+      assert.equal(result.path, filePath)
+      assert.equal(fs.readFileSync(filePath, 'utf8'), 'bär-promise')
+    }
+  )
 
-    toVFile
-      .write(filePath)
-      .then((result) => {
+  await t.test('should work (null)', async () => {
+    await new Promise((ok) => {
+      toVFile.write(filePath, (error, result) => {
         const doc = fs.readFileSync(filePath, 'utf8')
 
         fs.unlinkSync(filePath)
 
-        t.equal(result.path, filePath)
-        t.equal(doc, '')
-      })
-      .catch(() => {
-        t.fail('should resolve, not reject')
+        assert(result, 'expected result')
+        assert.ifError(error)
+        assert.equal(result.path, filePath)
+        assert.equal(doc, '')
+        ok(undefined)
       })
+    })
   })
 
-  t.test('should pass an error for files that cannot be written', (t) => {
-    t.plan(1)
+  await t.test('should work in promise mode (null)', async () => {
+    const result = await toVFile.write(filePath)
 
-    toVFile.write(invalidFilePath, (error) => {
-      assert(error, 'expected error')
-      t.ok(/ENOENT/.test(error.message))
-    })
-  })
+    const doc = fs.readFileSync(filePath, 'utf8')
 
-  t.test(
-    'should reject for files that cannot be written in promise mode',
-    (t) => {
-      t.plan(1)
+    fs.unlinkSync(filePath)
 
-      toVFile
-        .write(invalidFilePath)
-        .then(() => {
-          t.fail('should reject, not resolve')
-        })
-        .catch((/** @type {Error} */ error) => {
-          t.ok(/ENOENT/.test(error.message))
+    assert.equal(result.path, filePath)
+    assert.equal(doc, '')
+  })
+
+  await t.test(
+    'should pass an error for files that cannot be written',
+    async () => {
+      await new Promise((ok) => {
+        toVFile.write(invalidFilePath, (error) => {
+          assert(error, 'expected error')
+          assert.ok(/ENOENT/.test(error.message))
+          ok(undefined)
         })
+      })
+    }
+  )
+
+  await t.test(
+    'should reject for files that cannot be written in promise mode',
+    async () => {
+      try {
+        await toVFile.write(invalidFilePath)
+        assert.fail('should reject, not resolve')
+      } catch (error) {
+        assert(error instanceof Error)
+        assert.ok(/ENOENT/.test(error.message))
+      }
     }
   )
 })