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

@@ -37,7 +37,7 @@
     "mdast-util-mdx-expression": "^1.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",

test.js

@@ -6,58 +6,59 @@
  * @typedef {import('mdast-util-mdx-expression').MDXTextExpression} MDXTextExpression
  */
 
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {commentMarker} from './index.js'
 
-test('commentMaker(node)', (t) => {
+test('commentMaker(node)', () => {
   // @ts-expect-error: runtime: not enough arguments.
-  t.equal(commentMarker(), null, 'should work without node')
+  assert.equal(commentMarker(), null, 'should work without node')
 
   /** @type {Paragraph} */
   const paragraph = {type: 'paragraph', children: []}
 
-  t.equal(commentMarker(paragraph), null, 'should work without html node')
+  assert.equal(commentMarker(paragraph), null, 'should work without html node')
 
   /** @type {HTML} */
   let html = {type: 'html', value: '<div></div>'}
 
-  t.equal(commentMarker(html), null, 'should work without comment')
+  assert.equal(commentMarker(html), null, 'should work without comment')
 
   html = {type: 'html', value: '<!-- -->'}
 
-  t.equal(commentMarker(html), null, 'should work for empty comments')
+  assert.equal(commentMarker(html), null, 'should work for empty comments')
 
   html = {type: 'html', value: '<!--foo-->this is something else.'}
 
-  t.equal(commentMarker(html), null, 'should work for partial comments')
+  assert.equal(commentMarker(html), null, 'should work for partial comments')
 
   html = {type: 'html', value: '<!--foo-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {name: 'foo', attributes: '', parameters: {}, node: html},
     'marker without attributes'
   )
 
   html = {type: 'html', value: '<!-- foo -->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {name: 'foo', attributes: '', parameters: {}, node: html},
     'marker without attributes ignoring spaces'
   )
 
   html = {type: 'html', value: '<!--foo bar-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {name: 'foo', attributes: 'bar', parameters: {bar: true}, node: html},
     'marker with boolean attributes'
   )
 
   html = {type: 'html', value: '<!--foo bar=baz qux-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -70,7 +71,7 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: '<!--foo bar="baz qux"-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -83,7 +84,7 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: "<!--foo bar='baz qux'-->"}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -96,7 +97,7 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: '<!--foo bar=3-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -109,7 +110,7 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: '<!--foo bar=true-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -122,7 +123,7 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: '<!--foo bar=false-->'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(html),
     {
       name: 'foo',
@@ -135,52 +136,62 @@ test('commentMaker(node)', (t) => {
 
   html = {type: 'html', value: '<!--foo bar=-->'}
 
-  t.equal(commentMarker(html), null, 'marker stop for invalid parameters (#1)')
+  assert.equal(
+    commentMarker(html),
+    null,
+    'marker stop for invalid parameters (#1)'
+  )
 
   html = {type: 'html', value: '<!--foo bar= qux-->'}
 
-  t.equal(commentMarker(html), null, 'marker stop for invalid parameters (#2)')
+  assert.equal(
+    commentMarker(html),
+    null,
+    'marker stop for invalid parameters (#2)'
+  )
 
   html = {type: 'html', value: '<!--foo |-->'}
 
-  t.equal(commentMarker(html), null, 'marker stop for invalid parameters (#3)')
-
-  t.end()
+  assert.equal(
+    commentMarker(html),
+    null,
+    'marker stop for invalid parameters (#3)'
+  )
 })
 
-test('comment node', (t) => {
+test('comment node', () => {
   /** @type {Literal & {type: 'comment'}} */
   let comment = {type: 'comment', value: ' '}
 
-  t.equal(commentMarker(comment), null, 'should work for empty comments')
+  assert.equal(commentMarker(comment), null, 'should work for empty comments')
 
   comment = {type: 'comment', value: 'foo'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {name: 'foo', attributes: '', parameters: {}, node: comment},
     'comment without attributes'
   )
 
   comment = {type: 'comment', value: ' foo '}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {name: 'foo', attributes: '', parameters: {}, node: comment},
     'comment without attributes ignoring spaces'
   )
 
   comment = {type: 'comment', value: 'foo bar'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {name: 'foo', attributes: 'bar', parameters: {bar: true}, node: comment},
     'comment with boolean attributes'
   )
 
   comment = {type: 'comment', value: 'foo bar=baz qux'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -193,7 +204,7 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: 'foo bar="baz qux"'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -206,7 +217,7 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: "foo bar='baz qux'"}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -219,7 +230,7 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: 'foo bar=3'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -232,7 +243,7 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: 'foo bar=true'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -245,7 +256,7 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: 'foo bar=false'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(comment),
     {
       name: 'foo',
@@ -258,39 +269,37 @@ test('comment node', (t) => {
 
   comment = {type: 'comment', value: 'foo bar='}
 
-  t.equal(
+  assert.equal(
     commentMarker(comment),
     null,
     'marker stop for invalid parameters (#1)'
   )
 
   comment = {type: 'comment', value: 'foo bar= qux'}
 
-  t.equal(
+  assert.equal(
     commentMarker(comment),
     null,
     'marker stop for invalid parameters (#2)'
   )
 
   comment = {type: 'comment', value: 'foo |'}
 
-  t.equal(
+  assert.equal(
     commentMarker(comment),
     null,
     'marker stop for invalid parameters (#3)'
   )
-
-  t.end()
 })
 
-test('MDX@2 expressions', (t) => {
+test('MDX@2 expressions', () => {
   /** @type {MDXFlowExpression|MDXTextExpression} */
   let node = {
     type: 'mdxFlowExpression',
     value: '/* lint disable heading-style */'
   }
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(node),
     {
       name: 'lint',
@@ -303,11 +312,9 @@ test('MDX@2 expressions', (t) => {
 
   node = {type: 'mdxTextExpression', value: '/* lint enable */'}
 
-  t.deepEqual(
+  assert.deepEqual(
     commentMarker(node),
     {name: 'lint', attributes: 'enable', parameters: {enable: true}, node},
     'should work for comments'
   )
-
-  t.end()
 })