@fastify/reply-from 12.1.0 → 12.3.0

package/test/http2-target-multi-crash.test.js

@@ -1,14 +1,14 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
-const got = require('got')
 
 test('http -> http2 crash multiple times', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
     reply.from()
@@ -23,29 +23,24 @@ test('http -> http2 crash multiple times', async (t) => {
   })
 
   await instance.listen({ port: 0 })
-
-  try {
-    let target = setupTarget()
-    await target.listen({ port: 3128 })
-    await got(`http://localhost:${instance.server.address().port}`)
-    await target.close()
-    target = setupTarget()
-    await target.listen({ port: 3128 })
-    await got(`http://localhost:${instance.server.address().port}`)
-    await target.close()
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 503)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 503,
-      code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
-      error: 'Service Unavailable',
-      message: 'Service Unavailable'
-    })
-    return
-  }
-  t.fail()
+  let target = setupTarget()
+  await target.listen({ port: 3128 })
+  await request(`http://localhost:${instance.server.address().port}`)
+  await target.close()
+  target = setupTarget()
+  await target.listen({ port: 3128 })
+  await request(`http://localhost:${instance.server.address().port}`)
+  await target.close()
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 503)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 503,
+    code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
+    error: 'Service Unavailable',
+    message: 'Service Unavailable'
+  })
 
   function setupTarget () {
     const target = Fastify({
@@ -53,7 +48,7 @@ test('http -> http2 crash multiple times', async (t) => {
     })
 
     target.get('/', (request, reply) => {
-      t.pass('request proxied')
+      t.assert.ok('request proxied')
       reply.code(200).send({
         hello: 'world'
       })

package/test/http2-timeout-disabled.test.js

@@ -1,22 +1,22 @@
 '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('http2 request timeout disabled', async (t) => {
   const target = Fastify({ http2: true })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', () => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
   })
 
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -30,22 +30,24 @@ test('http2 request timeout disabled', async (t) => {
   await instance.listen({ port: 0 })
 
   const result = await Promise.race([
-    got.get(`http://localhost:${instance.server.address().port}/`, {
-      retry: 0
+    request(`http://localhost:${instance.server.address().port}/`, {
+      dispatcher: new Agent({
+        pipelining: 0
+      })
     }),
     new Promise(resolve => setTimeout(resolve, 11000, 'passed'))
   ])
 
   // if we wait 11000 ms without a timeout error, we assume disabling the timeout worked
   // 10000 ms is the default timeout
-  t.equal(result, 'passed')
+  t.assert.strictEqual(result, 'passed')
 })
 
 test('http2 session timeout disabled', async (t) => {
   const target = Fastify({ http2: true })
 
   target.get('/', () => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
   })
 
   await target.listen({ port: 0 })
@@ -65,21 +67,24 @@ test('http2 session timeout disabled', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  const request = got.get(`http://localhost:${instance.server.address().port}/`, {
-    retry: 0
-  })
+  const abortController = new AbortController()
 
   const result = await Promise.race([
-    request,
+    request(`http://localhost:${instance.server.address().port}/`, {
+      dispatcher: new Agent({
+        pipelining: 0
+      }),
+      signal: abortController.signal
+    }),
     new Promise(resolve => setTimeout(resolve, 4000, 'passed'))
   ])
 
   // clean up right after the timeout, otherwise test will hang
-  request.cancel()
+  abortController.abort()
   target.close()
   instance.close()
 
   // if we wait 4000 ms without a timeout error, we assume disabling the session timeout for reply-from worked
   // because we pass 3000 ms as session timeout to the Fastify options itself
-  t.equal(result, 'passed')
+  t.assert.strictEqual(result, 'passed')
 })

package/test/http2-timeout.test.js

@@ -1,23 +1,23 @@
 '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')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 test('http2 request timeout', async (t) => {
   const target = Fastify({ http2: true, sessionTimeout: 0 })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', () => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
   })
 
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -30,33 +30,28 @@ test('http2 request timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, {
-      retry: 0
+  const result = await request(`http://localhost:${instance.server.address().port}/`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
-    })
-
-    return
-  }
-
-  t.fail()
+  })
+  t.assert.strictEqual(result.statusCode, 504)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
 })
 
 test('http2 request with specific timeout', async (t) => {
   const clock = FakeTimers.createClock()
   const target = Fastify({ http2: true })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     setTimeout(() => {
       reply.status(200).send('hello world')
@@ -68,7 +63,7 @@ test('http2 request with specific timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -87,38 +82,40 @@ test('http2 request with specific timeout', async (t) => {
   })
 
   await instance.listen({ port: 0 })
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
-  t.equal(statusCode, 200)
-
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}/success`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    return
-  }
+  })
+  t.assert.strictEqual(result.statusCode, 200)
 
-  t.fail()
+  const result2 = await request(`http://localhost:${instance.server.address().port}/fail`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+  t.assert.strictEqual(result2.statusCode, 504)
+  t.assert.match(result2.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result2.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
 })
 
 test('http2 session timeout', async (t) => {
   const target = Fastify({ http2: true, sessionTimeout: 0 })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', () => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
   })
 
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -131,31 +128,27 @@ test('http2 session 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, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}/`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
+  })
 
-    return
-  }
-
-  t.fail()
+  t.assert.strictEqual(result.statusCode, 504)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
 })
 
 test('http2 sse removes request and session timeout test', async (t) => {
   const target = Fastify({ http2: true, sessionTimeout: 0 })
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     reply.status(200).header('content-type', 'text/event-stream').send('hello world')
   })
@@ -175,11 +168,11 @@ test('http2 sse removes request and session timeout test', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  t.teardown(instance.close.bind(instance))
-  t.teardown(target.close.bind(target))
+  t.after(() => instance.close())
+  t.after(() => target.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)
   instance.close()
   target.close()
 })

package/test/http2-unix-socket.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const From = require('../index')
 
@@ -9,7 +9,7 @@ test('throw an error if http2 is used with a Unix socket destination', async t =
 
   const instance = Fastify()
 
-  await t.rejects(async () => instance.register(From, {
+  await t.assert.rejects(async () => instance.register(From, {
     base: 'unix+http://localhost:1337',
     http2: { requestTimeout: 100 }
   }), new Error('Unix socket destination is not supported when http2 is true'))

package/test/https-agents.test.js

@@ -1,11 +1,12 @@
 '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 https = require('node:https')
-const get = require('simple-get').concat
+const { Agent } = require('undici')
 
 const fs = require('node:fs')
 const path = require('node:path')
@@ -18,27 +19,27 @@ const instance = Fastify({
   https: certs
 })
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
+t.test('https agents', async (t) => {
+  t.plan(7)
+  t.after(() => instance.close())
 
-const target = https.createServer(certs, (req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+  const target = https.createServer(certs, (req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/')
+    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()
-})
+  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))
 
   instance.register(From, {
     base: `https://localhost:${target.address().port}`,
@@ -50,18 +51,18 @@ target.listen({ port: 0 }, (err) => {
     }
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-    get({
-      url: `https://localhost:${instance.server.address().port}`,
-      rejectUnauthorized: 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')
+  const result = await request(`https://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
     })
   })
+
+  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/https-global-agent.test.js

@@ -1,10 +1,11 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const https = require('node:https')
-const get = require('simple-get').concat
+const { Agent } = require('undici')
 
 const fs = require('node:fs')
 const path = require('node:path')
@@ -20,50 +21,40 @@ test('https global agent is used, but not destroyed', async (t) => {
   const instance = Fastify({
     https: certs
   })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   instance.get('/', (_request, reply) => {
     reply.from()
   })
 
   const target = https.createServer(certs, (req, res) => {
-    t.pass('request proxied')
-    t.equal(req.method, 'GET')
-    t.equal(req.url, '/')
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/')
     res.statusCode = 200
     res.end()
   })
-  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: `https://localhost:${target.address().port}`,
-        globalAgent: true,
-        http: {
-        }
-      })
+  instance.register(From, {
+    base: `https://localhost:${target.address().port}`,
+    globalAgent: true,
+    http: {
+    }
+  })
 
-      instance.listen({ port: 0 }, (err) => {
-        t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-        get(
-          {
-            url: `https://localhost:${instance.server.address().port}`,
-            rejectUnauthorized: false
-          },
-          (err, res) => {
-            t.error(err)
-            t.equal(res.statusCode, 200)
-            resolve()
-          }
-        )
-      })
+  const result = await request(`https://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
     })
   })
 
-  await executionFlow()
+  t.assert.strictEqual(result.statusCode, 200)
 
   target.close()
 })

package/test/method.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('method', 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.deepStrictEqual(req.method, 'POST')
+    t.assert.deepStrictEqual(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.patch('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, { method: 'POST' })
-})
+  instance.patch('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, { method: 'POST' })
+  })
 
-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: 'PATCH',
-      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: 'PATCH',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: bodyString
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })