@fastify/reply-from 12.1.0 → 12.3.0

package/test/core-with-path-in-base.test.js

@@ -1,53 +1,50 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 
-t.plan(11)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  t.equal(req.headers.connection, 'close')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('core with path in base', async (t) => {
+  t.plan(8)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    t.assert.strictEqual(req.headers.connection, 'close')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from('/hello')
-})
+  instance.get('/', (_request, reply) => {
+    reply.from('/hello')
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-target.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}/hello`,
     http: true
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      agent: false
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-my-header'], 'hello!')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'hello world')
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
   })
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/custom-undici-instance.test.js

@@ -1,17 +1,17 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
+const assert = require('node:assert')
 const Fastify = require('fastify')
-const undici = require('undici')
+const { Pool, request, Client } = require('undici')
 const http = require('node:http')
-const get = require('simple-get').concat
 const From = require('..')
 
 const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/')
-  t.equal(req.headers.connection, 'keep-alive')
+  assert.ok('request proxied')
+  assert.strictEqual(req.method, 'GET')
+  assert.strictEqual(req.url, '/')
+  assert.strictEqual(req.headers.connection, 'keep-alive')
   res.statusCode = 205
   res.setHeader('Content-Type', 'text/plain')
   res.setHeader('x-my-header', 'hello!')
@@ -19,59 +19,51 @@ const target = http.createServer((req, res) => {
 })
 
 t.test('use a custom instance of \'undici\'', async t => {
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await new Promise((resolve, reject) => target.listen({ port: 0 }, err => err ? reject(err) : resolve()))
 
-  t.test('custom Pool', t => {
+  await t.test('custom Pool', async t => {
     const instance = Fastify()
-    t.teardown(instance.close.bind(instance))
+    t.after(() => instance.close())
     instance.register(From, {
       base: `http://localhost:${target.address().port}`,
-      undici: new undici.Pool(`http://localhost:${target.address().port}`)
+      undici: new Pool(`http://localhost:${target.address().port}`)
     })
 
     instance.get('/', (_request, reply) => {
       reply.from()
     })
 
-    instance.listen({ port: 0 }, (err) => {
-      t.error(err)
+    await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'text/plain')
-        t.equal(res.headers['x-my-header'], 'hello!')
-        t.equal(res.statusCode, 205)
-        t.equal(data.toString(), 'hello world')
-        t.end()
-      })
-    })
+    const result = await request(`http://localhost:${instance.server.address().port}`)
+
+    t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.strictEqual(result.statusCode, 205)
+    t.assert.strictEqual(await result.body.text(), 'hello world')
   })
 
-  t.test('custom Client', t => {
+  await t.test('custom Client', async t => {
     const instance = Fastify()
-    t.teardown(instance.close.bind(instance))
+    t.after(() => instance.close())
     instance.register(From, {
       base: `http://localhost:${target.address().port}`,
-      undici: new undici.Client(`http://localhost:${target.address().port}`)
+      undici: new Client(`http://localhost:${target.address().port}`)
     })
 
     instance.get('/', (_request, reply) => {
       reply.from()
     })
 
-    instance.listen({ port: 0 }, (err) => {
-      t.error(err)
+    await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'text/plain')
-        t.equal(res.headers['x-my-header'], 'hello!')
-        t.equal(res.statusCode, 205)
-        t.equal(data.toString(), 'hello world')
-        t.end()
-      })
-    })
+    const result = await request(`http://localhost:${instance.server.address().port}`)
+
+    t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.strictEqual(result.statusCode, 205)
+    t.assert.strictEqual(await result.body.text(), 'hello world')
   })
 })

package/test/disable-request-logging.test.js

@@ -1,17 +1,18 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
+const assert = require('node:assert')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 const split = require('split2')
 
 const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/')
-  t.equal(req.headers.connection, 'keep-alive')
+  assert.ok('request proxied')
+  assert.strictEqual(req.method, 'GET')
+  assert.strictEqual(req.url, '/')
+  assert.strictEqual(req.headers.connection, 'keep-alive')
   res.statusCode = 205
   res.setHeader('Content-Type', 'text/plain')
   res.setHeader('x-my-header', 'hello!')
@@ -20,11 +21,11 @@ const target = http.createServer((req, res) => {
 
 t.test('use a custom instance of \'undici\'', async t => {
   t.plan(3)
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await new Promise((resolve, reject) => target.listen({ port: 0 }, err => err ? reject(err) : resolve()))
 
-  t.test('disableRequestLogging is set to true', t => {
+  await t.test('disableRequestLogging is set to true', async t => {
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {
@@ -32,7 +33,7 @@ t.test('use a custom instance of \'undici\'', async t => {
         stream: logStream
       }
     })
-    t.teardown(instance.close.bind(instance))
+    t.after(() => instance.close())
     instance.register(From, {
       base: `http://localhost:${target.address().port}`,
       disableRequestLogging: true
@@ -50,25 +51,20 @@ t.test('use a custom instance of \'undici\'', async t => {
           !log.msg.match('fetching from remote server')
         )
       ) {
-        t.pass('request log message does not logged')
+        t.assert.ok('request log message does not logged')
       }
     })
 
-    instance.listen({ port: 0 }, (err) => {
-      t.error(err)
-
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'text/plain')
-        t.equal(res.headers['x-my-header'], 'hello!')
-        t.equal(res.statusCode, 205)
-        t.equal(data.toString(), 'hello world')
-        t.end()
-      })
-    })
+    await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+    const result = await request(`http://localhost:${instance.server.address().port}`)
+    t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.strictEqual(result.statusCode, 205)
+    t.assert.strictEqual(await result.body.text(), 'hello world')
   })
 
-  t.test('disableRequestLogging is set to false', t => {
+  await t.test('disableRequestLogging is set to false', async t => {
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {
@@ -76,7 +72,7 @@ t.test('use a custom instance of \'undici\'', async t => {
         stream: logStream
       }
     })
-    t.teardown(instance.close.bind(instance))
+    t.after(() => instance.close())
     instance.register(From, {
       base: `http://localhost:${target.address().port}`,
       disableRequestLogging: false
@@ -94,25 +90,20 @@ t.test('use a custom instance of \'undici\'', async t => {
           log.msg.match('fetching from remote server')
         )
       ) {
-        t.pass('request log message does not logged')
+        t.assert.ok('request log message does not logged')
       }
     })
 
-    instance.listen({ port: 0 }, (err) => {
-      t.error(err)
-
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'text/plain')
-        t.equal(res.headers['x-my-header'], 'hello!')
-        t.equal(res.statusCode, 205)
-        t.equal(data.toString(), 'hello world')
-        t.end()
-      })
-    })
+    await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+    const result = await request(`http://localhost:${instance.server.address().port}`)
+    t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.strictEqual(result.statusCode, 205)
+    t.assert.strictEqual(await result.body.text(), 'hello world')
   })
 
-  t.test('disableRequestLogging is not defined', t => {
+  await t.test('disableRequestLogging is not defined', async t => {
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {
@@ -120,7 +111,7 @@ t.test('use a custom instance of \'undici\'', async t => {
         stream: logStream
       }
     })
-    t.teardown(instance.close.bind(instance))
+    t.after(() => instance.close())
     instance.register(From, {
       base: `http://localhost:${target.address().port}`
     })
@@ -137,21 +128,16 @@ t.test('use a custom instance of \'undici\'', async t => {
           log.msg.match('fetching from remote server')
         )
       ) {
-        t.pass('request log message does not logged')
+        t.assert.ok('request log message does not logged')
       }
     })
 
-    instance.listen({ port: 0 }, (err) => {
-      t.error(err)
-
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'text/plain')
-        t.equal(res.headers['x-my-header'], 'hello!')
-        t.equal(res.statusCode, 205)
-        t.equal(data.toString(), 'hello world')
-        t.end()
-      })
-    })
+    await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+    const result = await request(`http://localhost:${instance.server.address().port}`)
+    t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.strictEqual(result.statusCode, 205)
+    t.assert.strictEqual(await result.body.text(), 'hello world')
   })
 })

package/test/fastify-multipart-incompatibility.test.js

@@ -2,12 +2,12 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const Multipart = require('@fastify/multipart')
 const http = require('node:http')
-const get = require('simple-get').concat
 const FormData = require('form-data')
 
 const split = require('split2')
@@ -23,68 +23,62 @@ const instance = Fastify({
 instance.register(Multipart)
 instance.register(From)
 
-t.plan(12)
+t.test('fastify-multipart-incompatibility', async (t) => {
+  t.plan(9)
 
-t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-const filetPath = path.join(__dirname, 'fixtures', 'file.txt')
-const fileContent = fs.readFileSync(filetPath, { encoding: 'utf-8' })
+  const filetPath = path.join(__dirname, 'fixtures', 'file.txt')
+  const fileContent = fs.readFileSync(filetPath, { encoding: 'utf-8' })
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.match(req.headers['content-type'], /^multipart\/form-data/)
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.notMatch(data, 'Content-Disposition: form-data; name="key"')
-    t.notMatch(data, 'value')
-    t.notMatch(data, 'Content-Disposition: form-data; name="file"')
-    t.notMatch(data, fileContent)
-    res.setHeader('content-type', 'application/json')
-    res.statusCode = 200
-    res.end(JSON.stringify({ something: 'else' }))
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'POST')
+    t.assert.match(req.headers['content-type'], /^multipart\/form-data/)
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.notDeepEqual(data, 'Content-Disposition: form-data; name="key"')
+      t.assert.notDeepEqual(data, 'value')
+      t.assert.notDeepEqual(data, 'Content-Disposition: form-data; name="file"')
+      t.assert.notDeepEqual(data, fileContent)
+      res.setHeader('content-type', 'application/json')
+      res.statusCode = 200
+      res.end(JSON.stringify({ something: 'else' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`)
-})
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
   logStream.on('data', (log) => {
     if (
       log.level === 40 &&
       log.msg.match(/@fastify\/reply-from might not behave as expected when used with @fastify\/multipart/)
     ) {
-      t.pass('incompatibility warn message logged')
+      t.assert.ok('incompatibility warn message logged')
     }
   })
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    const form = new FormData()
-    form.append('key', 'value')
-    form.append('file', fs.createReadStream(filetPath, { encoding: 'utf-8' }))
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      headers: {
-        ...form.getHeaders()
-      },
-      body: form
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(JSON.parse(data), { something: 'else' })
-    })
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+  const form = new FormData()
+  form.append('key', 'value')
+  form.append('file', fs.createReadStream(filetPath, { encoding: 'utf-8' }))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: form.getHeaders(),
+    body: form
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/fix-GHSA-v2v2-hph8-q5xp.test.js

@@ -2,6 +2,7 @@
 
 const { describe, after, it } = require('node:test')
 const fastify = require('fastify')
+const { request } = require('undici')
 const fastifyProxyFrom = require('..')
 const { isIPv6 } = require('node:net')
 
@@ -49,7 +50,7 @@ describe('GHSA-v2v2-hph8-q5xp', function () {
       appAddress = `[${appAddress}]`
     }
 
-    const response = await fetch(
+    const response = await request(
       `http://${appAddress}:${app.server.address().port}/test`,
       {
         headers: { 'content-type': 'application/json ; charset=utf-8' },
@@ -58,6 +59,6 @@ describe('GHSA-v2v2-hph8-q5xp', function () {
         method: 'POST'
       })
 
-    t.assert.strictEqual(await response.text(), 'ok')
+    t.assert.strictEqual(await response.body.text(), 'ok')
   })
 })

package/test/full-delete-http2.test.js

@@ -1,21 +1,21 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 
 test('http -> http2', async function (t) {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = Fastify({
     http2: true
   })
 
   target.delete('/', (_request, reply) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     reply.code(200).header('x-my-header', 'hello!').send({
       hello: 'world'
     })
@@ -25,7 +25,7 @@ test('http -> http2', async function (t) {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await target.listen({ port: 0 })
 
@@ -36,17 +36,18 @@ test('http -> http2', async function (t) {
 
   await instance.listen({ port: 0 })
 
-  const { headers, body, statusCode } = await got(
+  const { headers, body, statusCode } = await request(
     `http://localhost:${instance.server.address().port}`,
     {
       method: 'DELETE',
-      responseType: 'json'
+      responseType: 'json',
+      dispatcher: new Agent({ pipelining: 0 })
     }
   )
-  t.equal(statusCode, 200)
-  t.equal(headers['x-my-header'], 'hello!')
-  t.match(headers['content-type'], /application\/json/)
-  t.same(body, { hello: 'world' })
+  t.assert.strictEqual(statusCode, 200)
+  t.assert.strictEqual(headers['x-my-header'], 'hello!')
+  t.assert.match(headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await body.json(), { hello: 'world' })
   instance.close()
   target.close()
 })

package/test/full-get-test.test.js

@@ -1,45 +1,42 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 instance.register(From)
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('full get', async (t) => {
+  t.plan(7)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}/hello`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/hello`)
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-my-header'], 'hello!')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'hello world')
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })