@fastify/reply-from 12.0.2 → 12.2.0

package/test/retry-with-a-custom-handler.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const got = require('got')
 
 function serverWithCustomError (stopAfter, statusCodeToFailOn, closeSocket) {
   let requestCount = 0
@@ -26,7 +26,7 @@ async function setupServer (t, fromOptions = {}, statusCodeToFailOn = 500, stopA
   const target = serverWithCustomError(stopAfter, statusCodeToFailOn, closeSocket)
 
   await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   const instance = Fastify()
   instance.register(From, {
@@ -37,7 +37,7 @@ async function setupServer (t, fromOptions = {}, statusCodeToFailOn = 500, stopA
     reply.from(`http://localhost:${target.address().port}`, fromOptions)
   })
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   await instance.listen({ port: 0 })
 
   return {
@@ -48,14 +48,10 @@ async function setupServer (t, fromOptions = {}, statusCodeToFailOn = 500, stopA
 test('a 500 status code with no custom handler should fail', async (t) => {
   const { instance } = await setupServer(t)
 
-  let errorMessage
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}`, { retry: 3 })
-  } catch (error) {
-    errorMessage = error.message
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}`, { dispatcher: new Agent({ pipelining: 3 }) })
 
-  t.equal(errorMessage, 'Response code 500 (Internal Server Error)')
+  t.assert.strictEqual(result.statusCode, 500)
+  t.assert.strictEqual(await result.body.text(), 'This Service is Unavailable')
 })
 
 test("a server 500's with a custom handler and should revive", async (t) => {
@@ -71,11 +67,11 @@ test("a server 500's with a custom handler and should revive", async (t) => {
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic })
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 5!')
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 5!')
 })
 
 test('custom retry does not invoke the default delay causing a 501', async (t) => {
@@ -89,14 +85,10 @@ test('custom retry does not invoke the default delay causing a 501', async (t) =
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic }, 501)
 
-  let errorMessage
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
-  } catch (error) {
-    errorMessage = error.message
-  }
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.equal(errorMessage, 'Response code 501 (Not Implemented)')
+  t.assert.strictEqual(res.statusCode, 501)
+  t.assert.strictEqual(await res.body.text(), 'This Service is Unavailable')
 })
 
 test('custom retry delay functions can invoke the default delay', async (t) => {
@@ -114,11 +106,11 @@ test('custom retry delay functions can invoke the default delay', async (t) => {
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic }, 500)
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 5!')
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 5!')
 })
 
 test('custom retry delay function inspects the err paramater', async (t) => {
@@ -131,11 +123,11 @@ test('custom retry delay function inspects the err paramater', async (t) => {
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic }, 500, 4, true)
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 5!')
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 5!')
 })
 
 test('we can exceed our retryCount and introspect attempts independently', async (t) => {
@@ -153,12 +145,12 @@ test('we can exceed our retryCount and introspect attempts independently', async
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic }, 500, 4, true)
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.match(attemptCounter, [0, 1, 2, 3, 4])
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 5!')
+  t.assert.deepStrictEqual(attemptCounter, [0, 1, 2, 3, 4])
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 5!')
 })
 
 test('we handle our retries based on the retryCount', async (t) => {
@@ -177,10 +169,11 @@ test('we handle our retries based on the retryCount', async (t) => {
 
   const { instance } = await setupServer(t, { retryDelay: customRetryLogic, retriesCount: 2 }, 500)
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+  await request(`http://localhost:${instance.server.address().port}`)
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.match(attemptCounter, [0, 1])
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 5!')
+  t.assert.deepStrictEqual(attemptCounter.slice(0, 2), [0, 1])
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 5!')
 })

package/test/rewrite-headers-type.test.js

@@ -1,45 +1,40 @@
 '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(8)
-t.teardown(instance.close.bind(instance))
+t.test('rewriteHeaders type', async (t) => {
+  t.plan(5)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 205
-  res.end('hello world')
-})
-
-instance.get('/', (request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    rewriteHeaders: (_headers, req) => {
-      t.pass('rewriteHeaders called with correct request parameter')
-      t.equal(req, request)
-      return {}
-    }
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.statusCode = 205
+    res.end('hello world')
   })
-})
 
-t.teardown(target.close.bind(target))
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteHeaders: (_headers, req) => {
+        t.assert.ok('rewriteHeaders called with correct request parameter')
+        t.assert.strictEqual(req, request)
+        return {}
+      }
+    })
+  })
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  t.after(() => target.close())
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 205)
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 205)
 })

package/test/rewrite-headers.test.js

@@ -1,52 +1,47 @@
 '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')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('rewriteHeaders', 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')
+    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}`, {
-    rewriteHeaders: (headers) => {
-      t.pass('rewriteHeaders called')
-      return {
-        'content-type': headers['content-type'],
-        'x-another-header': 'so headers!'
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteHeaders: (headers) => {
+        t.assert.ok('rewriteHeaders called')
+        return {
+          'content-type': headers['content-type'],
+          'x-another-header': 'so headers!'
+        }
       }
-    }
+    })
   })
-})
-
-t.teardown(target.close.bind(target))
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  t.after(() => target.close())
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-another-header'], 'so headers!')
-      t.notOk(res.headers['x-my-header'])
-      t.equal(res.statusCode, 205)
-    })
-  })
+  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-another-header'], 'so headers!')
+  t.assert.ok(!result.headers['x-my-header'])
+  t.assert.strictEqual(result.statusCode, 205)
 })

package/test/rewrite-request-headers-type.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(8)
-t.teardown(instance.close.bind(instance))
+t.test('rewriteRequestHeaders type', async (t) => {
+  t.plan(5)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 205
-  res.end(req.headers.host)
-})
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.statusCode = 205
+    res.end(req.headers.host)
+  })
 
-instance.get('/', (request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    rewriteRequestHeaders: (originalReq) => {
-      t.pass('rewriteRequestHeaders called with correct request parameter')
-      t.equal(originalReq, request)
-      return {}
-    }
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteRequestHeaders: (originalReq) => {
+        t.assert.ok('rewriteRequestHeaders called with correct request parameter')
+        t.assert.strictEqual(originalReq, request)
+        return {}
+      }
+    })
   })
-})
 
-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) => {
-      t.error(err)
-      t.equal(res.statusCode, 205)
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 205)
 })

package/test/rewrite-request-headers.test.js

@@ -1,47 +1,43 @@
 '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(9)
-t.teardown(instance.close.bind(instance))
+t.test('rewriteRequestHeaders', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.end(req.headers.host)
-})
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.end(req.headers.host)
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    rewriteRequestHeaders: (_originalReq, headers) => {
-      t.pass('rewriteRequestHeaders called')
-      return Object.assign(headers, { host: 'host-override' })
-    }
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      rewriteRequestHeaders: (_originalReq, headers) => {
+        t.assert.ok('rewriteRequestHeaders called')
+        return Object.assign(headers, { host: 'host-override' })
+      }
+    })
   })
-})
 
-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))
+  await new Promise((resolve) => target.listen({ port: 0 }, resolve))
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  const result = await request(`http://localhost:${instance.server.address().port}`)
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'host-override')
-    })
-  })
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'host-override')
 })

package/test/transform-body.test.js

@@ -1,61 +1,55 @@
 '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 Transform = require('node:stream').Transform
 
 const instance = Fastify()
 instance.register(From)
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('transform body', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    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}`, {
-    onResponse: (_request, reply, res) => {
-      reply.send(
-        res.stream.pipe(
-          new Transform({
-            transform: function (chunk, _enc, cb) {
-              this.push(chunk.toString().toUpperCase())
-              cb()
-            }
-          })
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      onResponse: (_request, reply, res) => {
+        reply.send(
+          res.stream.pipe(
+            new Transform({
+              transform: function (chunk, _enc, cb) {
+                this.push(chunk.toString().toUpperCase())
+                cb()
+              }
+            })
+          )
         )
-      )
-    }
+      }
+    })
   })
-})
 
-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')
 })

package/test/undici-agent.test.js

@@ -1,31 +1,31 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const undici = require('undici')
 const proxyquire = require('proxyquire')
 const http = require('node:http')
-const get = require('simple-get').concat
-const undici = require('undici')
 const { getUndiciOptions } = require('../lib/request')
 
-t.plan(10)
+t.test('undici agent', async (t) => {
+  t.plan(6)
 
-const instance = Fastify()
-t.teardown(instance.close.bind(instance))
+  const instance = Fastify()
+  t.after(() => instance.close())
 
-const target = http.createServer((_req, res) => {
-  res.statusCode = 200
-  res.end('hello world')
-})
+  const target = http.createServer((_req, res) => {
+    res.statusCode = 200
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from()
-})
+  instance.get('/', (_request, reply) => {
+    reply.from()
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
+
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-target.listen({ port: 0 }, err => {
-  t.error(err)
   let poolCreation = 0
 
   const From = proxyquire('..', {
@@ -48,23 +48,19 @@ target.listen({ port: 0 }, err => {
     undici: buildUndiciOptions()
   })
 
-  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.statusCode, 200)
-      t.equal(data.toString(), 'hello world')
-      t.equal(poolCreation, 1)
+  const result = await undici.request(`http://localhost:${instance.server.address().port}`)
 
-      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.statusCode, 200)
-        t.equal(data.toString(), 'hello world')
-        t.equal(poolCreation, 1)
-      })
-    })
-  })
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
+  t.assert.strictEqual(poolCreation, 1)
+
+  const result2 = await undici.request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result2.statusCode, 200)
+  t.assert.strictEqual(await result2.body.text(), 'hello world')
+  t.assert.strictEqual(poolCreation, 1)
 })
 
 function buildUndiciOptions () {