@fastify/reply-from 12.0.2 → 12.2.0

package/test/undici-body.test.js

@@ -1,46 +1,46 @@
 '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()
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
+t.test('undici body', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
 
-const bodyString = JSON.stringify({ hello: 'world' })
+  const bodyString = JSON.stringify({ hello: 'world' })
 
-const parsedLength = Buffer.byteLength(bodyString)
+  const parsedLength = Buffer.byteLength(bodyString)
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  t.same(req.headers['content-length'], parsedLength)
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.same(JSON.parse(data), { hello: 'world' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    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.strictEqual(req.headers['content-type'], 'application/json')
+    t.assert.deepStrictEqual(req.headers['content-length'], `${parsedLength}`)
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(JSON.parse(data), { hello: 'world' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      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())
 
-target.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise((resolve) => target.listen({ port: 0 }, resolve))
 
   instance.addContentTypeParser('application/json', function (_req, payload, done) {
     done(null, payload)
@@ -51,20 +51,15 @@ target.listen({ port: 0 }, (err) => {
     undici: true
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise((resolve) => instance.listen({ port: 0 }, resolve))
 
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: bodyString
-    }, (err, _res, data) => {
-      t.error(err)
-      const parsed = JSON.parse(data)
-      t.same(parsed, { something: 'else' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: bodyString
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/undici-chaining.test.js

@@ -1,57 +1,50 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
-const get = require('simple-get').concat
+const { request } = require('undici')
 const From = require('..')
 
 const header = 'attachment; filename="år.pdf"'
 
-t.plan(6)
+t.test('undici chaining', async (t) => {
+  t.plan(2)
 
-const instance = Fastify()
-t.teardown(instance.close.bind(instance))
-const proxy1 = Fastify()
-t.teardown(proxy1.close.bind(proxy1))
-const proxy2 = Fastify()
-t.teardown(proxy2.close.bind(proxy2))
+  const instance = Fastify()
+  t.after(() => instance.close())
+  const proxy1 = Fastify()
+  t.after(() => proxy1.close())
+  const proxy2 = Fastify()
+  t.after(() => proxy2.close())
 
-instance.get('/', (_request, reply) => {
-  reply.header('content-disposition', header).send('OK')
-})
-
-proxy1.register(From, {
-  undici: {
-    keepAliveMaxTimeout: 10
-  }
-})
-proxy1.get('/', (_request, reply) => {
-  return reply.from(`http://localhost:${instance.server.address().port}`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.header('content-disposition', header).send('OK')
+  })
 
-proxy2.register(From, {
-  undici: {
-    keepAliveMaxTimeout: 10
-  }
-})
-proxy2.get('/', (_request, reply) => {
-  return reply.from(`http://localhost:${proxy1.server.address().port}`)
-})
+  proxy1.register(From, {
+    undici: {
+      keepAliveMaxTimeout: 10
+    }
+  })
+  proxy1.get('/', (_request, reply) => {
+    return reply.from(`http://localhost:${instance.server.address().port}`)
+  })
 
-instance.listen({ port: 0 }, err => {
-  t.error(err)
+  proxy2.register(From, {
+    undici: {
+      keepAliveMaxTimeout: 10
+    }
+  })
+  proxy2.get('/', (_request, reply) => {
+    return reply.from(`http://localhost:${proxy1.server.address().port}`)
+  })
 
-  proxy1.listen({ port: 0 }, err => {
-    t.error(err)
+  await new Promise((resolve) => instance.listen({ port: 0 }, resolve))
+  await new Promise((resolve) => proxy1.listen({ port: 0 }, resolve))
+  await new Promise((resolve) => proxy2.listen({ port: 0 }, resolve))
 
-    proxy2.listen({ port: 0 }, err => {
-      t.error(err)
+  const result = await request(`http://localhost:${proxy2.server.address().port}`)
 
-      get(`http://localhost:${proxy2.server.address().port}`, (err, res, data) => {
-        t.error(err)
-        t.equal(res.statusCode, 200)
-        t.equal(data.toString(), 'OK')
-      })
-    })
-  })
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(await result.body.text(), 'OK')
 })

package/test/undici-connect-timeout.test.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const http = require('node:http')
 const net = require('node:net')
 const Fastify = require('fastify')
 const From = require('..')
-const got = require('got')
+const { request, Agent } = require('undici')
 
 t.test('undici connect timeout', async (t) => {
 // never connect
@@ -18,11 +18,11 @@ t.test('undici connect timeout', async (t) => {
   })
 
   t.plan(2)
-  await target.listen({ port: 0 })
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
-  t.teardown(target.close.bind(target))
+  t.after(() => instance.close())
+  t.after(() => target.close())
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}`,
@@ -38,15 +38,15 @@ t.test('undici connect timeout', async (t) => {
   await instance.listen({ port: 0 })
 
   try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 500,
-      code: 'UND_ERR_CONNECT_TIMEOUT',
-      error: 'Internal Server Error',
-      message: 'Connect Timeout Error'
+    await request(`http://localhost:${instance.server.address().port}/`, {
+      dispatcher: new Agent({
+        pipelining: 0,
+        connectTimeout: 10
+      })
     })
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'UND_ERR_CONNECT_TIMEOUT')
+    t.assert.strictEqual(err.name, 'ConnectTimeoutError')
     return
   }
 

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

@@ -1,13 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
-const undici = require('undici')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Pool } = require('undici')
 const From = require('..')
 
 class CustomDispatcher {
   constructor (...args) {
-    this._dispatcher = new undici.Pool(...args)
+    this._dispatcher = new Pool(...args)
   }
 
   request (...args) {
@@ -29,7 +29,7 @@ test('use a custom instance of \'undici\'', async t => {
   })
 
   target.get('/', (_req, reply) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
 
     reply.headers({
       'Content-Type': 'text/plain',
@@ -41,7 +41,7 @@ test('use a custom instance of \'undici\'', async t => {
   })
 
   await target.listen({ port: 3001 })
-  t.teardown(async () => {
+  t.after(async () => {
     await target.close()
   })
 
@@ -58,16 +58,16 @@ test('use a custom instance of \'undici\'', async t => {
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(async () => {
+  t.after(async () => {
     await instance.close()
   })
 
-  const res = await undici.request(`http://localhost:${instance.server.address().port}`)
+  const res = await request(`http://localhost:${instance.server.address().port}`)
 
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.headers['x-my-header'], 'hello!')
-  t.equal(res.statusCode, 205)
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(res.statusCode, 205)
 
   const data = await res.body.text()
-  t.equal(data, 'hello world')
+  t.assert.strictEqual(data, 'hello world')
 })

package/test/undici-global-agent.test.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const http = require('node:http')
-const get = require('simple-get').concat
 const undici = require('undici')
 const From = require('..')
 
@@ -15,7 +15,7 @@ test('undici global agent is used, but not destroyed', async (t) => {
   undici.setGlobalDispatcher(mockAgent)
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = http.createServer((_req, res) => {
     res.statusCode = 200
@@ -26,41 +26,22 @@ test('undici global agent is used, but not destroyed', async (t) => {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-  const executionFlow = () => new Promise((resolve) => {
-    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}`,
-        globalAgent: true
-      })
-
-      instance.listen({ port: 0 }, (err) => {
-        t.error(err)
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    globalAgent: true
+  })
 
-        get(
-          `http://localhost:${instance.server.address().port}`,
-          (err, res) => {
-            t.error(err)
-            t.equal(res.statusCode, 200)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-            get(
-              `http://localhost:${instance.server.address().port}`,
-              (err, res) => {
-                t.error(err)
-                t.equal(res.statusCode, 200)
-                resolve()
-              }
-            )
-          }
-        )
-      })
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 200)
 
-  await executionFlow()
+  const result1 = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result1.statusCode, 200)
 
   target.close()
 })

package/test/undici-no-destroy.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const undici = require('undici')
 const From = require('..')
@@ -12,7 +12,7 @@ test('destroyAgent false', async (t) => {
   }
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
     reply.from()

package/test/undici-options.test.js

@@ -1,31 +1,32 @@
 '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 proxyquire = require('proxyquire')
 const http = require('node:http')
-const get = require('simple-get').concat
 const undici = require('undici')
 const { getUndiciOptions } = require('../lib/request')
 
 const instance = Fastify()
 
-t.plan(6)
-t.teardown(instance.close.bind(instance))
+t.test('undici options', async (t) => {
+  t.plan(2)
+  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())
 
-target.listen({ port: 0 }, err => {
-  t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
   const From = proxyquire('..', {
     './lib/request.js': proxyquire('../lib/request.js', {
@@ -38,28 +39,24 @@ 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')
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })
 
 function undiciProxy () {}
 undiciProxy.Agent = class Agent extends undici.Agent {
   constructor (opts) {
     super(opts)
-    t.strictSame(opts, buildUndiciOptions())
+    assert.deepStrictEqual(opts, buildUndiciOptions())
   }
 }
 undiciProxy.Pool = class Pool extends undici.Pool {
   constructor (url, options) {
     super(url, options)
-    t.hasStrict(options, buildUndiciOptions())
+    assert.deepStrictEqual(options, buildUndiciOptions())
   }
 }
 

package/test/undici-proxy-agent.test.js

@@ -3,6 +3,7 @@
 const { test, after } = require('node:test')
 const { createServer } = require('node:http')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const { createProxy } = require('proxy')
 const fastifyProxyFrom = require('..')
 const { isIPv6 } = require('node:net')
@@ -78,10 +79,10 @@ for (const [description, format] of Object.entries(configFormat)) {
       }
     }
 
-    const response = await fetch(`http://localhost:${instance.server.address().port}`)
+    const response = await request(`http://localhost:${instance.server.address().port}`)
 
-    t.assert.strictEqual(response.status, 200)
-    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(await response.body.json(), { hello: 'world' })
   })
 }
 

package/test/undici-retry.test.js

@@ -1,9 +1,9 @@
 'use strict'
 
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
-const { test } = require('tap')
+const { test } = require('node:test')
 
 let retryNum = 1
 
@@ -20,10 +20,10 @@ const target = require('node:http').createServer(function (req, res) {
 })
 
 test('Will retry', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
-  await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -33,24 +33,24 @@ test('Will retry', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 1,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'UND_ERR_SOCKET')
+        t.assert.strictEqual(error.code, 'UND_ERR_SOCKET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  t.equal(statusCode, 200)
+  const { statusCode } = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+  t.assert.strictEqual(statusCode, 200)
 })
 
 test('will not retry', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
-  await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -60,28 +60,25 @@ test('will not retry', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 0,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'UND_ERR_SOCKET')
+        t.assert.strictEqual(error.code, 'UND_ERR_SOCKET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-    t.fail()
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+
+  t.assert.strictEqual(result.statusCode, 500)
 })
 
 test('will not retry unsupported method', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
-  await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -91,19 +88,15 @@ test('will not retry unsupported method', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 1,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'UND_ERR_SOCKET')
+        t.assert.strictEqual(error.code, 'UND_ERR_SOCKET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-    t.fail()
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+  t.assert.strictEqual(result.statusCode, 500)
 })