Use Node test runner

Author: wooorm

.github/workflows/main.yml

@@ -7,8 +7,8 @@ jobs:
     name: ${{matrix.node}}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: dcodeIO/setup-node-nvm@master
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
           node-version: ${{matrix.node}}
       - run: npm install
@@ -17,5 +17,5 @@ jobs:
     strategy:
       matrix:
         node:
-          - lts/erbium
+          - lts/hydrogen
           - node

package.json

@@ -27,13 +27,12 @@
     "index.js"
   ],
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.00",
     "c8": "^7.0.0",
     "cept": "^2.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.52.0"

test.js

@@ -1,96 +1,88 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {cept} from 'cept'
 import {toJson} from './index.js'
 
-test('toJson', function (t) {
-  t.equal(typeof toJson, 'function', 'should be a `function`')
-  t.end()
+test('toJson', function () {
+  assert.equal(typeof toJson, 'function', 'should be a `function`')
 })
 
-test('Comments', function (t) {
-  t.deepEqual(
+test('Comments', function () {
+  assert.deepEqual(
     toJson(['% This is a completely commented line.', 'unicorn'].join('\n')),
     ['unicorn'],
     'should strip line comments'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn % This is a partially commented line.'),
     ['unicorn'],
     'should strip partial line comments'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn % This is a partially commented line.', {
       comment: false
     }),
     ['unicorn % This is a partially commented line.'],
     'should honour `comment: false`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson(['# This is a completely commented line.', 'unicorn'].join('\n'), {
       comment: '#'
     }),
     ['unicorn'],
     'should strip line comments based on a given token'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn # This is a partially commented line.', {
       comment: '#'
     }),
     ['unicorn'],
     'should strip partial comments based on a given token'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn # 1\n% 2\ndoge', {
       comment: ['#', '%']
     }),
     ['doge', 'unicorn'],
     'should strip partial comments based on a given token'
   )
-
-  t.end()
 })
 
-test('White space', function (t) {
-  t.deepEqual(
+test('White space', function () {
+  assert.deepEqual(
     toJson('  \tunicorn  \t'),
     ['unicorn'],
     'should trim prefixed and suffixed white space'
   )
-
-  t.end()
 })
 
-test('Blank lines', function (t) {
-  t.deepEqual(
+test('Blank lines', function () {
+  assert.deepEqual(
     toJson('\n  \t  \ndoge\n\nunicorn\r\n'),
     ['doge', 'unicorn'],
     'should remove empty / blank lines'
   )
-
-  t.end()
 })
 
-test('EOF', function (t) {
-  t.deepEqual(toJson('unicorn'), ['unicorn'], 'No EOL')
-  t.deepEqual(toJson('unicorn\n'), ['unicorn'], 'LF')
-  t.deepEqual(toJson('unicorn\r\n'), ['unicorn'], 'CR+LF')
-
-  t.end()
+test('EOF', function () {
+  assert.deepEqual(toJson('unicorn'), ['unicorn'], 'No EOL')
+  assert.deepEqual(toJson('unicorn\n'), ['unicorn'], 'LF')
+  assert.deepEqual(toJson('unicorn\r\n'), ['unicorn'], 'CR+LF')
 })
 
-test('Property-value pairs', function (t) {
-  t.deepEqual(
+test('Property-value pairs', function () {
+  assert.deepEqual(
     toJson('unicorn: magic creature'),
     {unicorn: 'magic creature'},
     'should support pair delimiters'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson(
       [
         'unicorn : magic creature',
@@ -106,55 +98,49 @@ test('Property-value pairs', function (t) {
     'white-space around pair delimiters'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn\tmagic creature', {delimiter: '\t'}),
     {unicorn: 'magic creature'},
     'given delimiters'
   )
-
-  t.end()
 })
 
-test('Values', function (t) {
-  t.deepEqual(toJson('unicorn'), ['unicorn'], 'one value')
+test('Values', function () {
+  assert.deepEqual(toJson('unicorn'), ['unicorn'], 'one value')
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn \n doge\n\trainbow'),
     ['doge', 'rainbow', 'unicorn'],
     'multiple values'
   )
-
-  t.end()
 })
 
-test('Mixed values', function (t) {
-  t.throws(
+test('Mixed values', function () {
+  assert.throws(
     function () {
       toJson('unicorn\nrainbow: double')
     },
     /^Error: Error at `rainbow,double`/,
     'should throw when both property-value pairs and values are provided'
   )
-
-  t.end()
 })
 
-test('Invalid lists', function (t) {
-  t.throws(
+test('Invalid lists', async function (t) {
+  assert.throws(
     function () {
       toJson('unicorn\nrainbow\nunicorn')
     },
     /^Error: Error at `unicorn`: Duplicate data found/,
     'should throw when duplicate values exist'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('unicorn\nrainbow\nunicorn', {forgiving: true}),
     ['rainbow', 'unicorn', 'unicorn'],
     'should honour forgiving'
   )
 
-  t.test('should log duplicate values when `forgiving`', function (st) {
+  await t.test('should log duplicate values when `forgiving`', function () {
     const stop = cept(console, 'log', hoist)
     /** @type {Array<unknown>} */
     let parameters = []
@@ -163,15 +149,14 @@ test('Invalid lists', function (t) {
 
     stop()
 
-    st.equal(parameters[0], 'Ignoring duplicate key for `unicorn`')
-    st.end()
+    assert.equal(parameters[0], 'Ignoring duplicate key for `unicorn`')
 
     function hoist() {
       parameters = [...arguments]
     }
   })
 
-  t.test('should honour `log: false`', function (st) {
+  await t.test('should honour `log: false`', function () {
     const stop = cept(console, 'log', hoist)
     /** @type {Array<unknown>|undefined} */
     let parameters
@@ -180,35 +165,32 @@ test('Invalid lists', function (t) {
 
     stop()
 
-    st.equal(parameters, undefined)
-    st.end()
+    assert.equal(parameters, undefined)
 
     function hoist() {
       parameters = [...arguments]
     }
   })
-
-  t.end()
 })
 
-test('Invalid objects', function (t) {
-  t.throws(
+test('Invalid objects', async function (t) {
+  assert.throws(
     function () {
       toJson('doge: so scare\nunicorn: magic\ndoge: double')
     },
     /^Error: Error at `doge,double`: Duplicate data found/,
     'should throw when duplicate values exist'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('doge: so scare\nunicorn: magic creature\ndoge: so scare\n', {
       forgiving: true
     }),
     {doge: 'so scare', unicorn: 'magic creature'},
     'should honour forgiving'
   )
 
-  t.test('should log duplicate values when `forgiving`', function (st) {
+  await t.test('should log duplicate values when `forgiving`', function () {
     const stop = cept(console, 'log', hoist)
     /** @type {Array<unknown>} */
     let parameters = []
@@ -219,15 +201,14 @@ test('Invalid objects', function (t) {
 
     stop()
 
-    st.equal(parameters[0], 'Ignoring duplicate key for `doge`')
-    st.end()
+    assert.equal(parameters[0], 'Ignoring duplicate key for `doge`')
 
     function hoist() {
       parameters = [...arguments]
     }
   })
 
-  t.test('should honour `log: false`', function (st) {
+  await t.test('should honour `log: false`', function () {
     const stop = cept(console, 'log', hoist)
     /** @type {Array<unknown>|undefined} */
     let parameters
@@ -239,33 +220,32 @@ test('Invalid objects', function (t) {
 
     stop()
 
-    st.equal(parameters, undefined)
-    st.end()
+    assert.equal(parameters, undefined)
 
     function hoist() {
       parameters = [...arguments]
     }
   })
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('doge: so scare\nunicorn: magic creature\ndoge: so scare\n', {
       forgiving: 'fix'
     }),
     {doge: 'so scare', unicorn: 'magic creature'},
     "should honour `forgiving: 'fix'`"
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toJson('doge: so scare\nunicorn: magic creature\ndoge: rainbows\n', {
       forgiving: 'fix'
     }),
     {doge: 'rainbows', unicorn: 'magic creature'},
     'duplicate keys with different values'
   )
 
-  t.test(
+  await t.test(
     'should log for duplicate keys when `forgiving` is `"fix"',
-    function (st) {
+    function () {
       const stop = cept(console, 'log', hoist)
       /** @type {Array<unknown>} */
       let parameters = []
@@ -276,14 +256,11 @@ test('Invalid objects', function (t) {
 
       stop()
 
-      st.equal(parameters[0], 'Ignoring duplicate key for `doge`')
-      st.end()
+      assert.equal(parameters[0], 'Ignoring duplicate key for `doge`')
 
       function hoist() {
         parameters = [...arguments]
       }
     }
   )
-
-  t.end()
 })