From 6c0f65fff99f7b2aacc4d44829ef8d729a22f5ed Mon Sep 17 00:00:00 2001
From: Aras Abbasi <aras.abbasi@googlemail.com>
Date: Mon, 12 Feb 2024 16:02:45 +0100
Subject: [PATCH] chore: migrate a batch of tests to node test runner (#2742)
---
test/client-errors.js | 15 +-
test/client-stream.js | 435 ++++++++++++++++++++----------------
test/connect-abort.js | 13 +-
test/http-req-destroy.js | 23 +-
test/https.js | 47 ++--
test/max-response-size.js | 57 ++---
test/parser-issues.js | 51 +++--
test/pipeline-pipelining.js | 45 ++--
test/socket-timeout.js | 45 ++--
test/stream-compat.js | 31 +--
test/trailers.js | 31 +--
11 files changed, 446 insertions(+), 347 deletions(-)
diff --git a/test/client-errors.js b/test/client-errors.js
index 21732ac075a..0c935d7cdac 100644
--- a/test/client-errors.js
+++ b/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
})
diff --git a/test/client-stream.js b/test/client-stream.js
index 69843acf0df..8df8c690aea 100644
--- a/test/client-stream.js
+++ b/test/client-stream.js
@@ -1,26 +1,27 @@
'use strict'
-const { test } = require('tap')
+const { tspl } = require('@matteo.collina/tspl')
+const { test, after } = require('node:test')
const { Client, errors } = require('..')
const { createServer } = require('node:http')
const { PassThrough, Writable, Readable } = require('node:stream')
const EE = require('node:events')
-test('stream get', (t) => {
- t.plan(9)
+test('stream get', async (t) => {
+ t = tspl(t, { plan: 9 })
const server = createServer((req, res) => {
- t.equal('/', req.url)
- t.equal('GET', req.method)
- t.equal(`localhost:${server.address().port}`, req.headers.host)
+ t.strictEqual('/', req.url)
+ t.strictEqual('GET', req.method)
+ t.strictEqual(`localhost:${server.address().port}`, req.headers.host)
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}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
const signal = new EE()
client.stream({
@@ -29,81 +30,85 @@ test('stream get', (t) => {
method: 'GET',
opaque: new PassThrough()
}, ({ statusCode, headers, opaque: pt }) => {
- t.equal(statusCode, 200)
- t.equal(headers['content-type'], 'text/plain')
+ t.strictEqual(statusCode, 200)
+ t.strictEqual(headers['content-type'], 'text/plain')
const bufs = []
pt.on('data', (buf) => {
bufs.push(buf)
})
pt.on('end', () => {
- t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+ t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
})
return pt
}, (err) => {
- t.equal(signal.listenerCount('abort'), 0)
- t.error(err)
+ t.strictEqual(signal.listenerCount('abort'), 0)
+ t.ifError(err)
})
- t.equal(signal.listenerCount('abort'), 1)
+ t.strictEqual(signal.listenerCount('abort'), 1)
})
+
+ await t.completed
})
-test('stream promise get', (t) => {
- t.plan(6)
+test('stream promise get', async (t) => {
+ t = tspl(t, { plan: 6 })
const server = createServer((req, res) => {
- t.equal('/', req.url)
- t.equal('GET', req.method)
- t.equal(`localhost:${server.address().port}`, req.headers.host)
+ t.strictEqual('/', req.url)
+ t.strictEqual('GET', req.method)
+ t.strictEqual(`localhost:${server.address().port}`, req.headers.host)
res.setHeader('content-type', 'text/plain')
res.end('hello')
})
- 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.close.bind(client))
+ after(() => client.close())
await client.stream({
path: '/',
method: 'GET',
opaque: new PassThrough()
}, ({ statusCode, headers, opaque: pt }) => {
- t.equal(statusCode, 200)
- t.equal(headers['content-type'], 'text/plain')
+ t.strictEqual(statusCode, 200)
+ t.strictEqual(headers['content-type'], 'text/plain')
const bufs = []
pt.on('data', (buf) => {
bufs.push(buf)
})
pt.on('end', () => {
- t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+ t.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
})
return pt
})
})
+
+ await t.completed
})
-test('stream GET destroy res', (t) => {
- t.plan(14)
+test('stream GET destroy res', async (t) => {
+ t = tspl(t, { plan: 14 })
const server = createServer((req, res) => {
- t.equal('/', req.url)
- t.equal('GET', req.method)
- t.equal(`localhost:${server.address().port}`, req.headers.host)
+ t.strictEqual('/', req.url)
+ t.strictEqual('GET', req.method)
+ t.strictEqual(`localhost:${server.address().port}`, req.headers.host)
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}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
client.stream({
path: '/',
method: 'GET'
}, ({ statusCode, headers }) => {
- t.equal(statusCode, 200)
- t.equal(headers['content-type'], 'text/plain')
+ t.strictEqual(statusCode, 200)
+ t.strictEqual(headers['content-type'], 'text/plain')
const pt = new PassThrough()
.on('error', (err) => {
@@ -122,26 +127,28 @@ test('stream GET destroy res', (t) => {
path: '/',
method: 'GET'
}, ({ statusCode, headers }) => {
- t.equal(statusCode, 200)
- t.equal(headers['content-type'], 'text/plain')
+ t.strictEqual(statusCode, 200)
+ t.strictEqual(headers['content-type'], 'text/plain')
let ret = ''
const pt = new PassThrough()
pt.on('data', chunk => {
ret += chunk
}).on('end', () => {
- t.equal(ret, 'hello')
+ t.strictEqual(ret, 'hello')
})
return pt
}, (err) => {
- t.error(err)
+ t.ifError(err)
})
})
+
+ await t.completed
})
-test('stream GET remote destroy', (t) => {
- t.plan(4)
+test('stream GET remote destroy', async (t) => {
+ t = tspl(t, { plan: 4 })
const server = createServer((req, res) => {
res.write('asd')
@@ -149,11 +156,11 @@ test('stream GET remote destroy', (t) => {
res.destroy()
})
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
client.stream({
path: '/',
@@ -181,10 +188,12 @@ test('stream GET remote destroy', (t) => {
t.ok(err)
})
})
+
+ await t.completed
})
-test('stream response resume back pressure and non standard error', (t) => {
- t.plan(5)
+test('stream response resume back pressure and non standard error', async (t) => {
+ t = tspl(t, { plan: 5 })
const server = createServer((req, res) => {
res.write(Buffer.alloc(1e3))
@@ -193,11 +202,11 @@ test('stream response resume back pressure and non standard error', (t) => {
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.close.bind(client))
+ after(() => client.close())
const pt = new PassThrough()
client.stream({
@@ -207,12 +216,12 @@ test('stream response resume back pressure and non standard error', (t) => {
pt.on('data', () => {
pt.emit('error', new Error('kaboom'))
}).once('error', (err) => {
- t.equal(err.message, 'kaboom')
+ t.strictEqual(err.message, 'kaboom')
})
return pt
}, (err) => {
t.ok(err)
- t.equal(pt.destroyed, true)
+ t.strictEqual(pt.destroyed, true)
})
client.once('disconnect', (err) => {
@@ -227,36 +236,40 @@ test('stream response resume back pressure and non standard error', (t) => {
pt.resume()
return pt
}, (err) => {
- t.error(err)
+ t.ifError(err)
})
})
+
+ await t.completed
})
-test('stream waits only for writable side', (t) => {
- t.plan(2)
+test('stream waits only for writable side', async (t) => {
+ t = tspl(t, { plan: 2 })
const server = createServer((req, res) => {
res.end(Buffer.alloc(1e3))
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
const pt = new PassThrough({ autoDestroy: false })
client.stream({
path: '/',
method: 'GET'
}, () => pt, (err) => {
- t.error(err)
- t.equal(pt.destroyed, false)
+ t.ifError(err)
+ t.strictEqual(pt.destroyed, false)
})
})
+
+ await t.completed
})
-test('stream args validation', (t) => {
- t.plan(3)
+test('stream args validation', async (t) => {
+ t = tspl(t, { plan: 3 })
const client = new Client('http://localhost:5000')
client.stream({
@@ -277,8 +290,8 @@ test('stream args validation', (t) => {
}
})
-test('stream args validation promise', (t) => {
- t.plan(2)
+test('stream args validation promise', async (t) => {
+ t = tspl(t, { plan: 2 })
const client = new Client('http://localhost:5000')
client.stream({
@@ -291,21 +304,23 @@ test('stream args validation promise', (t) => {
client.stream(null, null).catch((err) => {
t.ok(err instanceof errors.InvalidArgumentError)
})
+
+ await t.completed
})
-test('stream destroy if not readable', (t) => {
- t.plan(2)
+test('stream destroy if not readable', async (t) => {
+ t = tspl(t, { plan: 2 })
const server = createServer((req, res) => {
res.end()
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
const pt = new PassThrough()
pt.readable = false
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.destroy.bind(client))
+ after(client.destroy.bind(client))
client.stream({
path: '/',
@@ -313,23 +328,25 @@ test('stream destroy if not readable', (t) => {
}, () => {
return pt
}, (err) => {
- t.error(err)
- t.equal(pt.destroyed, true)
+ t.ifError(err)
+ t.strictEqual(pt.destroyed, true)
})
})
+
+ await t.completed
})
-test('stream server side destroy', (t) => {
- t.plan(1)
+test('stream server side destroy', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.destroy()
})
- 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.bind(client))
client.stream({
path: '/',
@@ -340,19 +357,21 @@ test('stream server side destroy', (t) => {
t.ok(err instanceof errors.SocketError)
})
})
+
+ await t.completed
})
-test('stream invalid return', (t) => {
- t.plan(1)
+test('stream invalid return', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.write('asd')
})
- 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.bind(client))
client.stream({
path: '/',
@@ -363,19 +382,21 @@ test('stream invalid return', (t) => {
t.ok(err instanceof errors.InvalidReturnValueError)
})
})
+
+ await t.completed
})
-test('stream body without destroy', (t) => {
- t.plan(1)
+test('stream body without destroy', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
client.stream({
path: '/',
@@ -386,22 +407,24 @@ test('stream body without destroy', (t) => {
pt.resume()
return pt
}, (err) => {
- t.error(err)
+ t.ifError(err)
})
})
+
+ await t.completed
})
-test('stream factory abort', (t) => {
- t.plan(3)
+test('stream factory abort', async (t) => {
+ t = tspl(t, { plan: 3 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
const signal = new EE()
client.stream({
@@ -412,24 +435,26 @@ test('stream factory abort', (t) => {
signal.emit('abort')
return new PassThrough()
}, (err) => {
- t.equal(signal.listenerCount('abort'), 0)
+ t.strictEqual(signal.listenerCount('abort'), 0)
t.ok(err instanceof errors.RequestAbortedError)
})
- t.equal(signal.listenerCount('abort'), 1)
+ t.strictEqual(signal.listenerCount('abort'), 1)
})
+
+ await t.completed
})
-test('stream factory throw', (t) => {
- t.plan(3)
+test('stream factory throw', async (t) => {
+ t = tspl(t, { plan: 3 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
client.stream({
path: '/',
@@ -437,7 +462,7 @@ test('stream factory throw', (t) => {
}, () => {
throw new Error('asd')
}, (err) => {
- t.equal(err.message, 'asd')
+ t.strictEqual(err.message, 'asd')
})
client.stream({
path: '/',
@@ -445,7 +470,7 @@ test('stream factory throw', (t) => {
}, () => {
throw new Error('asd')
}, (err) => {
- t.equal(err.message, 'asd')
+ t.strictEqual(err.message, 'asd')
})
client.stream({
path: '/',
@@ -453,22 +478,24 @@ test('stream factory throw', (t) => {
}, () => {
return new PassThrough()
}, (err) => {
- t.error(err)
+ t.ifError(err)
})
})
+
+ await t.completed
})
-test('stream CONNECT throw', (t) => {
- t.plan(1)
+test('stream CONNECT throw', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
client.stream({
path: '/',
@@ -478,19 +505,21 @@ test('stream CONNECT throw', (t) => {
t.ok(err instanceof errors.InvalidArgumentError)
})
})
+
+ await t.completed
})
-test('stream abort after complete', (t) => {
- t.plan(1)
+test('stream abort after complete', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
const pt = new PassThrough()
const signal = new EE()
@@ -501,23 +530,25 @@ test('stream abort after complete', (t) => {
}, () => {
return pt
}, (err) => {
- t.error(err)
+ t.ifError(err)
signal.emit('abort')
})
})
+
+ await t.completed
})
-test('stream abort before dispatch', (t) => {
- t.plan(1)
+test('stream abort before dispatch', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
res.end('asd')
})
- 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.bind(client))
const pt = new PassThrough()
const signal = new EE()
@@ -532,44 +563,48 @@ test('stream abort before dispatch', (t) => {
})
signal.emit('abort')
})
+
+ await t.completed
})
-test('trailers', (t) => {
- t.plan(2)
+test('trailers', async (t) => {
+ t = tspl(t, { plan: 2 })
const server = createServer((req, res) => {
res.writeHead(200, { Trailer: 'Content-MD5' })
res.addTrailers({ 'Content-MD5': 'test' })
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.close.bind(client))
+ after(() => client.close())
client.stream({
path: '/',
method: 'GET'
}, () => new PassThrough(), (err, data) => {
- t.error(err)
- t.strictSame(data.trailers, { 'content-md5': 'test' })
+ t.ifError(err)
+ t.deepStrictEqual(data.trailers, { 'content-md5': 'test' })
})
})
+
+ await t.completed
})
-test('stream ignore 1xx', (t) => {
- t.plan(2)
+test('stream ignore 1xx', async (t) => {
+ t = tspl(t, { plan: 2 })
const server = createServer((req, res) => {
res.writeProcessing()
res.end('hello')
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
let buf = ''
client.stream({
@@ -581,25 +616,27 @@ test('stream ignore 1xx', (t) => {
callback()
}
}), (err, data) => {
- t.error(err)
- t.equal(buf, 'hello')
+ t.ifError(err)
+ t.strictEqual(buf, 'hello')
})
})
+
+ await t.completed
})
-test('stream ignore 1xx and use onInfo', (t) => {
- t.plan(4)
+test('stream ignore 1xx and use onInfo', async (t) => {
+ t = tspl(t, { plan: 4 })
const infos = []
const server = createServer((req, res) => {
res.writeProcessing()
res.end('hello')
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
let buf = ''
client.stream({
@@ -614,16 +651,18 @@ test('stream ignore 1xx and use onInfo', (t) => {
callback()
}
}), (err, data) => {
- t.error(err)
- t.equal(buf, 'hello')
- t.equal(infos.length, 1)
- t.equal(infos[0].statusCode, 102)
+ t.ifError(err)
+ t.strictEqual(buf, 'hello')
+ t.strictEqual(infos.length, 1)
+ t.strictEqual(infos[0].statusCode, 102)
})
})
+
+ await t.completed
})
-test('stream backpressure', (t) => {
- t.plan(2)
+test('stream backpressure', async (t) => {
+ t = tspl(t, { plan: 2 })
const expected = Buffer.alloc(1e6).toString()
@@ -631,11 +670,11 @@ test('stream backpressure', (t) => {
res.writeProcessing()
res.end(expected)
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ after(() => client.close())
let buf = ''
client.stream({
@@ -648,49 +687,53 @@ test('stream backpressure', (t) => {
process.nextTick(callback)
}
}), (err, data) => {
- t.error(err)
- t.equal(buf, expected)
+ t.ifError(err)
+ t.strictEqual(buf, expected)
})
})
+
+ await t.completed
})
-test('stream body destroyed on invalid callback', (t) => {
- t.plan(1)
+test('stream body destroyed on invalid callback', async (t) => {
+ t = tspl(t, { plan: 1 })
const server = createServer((req, res) => {
})
- 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.bind(client))
const body = new Readable({
- read () {}
+ read () { }
})
try {
client.stream({
path: '/',
method: 'GET',
body
- }, () => {}, null)
+ }, () => { }, null)
} catch (err) {
- t.equal(body.destroyed, true)
+ t.strictEqual(body.destroyed, true)
}
})
+
+ await t.completed
})
-test('stream needDrain', (t) => {
- t.plan(3)
+test('stream needDrain', async (t) => {
+ t = tspl(t, { plan: 3 })
const server = createServer((req, res) => {
res.end(Buffer.alloc(4096))
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(() => {
+ after(() => {
client.destroy()
})
@@ -715,8 +758,8 @@ test('stream needDrain', (t) => {
path: '/',
method: 'GET'
}, () => {
- t.equal(dst._writableState.needDrain, true)
- t.equal(dst.writableNeedDrain, true)
+ t.strictEqual(dst._writableState.needDrain, true)
+ t.strictEqual(dst.writableNeedDrain, true)
setImmediate(() => {
dst.write = (...args) => {
@@ -732,19 +775,21 @@ test('stream needDrain', (t) => {
t.ok(true, 'pass')
})
})
+
+ await t.completed
})
-test('stream legacy needDrain', (t) => {
- t.plan(3)
+test('stream legacy needDrain', async (t) => {
+ t = tspl(t, { plan: 3 })
const server = createServer((req, res) => {
res.end(Buffer.alloc(4096))
})
- t.teardown(server.close.bind(server))
+ after(() => server.close())
server.listen(0, () => {
const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(() => {
+ after(() => {
client.destroy()
})
@@ -768,8 +813,8 @@ test('stream legacy needDrain', (t) => {
path: '/',
method: 'GET'
}, () => {
- t.equal(dst._writableState.needDrain, true)
- t.equal(dst.writableNeedDrain, undefined)
+ t.strictEqual(dst._writableState.needDrain, true)
+ t.strictEqual(dst.writableNeedDrain, undefined)
setImmediate(() => {
dst.write = (...args) => {
@@ -785,63 +830,67 @@ test('stream legacy needDrain', (t) => {
t.ok(true, 'pass')
})
})
+ await t.completed
+})
- test('stream throwOnError', (t) => {
- t.plan(2)
+test('stream throwOnError', async (t) => {
+ t = tspl(t, { plan: 3 })
- const errStatusCode = 500
- const errMessage = 'Internal Server Error'
+ const errStatusCode = 500
+ const errMessage = 'Internal Server Error'
- const server = createServer((req, res) => {
- res.writeHead(errStatusCode, { 'Content-Type': 'text/plain' })
- res.end(errMessage)
- })
- t.teardown(server.close.bind(server))
+ const server = createServer((req, res) => {
+ res.writeHead(errStatusCode, { 'Content-Type': 'text/plain' })
+ res.end(errMessage)
+ })
+ after(() => server.close())
- server.listen(0, async () => {
- const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ server.listen(0, async () => {
+ const client = new Client(`http://localhost:${server.address().port}`)
+ after(() => client.close())
- client.stream({
- path: '/',
- method: 'GET',
- throwOnError: true,
- opaque: new PassThrough()
- }, ({ opaque: pt }) => {
- pt.on('data', () => {
- t.fail()
- })
- return pt
- }, (e) => {
- t.equal(e.status, errStatusCode)
- t.equal(e.body, errMessage)
- t.end()
+ client.stream({
+ path: '/',
+ method: 'GET',
+ throwOnError: true,
+ opaque: new PassThrough()
+ }, ({ opaque: pt }) => {
+ pt.on('data', () => {
+ t.fail()
})
+ return pt
+ }, (e) => {
+ t.strictEqual(e.status, errStatusCode)
+ t.strictEqual(e.body, errMessage)
+ t.ok(true, 'end')
})
})
- test('steam throwOnError=true, error on stream', (t) => {
- t.plan(1)
+ await t.completed
+})
- const server = createServer((req, res) => {
- res.end('asd')
- })
- t.teardown(server.close.bind(server))
+test('steam throwOnError=true, error on stream', async (t) => {
+ t = tspl(t, { plan: 1 })
+
+ const server = createServer((req, res) => {
+ res.end('asd')
+ })
+ after(() => server.close())
- server.listen(0, async () => {
- const client = new Client(`http://localhost:${server.address().port}`)
- t.teardown(client.close.bind(client))
+ server.listen(0, async () => {
+ const client = new Client(`http://localhost:${server.address().port}`)
+ after(() => client.close())
- client.stream({
- path: '/',
- method: 'GET',
- throwOnError: true,
- opaque: new PassThrough()
- }, () => {
- throw new Error('asd')
- }, (e) => {
- t.equal(e.message, 'asd')
- })
+ client.stream({
+ path: '/',
+ method: 'GET',
+ throwOnError: true,
+ opaque: new PassThrough()
+ }, () => {
+ throw new Error('asd')
+ }, (e) => {
+ t.strictEqual(e.message, 'asd')
})
})
+ await t.completed
})
diff --git a/test/connect-abort.js b/test/connect-abort.js
index 91ed1b2a258..bf75fd8bd6a 100644
--- a/test/connect-abort.js
+++ b/test/connect-abort.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
})
diff --git a/test/http-req-destroy.js b/test/http-req-destroy.js
index d0d83b6d848..ea7624c611d 100644
--- a/test/http-req-destroy.js
+++ b/test/http-req-destroy.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
})
}
diff --git a/test/https.js b/test/https.js
index 5d9ab3d8e22..418fb969f45 100644
--- a/test/https.js
+++ b/test/https.js
@@ -1,20 +1,21 @@
'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}`, {
@@ -22,33 +23,35 @@ test('https get with tls opts', (t) => {
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}`, {
@@ -56,19 +59,21 @@ test('https get with tls opts ip', (t) => {
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
})
diff --git a/test/max-response-size.js b/test/max-response-size.js
index adf75c6fee2..1e0d904469a 100644
--- a/test/max-response-size.js
+++ b/test/max-response-size.js
@@ -1,17 +1,16 @@
'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')
@@ -19,27 +18,29 @@ test('max response size', (t) => {
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()
@@ -47,27 +48,29 @@ test('max response size', (t) => {
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
})
diff --git a/test/parser-issues.js b/test/parser-issues.js
index 3602ae1ba5e..2d9f04628de 100644
--- a/test/parser-issues.js
+++ b/test/parser-issues.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,10 +64,12 @@ 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')
@@ -70,25 +77,27 @@ test('split header field', (t) => {
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')
@@ -96,19 +105,21 @@ test('split header value', (t) => {
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
})
diff --git a/test/pipeline-pipelining.js b/test/pipeline-pipelining.js
index d3f7143cba4..b244925786a 100644
--- a/test/pipeline-pipelining.js
+++ b/test/pipeline-pipelining.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
})
diff --git a/test/socket-timeout.js b/test/socket-timeout.js
index a0facda8369..83617e94f7e 100644
--- a/test/socket-timeout.js
+++ b/test/socket-timeout.js
@@ -1,13 +1,14 @@
'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()
@@ -15,13 +16,13 @@ test('timeout with pipelining 1', (t) => {
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}`, {
@@ -29,7 +30,7 @@ test('timeout with pipelining 1', (t) => {
headersTimeout: 500,
bodyTimeout: 500
})
- t.teardown(client.close.bind(client))
+ after(() => client.close())
client.request({
path: '/',
@@ -37,37 +38,39 @@ test('timeout with pipelining 1', (t) => {
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
})
diff --git a/test/stream-compat.js b/test/stream-compat.js
index 02d521a9d65..5f219fe42e3 100644
--- a/test/stream-compat.js
+++ b/test/stream-compat.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,19 +34,21 @@ 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({
@@ -53,23 +56,25 @@ test('IncomingMessage', (t) => {
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
})
diff --git a/test/trailers.js b/test/trailers.js
index e56542568ab..8f616e87eba 100644
--- a/test/trailers.js
+++ b/test/trailers.js
@@ -1,11 +1,12 @@
'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, {
@@ -13,23 +14,24 @@ test('response trailers missing 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 } = 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
})