chore: migrate a batch of tests to node test runner (#2742)

Author: Uzlopak

test/client-errors.js

@@ -1,28 +1,31 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client } = require('..')
 const net = require('node:net')
 
 // TODO: move to test/node-test/client-connect.js
-test('parser error', (t) => {
-  t.plan(2)
+test('parser error', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = net.createServer()
   server.once('connection', (socket) => {
     socket.write('asd\n\r213123')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.request({ path: '/', method: 'GET' }, (err) => {
       t.ok(err)
       client.close((err) => {
-        t.error(err)
+        t.ifError(err)
       })
     })
   })
+
+  await t.completed
 })

test/client-stream.js

@@ -1,18 +1,19 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test } = require('node:test')
 const { Client } = require('..')
 const { PassThrough } = require('node:stream')
 
-test(t => {
-  t.plan(2)
+test('connect-abort', async t => {
+  t = tspl(t, { plan: 2 })
 
   const client = new Client('http://localhost:1234', {
     connect: (_, cb) => {
       client.destroy()
       cb(null, new PassThrough({
         destroy (err, cb) {
-          t.same(err?.name, 'ClientDestroyedError')
+          t.strictEqual(err.name, 'ClientDestroyedError')
           cb(null)
         }
       }))
@@ -23,6 +24,8 @@ test(t => {
     path: '/',
     method: 'GET'
   }, (err, data) => {
-    t.same(err?.name, 'ClientDestroyedError')
+    t.strictEqual(err.name, 'ClientDestroyedError')
   })
+
+  await t.completed
 })

test/connect-abort.js

@@ -1,24 +1,25 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const undici = require('..')
 const { createServer } = require('node:http')
 const { Readable } = require('node:stream')
 const { maybeWrapStream, consts } = require('./utils/async-iterators')
 
 function doNotKillReqSocket (bodyType) {
-  test(`do not kill req socket ${bodyType}`, (t) => {
-    t.plan(3)
+  test(`do not kill req socket ${bodyType}`, async (t) => {
+    t = tspl(t, { plan: 3 })
 
     const server1 = createServer((req, res) => {
       const client = new undici.Client(`http://localhost:${server2.address().port}`)
-      t.teardown(client.close.bind(client))
+      after(() => client.close())
       client.request({
         path: '/',
         method: 'POST',
         body: req
       }, (err, response) => {
-        t.error(err)
+        t.ifError(err)
         setTimeout(() => {
           response.body.on('data', buf => {
             res.write(buf)
@@ -29,18 +30,18 @@ function doNotKillReqSocket (bodyType) {
         }, 100)
       })
     })
-    t.teardown(server1.close.bind(server1))
+    after(() => server1.close())
 
     const server2 = createServer((req, res) => {
       setTimeout(() => {
         req.pipe(res)
       }, 100)
     })
-    t.teardown(server2.close.bind(server2))
+    after(() => server2.close())
 
     server1.listen(0, () => {
       const client = new undici.Client(`http://localhost:${server1.address().port}`)
-      t.teardown(client.close.bind(client))
+      after(() => client.close())
 
       const r = new Readable({ read () {} })
       r.push('hello')
@@ -49,19 +50,21 @@ function doNotKillReqSocket (bodyType) {
         method: 'POST',
         body: maybeWrapStream(r, bodyType)
       }, (err, response) => {
-        t.error(err)
+        t.ifError(err)
         const bufs = []
         response.body.on('data', (buf) => {
           bufs.push(buf)
           r.push(null)
         })
         response.body.on('end', () => {
-          t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+          t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
         })
       })
     })
 
     server2.listen(0)
+
+    await t.completed
   })
 }
 

test/http-req-destroy.js

@@ -1,74 +1,79 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client } = require('..')
 const { createServer } = require('node:https')
 const pem = require('https-pem')
 
-test('https get with tls opts', (t) => {
-  t.plan(6)
+test('https get with tls opts', async (t) => {
+  t = tspl(t, { plan: 6 })
 
   const server = createServer(pem, (req, res) => {
-    t.equal('/', req.url)
-    t.equal('GET', req.method)
+    t.strictEqual('/', req.url)
+    t.strictEqual('GET', req.method)
     res.setHeader('content-type', 'text/plain')
     res.end('hello')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`https://localhost:${server.address().port}`, {
       tls: {
         rejectUnauthorized: false
       }
     })
-    t.teardown(client.close.bind(client))
+    after(() => client.close())
 
     client.request({ path: '/', method: 'GET' }, (err, { statusCode, headers, body }) => {
-      t.error(err)
-      t.equal(statusCode, 200)
-      t.equal(headers['content-type'], 'text/plain')
+      t.ifError(err)
+      t.strictEqual(statusCode, 200)
+      t.strictEqual(headers['content-type'], 'text/plain')
       const bufs = []
       body.on('data', (buf) => {
         bufs.push(buf)
       })
       body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
       })
     })
   })
+
+  await t.completed
 })
 
-test('https get with tls opts ip', (t) => {
-  t.plan(6)
+test('https get with tls opts ip', async (t) => {
+  t = tspl(t, { plan: 6 })
 
   const server = createServer(pem, (req, res) => {
-    t.equal('/', req.url)
-    t.equal('GET', req.method)
+    t.strictEqual('/', req.url)
+    t.strictEqual('GET', req.method)
     res.setHeader('content-type', 'text/plain')
     res.end('hello')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`https://127.0.0.1:${server.address().port}`, {
       tls: {
         rejectUnauthorized: false
       }
     })
-    t.teardown(client.close.bind(client))
+    after(() => client.close())
 
     client.request({ path: '/', method: 'GET' }, (err, { statusCode, headers, body }) => {
-      t.error(err)
-      t.equal(statusCode, 200)
-      t.equal(headers['content-type'], 'text/plain')
+      t.ifError(err)
+      t.strictEqual(statusCode, 200)
+      t.strictEqual(headers['content-type'], 'text/plain')
       const bufs = []
       body.on('data', (buf) => {
         bufs.push(buf)
       })
       body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
       })
     })
   })
+
+  await t.completed
 })

test/https.js

@@ -1,73 +1,76 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after, describe } = require('node:test')
 const { Client, errors } = require('..')
 const { createServer } = require('node:http')
 
-test('max response size', (t) => {
-  t.plan(4)
-
-  t.test('default max default size should allow all responses', (t) => {
-    t.plan(3)
+describe('max response size', async (t) => {
+  test('default max default size should allow all responses', async (t) => {
+    t = tspl(t, { plan: 3 })
 
     const server = createServer()
-    t.teardown(server.close.bind(server))
+    after(() => server.close())
 
     server.on('request', (req, res) => {
       res.end('hello')
     })
 
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`, { maxResponseSize: -1 })
-      t.teardown(client.close.bind(client))
+      after(() => client.close())
 
       client.request({ path: '/', method: 'GET' }, (err, { statusCode, body }) => {
-        t.error(err)
-        t.equal(statusCode, 200)
+        t.ifError(err)
+        t.strictEqual(statusCode, 200)
         const bufs = []
         body.on('data', (buf) => {
           bufs.push(buf)
         })
         body.on('end', () => {
-          t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+          t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
         })
       })
     })
+
+    await t.completed
   })
 
-  t.test('max response size set to zero should allow only empty responses', (t) => {
-    t.plan(3)
+  test('max response size set to zero should allow only empty responses', async (t) => {
+    t = tspl(t, { plan: 3 })
 
     const server = createServer()
-    t.teardown(server.close.bind(server))
+    after(() => server.close())
 
     server.on('request', (req, res) => {
       res.end()
     })
 
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`, { maxResponseSize: 0 })
-      t.teardown(client.close.bind(client))
+      after(() => client.close())
 
       client.request({ path: '/', method: 'GET' }, (err, { statusCode, body }) => {
-        t.error(err)
-        t.equal(statusCode, 200)
+        t.ifError(err)
+        t.strictEqual(statusCode, 200)
         const bufs = []
         body.on('data', (buf) => {
           bufs.push(buf)
         })
         body.on('end', () => {
-          t.equal('', Buffer.concat(bufs).toString('utf8'))
+          t.strictEqual('', Buffer.concat(bufs).toString('utf8'))
         })
       })
     })
+
+    await t.completed
   })
 
-  t.test('should throw an error if the response is too big', (t) => {
-    t.plan(3)
+  test('should throw an error if the response is too big', async (t) => {
+    t = tspl(t, { plan: 3 })
 
     const server = createServer()
-    t.teardown(server.close.bind(server))
+    after(() => server.close())
 
     server.on('request', (req, res) => {
       res.end('hello')
@@ -78,20 +81,22 @@ test('max response size', (t) => {
         maxResponseSize: 1
       })
 
-      t.teardown(client.close.bind(client))
+      after(() => client.close())
 
       client.request({ path: '/', method: 'GET' }, (err, { body }) => {
-        t.error(err)
+        t.ifError(err)
         body.on('error', (err) => {
           t.ok(err)
           t.ok(err instanceof errors.ResponseExceededMaxSizeError)
         })
       })
     })
+
+    await t.completed
   })
 
-  t.test('invalid max response size should throw an error', (t) => {
-    t.plan(2)
+  test('invalid max response size should throw an error', async (t) => {
+    t = tspl(t, { plan: 2 })
 
     t.throws(() => {
       // eslint-disable-next-line no-new
@@ -102,4 +107,6 @@ test('max response size', (t) => {
       new Client('http://localhost:3000', { maxResponseSize: -2 })
     }, 'maxResponseSize must be greater than or equal to -1')
   })
+
+  await t.completed
 })

test/max-response-size.js

@@ -1,9 +1,12 @@
+'use strict'
+
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const net = require('node:net')
-const { test } = require('tap')
 const { Client, errors } = require('..')
 
-test('https://github.com/mcollina/undici/issues/268', (t) => {
-  t.plan(2)
+test('https://github.com/mcollina/undici/issues/268', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = net.createServer(socket => {
     socket.write('HTTP/1.1 200 OK\r\n')
@@ -17,18 +20,18 @@ test('https://github.com/mcollina/undici/issues/268', (t) => {
       }, 500)
     }, 500)
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.request({
       method: 'GET',
       path: '/nxt/_changes?feed=continuous&heartbeat=5000',
       headersTimeout: 1e3
     }, (err, data) => {
-      t.error(err)
+      t.ifError(err)
       data.body
         .resume()
       setTimeout(() => {
@@ -37,19 +40,21 @@ test('https://github.com/mcollina/undici/issues/268', (t) => {
       }, 2e3)
     })
   })
+
+  await t.completed
 })
 
-test('parser fail', (t) => {
-  t.plan(2)
+test('parser fail', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = net.createServer(socket => {
     socket.write('HTT/1.1 200 OK\r\n')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.request({
       method: 'GET',
@@ -59,56 +64,62 @@ test('parser fail', (t) => {
       t.ok(err instanceof errors.HTTPParserError)
     })
   })
+
+  await t.completed
 })
 
-test('split header field', (t) => {
-  t.plan(2)
+test('split header field', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = net.createServer(socket => {
     socket.write('HTTP/1.1 200 OK\r\nA')
     setTimeout(() => {
       socket.write('SD: asd,asd\r\n\r\n\r\n')
     }, 100)
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.request({
       method: 'GET',
       path: '/'
     }, (err, data) => {
-      t.error(err)
+      t.ifError(err)
       t.equal(data.headers.asd, 'asd,asd')
       data.body.destroy().on('error', () => {})
     })
   })
+
+  await t.completed
 })
 
-test('split header value', (t) => {
-  t.plan(2)
+test('split header value', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = net.createServer(socket => {
     socket.write('HTTP/1.1 200 OK\r\nASD: asd')
     setTimeout(() => {
       socket.write(',asd\r\n\r\n\r\n')
     }, 100)
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.request({
       method: 'GET',
       path: '/'
     }, (err, data) => {
-      t.error(err)
+      t.ifError(err)
       t.equal(data.headers.asd, 'asd,asd')
       data.body.destroy().on('error', () => {})
     })
   })
+
+  await t.completed
 })

test/parser-issues.js

@@ -1,25 +1,26 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client } = require('..')
 const { createServer } = require('node:http')
 const { kConnect } = require('../lib/core/symbols')
 const { kBusy, kPending, kRunning } = require('../lib/core/symbols')
 
-test('pipeline pipelining', (t) => {
-  t.plan(10)
+test('pipeline pipelining', async (t) => {
+  t = tspl(t, { plan: 10 })
 
   const server = createServer((req, res) => {
-    t.strictSame(req.headers['transfer-encoding'], undefined)
+    t.deepStrictEqual(req.headers['transfer-encoding'], undefined)
     res.end()
   })
 
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`, {
       pipelining: 2
     })
-    t.teardown(client.close.bind(client))
+    after(() => client.close())
 
     client[kConnect](() => {
       t.equal(client[kRunning], 0)
@@ -28,25 +29,27 @@ test('pipeline pipelining', (t) => {
         path: '/'
       }, ({ body }) => body).end().resume()
       t.equal(client[kBusy], true)
-      t.strictSame(client[kRunning], 0)
-      t.strictSame(client[kPending], 1)
+      t.deepStrictEqual(client[kRunning], 0)
+      t.deepStrictEqual(client[kPending], 1)
 
       client.pipeline({
         method: 'GET',
         path: '/'
       }, ({ body }) => body).end().resume()
       t.equal(client[kBusy], true)
-      t.strictSame(client[kRunning], 0)
-      t.strictSame(client[kPending], 2)
+      t.deepStrictEqual(client[kRunning], 0)
+      t.deepStrictEqual(client[kPending], 2)
       process.nextTick(() => {
         t.equal(client[kRunning], 2)
       })
     })
   })
+
+  await t.completed
 })
 
-test('pipeline pipelining retry', (t) => {
-  t.plan(13)
+test('pipeline pipelining retry', async (t) => {
+  t = tspl(t, { plan: 13 })
 
   let count = 0
   const server = createServer((req, res) => {
@@ -57,12 +60,12 @@ test('pipeline pipelining retry', (t) => {
     }
   })
 
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`, {
       pipelining: 3
     })
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     client.once('disconnect', () => {
       t.ok(true, 'pass')
@@ -77,24 +80,24 @@ test('pipeline pipelining retry', (t) => {
           t.ok(err)
         })
       t.equal(client[kBusy], true)
-      t.strictSame(client[kRunning], 0)
-      t.strictSame(client[kPending], 1)
+      t.deepStrictEqual(client[kRunning], 0)
+      t.deepStrictEqual(client[kPending], 1)
 
       client.pipeline({
         method: 'GET',
         path: '/'
       }, ({ body }) => body).end().resume()
       t.equal(client[kBusy], true)
-      t.strictSame(client[kRunning], 0)
-      t.strictSame(client[kPending], 2)
+      t.deepStrictEqual(client[kRunning], 0)
+      t.deepStrictEqual(client[kPending], 2)
 
       client.pipeline({
         method: 'GET',
         path: '/'
       }, ({ body }) => body).end().resume()
       t.equal(client[kBusy], true)
-      t.strictSame(client[kRunning], 0)
-      t.strictSame(client[kPending], 3)
+      t.deepStrictEqual(client[kRunning], 0)
+      t.deepStrictEqual(client[kPending], 3)
 
       process.nextTick(() => {
         t.equal(client[kRunning], 3)
@@ -105,4 +108,6 @@ test('pipeline pipelining retry', (t) => {
       })
     })
   })
+
+  await t.completed
 })

test/pipeline-pipelining.js

@@ -1,73 +1,76 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client, errors } = require('..')
 const timers = require('../lib/timers')
 const { createServer } = require('node:http')
 const FakeTimers = require('@sinonjs/fake-timers')
 
-test('timeout with pipelining 1', (t) => {
-  t.plan(9)
+test('timeout with pipelining 1', async (t) => {
+  t = tspl(t, { plan: 9 })
 
   const server = createServer()
 
   server.once('request', (req, res) => {
     t.ok(true, 'first request received, we are letting this timeout on the client')
 
     server.once('request', (req, res) => {
-      t.equal('/', req.url)
-      t.equal('GET', req.method)
+      t.strictEqual('/', req.url)
+      t.strictEqual('GET', req.method)
       res.setHeader('content-type', 'text/plain')
       res.end('hello')
     })
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`, {
       pipelining: 1,
       headersTimeout: 500,
       bodyTimeout: 500
     })
-    t.teardown(client.close.bind(client))
+    after(() => client.close())
 
     client.request({
       path: '/',
       method: 'GET',
       opaque: 'asd'
     }, (err, data) => {
       t.ok(err instanceof errors.HeadersTimeoutError) // we are expecting an error
-      t.equal(data.opaque, 'asd')
+      t.strictEqual(data.opaque, 'asd')
     })
 
     client.request({
       path: '/',
       method: 'GET'
     }, (err, { statusCode, headers, body }) => {
-      t.error(err)
-      t.equal(statusCode, 200)
-      t.equal(headers['content-type'], 'text/plain')
+      t.ifError(err)
+      t.strictEqual(statusCode, 200)
+      t.strictEqual(headers['content-type'], 'text/plain')
       const bufs = []
       body.on('data', (buf) => {
         bufs.push(buf)
       })
       body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
       })
     })
   })
+
+  await t.completed
 })
 
-test('Disable socket timeout', (t) => {
-  t.plan(2)
+test('Disable socket timeout', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = createServer()
   const clock = FakeTimers.install()
-  t.teardown(clock.uninstall.bind(clock))
+  after(clock.uninstall.bind(clock))
 
   const orgTimers = { ...timers }
   Object.assign(timers, { setTimeout, clearTimeout })
-  t.teardown(() => {
+  after(() => {
     Object.assign(timers, orgTimers)
   })
 
@@ -77,24 +80,26 @@ test('Disable socket timeout', (t) => {
     }, 31e3)
     clock.tick(32e3)
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`, {
       bodyTimeout: 0,
       headersTimeout: 0
     })
-    t.teardown(client.close.bind(client))
+    after(() => client.close())
 
     client.request({ path: '/', method: 'GET' }, (err, result) => {
-      t.error(err)
+      t.ifError(err)
       const bufs = []
       result.body.on('data', (buf) => {
         bufs.push(buf)
       })
       result.body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
       })
     })
   })
+
+  await t.completed
 })

test/socket-timeout.js

@@ -1,21 +1,22 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client } = require('..')
 const { createServer } = require('node:http')
 const { Readable } = require('node:stream')
 const EE = require('node:events')
 
-test('stream body without destroy', (t) => {
-  t.plan(2)
+test('stream body without destroy', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = createServer((req, res) => {
     res.end()
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    after(() => client.destroy())
 
     const signal = new EE()
     const body = new Readable({ read () {} })
@@ -33,43 +34,47 @@ test('stream body without destroy', (t) => {
     })
     signal.emit('abort')
   })
+
+  await t.completed
 })
 
-test('IncomingMessage', (t) => {
-  t.plan(2)
+test('IncomingMessage', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = createServer((req, res) => {
     res.end()
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
 
   server.listen(0, () => {
     const proxyClient = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(proxyClient.destroy.bind(proxyClient))
+    after(() => proxyClient.destroy())
 
     const proxy = createServer((req, res) => {
       proxyClient.request({
         path: '/',
         method: 'PUT',
         body: req
       }, (err, data) => {
-        t.error(err)
+        t.ifError(err)
         data.body.pipe(res)
       })
     })
-    t.teardown(proxy.close.bind(proxy))
+    after(() => proxy.close())
 
     proxy.listen(0, () => {
       const client = new Client(`http://localhost:${proxy.address().port}`)
-      t.teardown(client.destroy.bind(client))
+      after(() => client.destroy())
 
       client.request({
         path: '/',
         method: 'PUT',
         body: 'hello world'
       }, (err, data) => {
-        t.error(err)
+        t.ifError(err)
       })
     })
   })
+
+  await t.completed
 })

test/stream-compat.js

@@ -1,35 +1,37 @@
 'use strict'
 
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
 const { Client } = require('..')
 const { createServer } = require('node:http')
 
-test('response trailers missing is OK', (t) => {
-  t.plan(1)
+test('response trailers missing is OK', async (t) => {
+  t = tspl(t, { plan: 1 })
 
   const server = createServer((req, res) => {
     res.writeHead(200, {
       Trailer: 'content-length'
     })
     res.end('response')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
   server.listen(0, async () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
-
+    after(() => client.destroy())
     const { body } = await client.request({
       path: '/',
       method: 'GET',
       body: 'asd'
     })
 
-    t.equal(await body.text(), 'response')
+    t.strictEqual(await body.text(), 'response')
   })
+
+  await t.completed
 })
 
-test('response trailers missing w trailers is OK', (t) => {
-  t.plan(2)
+test('response trailers missing w trailers is OK', async (t) => {
+  t = tspl(t, { plan: 2 })
 
   const server = createServer((req, res) => {
     res.writeHead(200, {
@@ -40,18 +42,19 @@ test('response trailers missing w trailers is OK', (t) => {
     })
     res.end('response')
   })
-  t.teardown(server.close.bind(server))
+  after(() => server.close())
   server.listen(0, async () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
-
+    after(() => client.destroy())
     const { body, trailers } = await client.request({
       path: '/',
       method: 'GET',
       body: 'asd'
     })
 
-    t.equal(await body.text(), 'response')
-    t.same(trailers, { asd: 'foo' })
+    t.strictEqual(await body.text(), 'response')
+    t.deepStrictEqual(trailers, { asd: 'foo' })
   })
+
+  await t.completed
 })