fastify 5.3.3 → 5.4.0

package/test/http2/secure-with-fallback.test.js

@@ -3,10 +3,10 @@
 const { test } = require('node:test')
 const Fastify = require('../..')
 const h2url = require('h2url')
-const sget = require('simple-get').concat
 const msg = { hello: 'world' }
 
 const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
 test.before(buildCertificate)
 
 test('secure with fallback', async (t) => {
@@ -41,12 +41,12 @@ test('secure with fallback', async (t) => {
 
   t.after(() => { fastify.close() })
 
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
   await t.test('https get error', async (t) => {
     t.plan(1)
 
-    const url = `https://localhost:${fastify.server.address().port}/error`
+    const url = `${fastifyServer}/error`
     const res = await h2url.concat({ url })
 
     t.assert.strictEqual(res.headers[':status'], 500)
@@ -55,9 +55,8 @@ test('secure with fallback', async (t) => {
   await t.test('https post', async (t) => {
     t.plan(2)
 
-    const url = `https://localhost:${fastify.server.address().port}`
     const res = await h2url.concat({
-      url,
+      url: fastifyServer,
       method: 'POST',
       body: JSON.stringify({ hello: 'http2' }),
       headers: {
@@ -72,39 +71,41 @@ test('secure with fallback', async (t) => {
   await t.test('https get request', async (t) => {
     t.plan(3)
 
-    const url = `https://localhost:${fastify.server.address().port}`
-    const res = await h2url.concat({ url })
+    const res = await h2url.concat({ url: fastifyServer })
 
     t.assert.strictEqual(res.headers[':status'], 200)
     t.assert.strictEqual(res.headers['content-length'], '' + JSON.stringify(msg).length)
     t.assert.deepStrictEqual(JSON.parse(res.body), msg)
   })
 
-  await t.test('http1 get request', (t, done) => {
+  await t.test('http1 get request', async t => {
     t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
+    const result = await fetch(fastifyServer, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    const body = await result.text()
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), msg)
   })
 
-  await t.test('http1 get error', (t, done) => {
+  await t.test('http1 get error', async t => {
     t.plan(2)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/error',
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      done()
+    const result = await fetch(`${fastifyServer}/error`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 500)
   })
 })

package/test/https/https.test.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
+const { request } = require('undici')
 const Fastify = require('../..')
 
 const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
 test.before(buildCertificate)
 
 test('https', async (t) => {
@@ -35,43 +36,45 @@ test('https', async (t) => {
 
   t.after(() => { fastify.close() })
 
-  await t.test('https get request', (t, done) => {
+  await t.test('https get request', async t => {
     t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  await t.test('https get request without trust proxy - protocol', (t, done) => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/proto',
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
+  await t.test('https get request without trust proxy - protocol', async t => {
+    t.plan(3)
+    const result1 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/proto',
-      rejectUnauthorized: false,
+    t.assert.ok(result1.ok)
+    t.assert.deepStrictEqual(await result1.json(), { proto: 'https' })
+
+    const result2 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      }),
       headers: {
         'x-forwarded-proto': 'lorem'
       }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
-      done()
     })
+    t.assert.deepStrictEqual(await result2.json(), { proto: 'https' })
   })
 })
 
@@ -98,36 +101,36 @@ test('https - headers', async (t) => {
 
   await fastify.listen({ port: 0 })
 
-  await t.test('https get request', (t, done) => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      const parsedBody = JSON.parse(body)
-      t.assert.strictEqual(parsedBody.hostname, 'localhost')
-      t.assert.strictEqual(parsedBody.port, fastify.server.address().port)
-      done()
+  await t.test('https get request', async t => {
+    t.plan(3)
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hostname: 'localhost', port: fastify.server.address().port, hello: 'world' })
   })
-  await t.test('https get request - test port fall back', (t, done) => {
-    t.plan(3)
-    sget({
+
+  await t.test('https get request - test port fall back', async t => {
+    t.plan(2)
+
+    const result = await request('https://localhost:' + fastify.server.address().port, {
       method: 'GET',
       headers: {
         host: 'example.com'
       },
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      const parsedBody = JSON.parse(body)
-      t.assert.strictEqual(parsedBody.port, null)
-      done()
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    t.assert.strictEqual(result.statusCode, 200)
+    t.assert.deepStrictEqual(await result.body.json(), { hello: 'world', hostname: 'example.com', port: null })
   })
 })

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 84
+const expectedErrors = 85
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)

package/test/internals/handle-request.test.js

@@ -7,7 +7,6 @@ const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 const { kRouteContext } = require('../../lib/symbols')
 const buildSchema = require('../../lib/validation').compileSchemasForValidation
-const sget = require('simple-get').concat
 
 const Ajv = require('ajv')
 const ajv = new Ajv({ coerceTypes: true })
@@ -129,8 +128,8 @@ test('handler function - preValidationCallback with finished response', t => {
   internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))
 })
 
-test('request should be defined in onSend Hook on post request with content type application/json', (t, done) => {
-  t.plan(8)
+test('request should be defined in onSend Hook on post request with content type application/json', async t => {
+  t.plan(6)
   const fastify = require('../..')()
 
   t.after(() => {
@@ -149,28 +148,24 @@ test('request should be defined in onSend Hook on post request with content type
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/json'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // a 400 error is expected because of no body
-      t.assert.strictEqual(response.statusCode, 400)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    }
   })
+
+  t.assert.strictEqual(result.status, 400)
 })
 
-test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', (t, done) => {
-  t.plan(7)
+test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', async t => {
+  t.plan(5)
   const fastify = require('../..')()
 
-  t.after(() => { fastify.close() })
+  t.after(() => {
+    fastify.close()
+  })
 
   fastify.addHook('onSend', (request, reply, payload, done) => {
     t.assert.ok(request)
@@ -183,29 +178,25 @@ test('request should be defined in onSend Hook on post request with content type
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/x-www-form-urlencoded'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // a 415 error is expected because of missing content type parser
-      t.assert.strictEqual(response.statusCode, 415)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    }
   })
+
+  // a 415 error is expected because of missing content type parser
+  t.assert.strictEqual(result.status, 415)
 })
 
-test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', (t, done) => {
-  t.plan(7)
+test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', async t => {
+  t.plan(5)
   const fastify = require('../..')()
 
-  t.after(() => { fastify.close() })
+  t.after(() => {
+    fastify.close()
+  })
 
   fastify.addHook('onSend', (request, reply, payload, done) => {
     t.assert.ok(request)
@@ -218,26 +209,20 @@ test('request should be defined in onSend Hook on options request with content t
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'OPTIONS',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/x-www-form-urlencoded'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // Body parsing skipped, so no body sent
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'OPTIONS',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    }
   })
+
+  // Body parsing skipped, so no body sent
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('request should respond with an error if an unserialized payload is sent inside an async handler', (t, done) => {
-  t.plan(3)
+test('request should respond with an error if an unserialized payload is sent inside an async handler', async t => {
+  t.plan(2)
 
   const fastify = require('../..')()
 
@@ -246,18 +231,16 @@ test('request should respond with an error if an unserialized payload is sent in
     return Promise.resolve(request.headers)
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/'
-  }, (err, res) => {
-    t.assert.ifError(err)
-    t.assert.strictEqual(res.statusCode, 500)
-    t.assert.deepStrictEqual(JSON.parse(res.payload), {
-      error: 'Internal Server Error',
-      code: 'FST_ERR_REP_INVALID_PAYLOAD_TYPE',
-      message: 'Attempted to send payload of invalid type \'object\'. Expected a string or Buffer.',
-      statusCode: 500
-    })
-    done()
+  })
+
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.deepStrictEqual(JSON.parse(res.payload), {
+    error: 'Internal Server Error',
+    code: 'FST_ERR_REP_INVALID_PAYLOAD_TYPE',
+    message: 'Attempted to send payload of invalid type \'object\'. Expected a string or Buffer.',
+    statusCode: 500
   })
 })

package/test/issue-4959.test.js

@@ -3,7 +3,14 @@
 const { test } = require('node:test')
 const http = require('node:http')
 const Fastify = require('../fastify')
-
+const { setTimeout } = require('node:timers')
+
+/*
+* Ensure that a socket error during the request does not cause the
+* onSend hook to be called multiple times.
+*
+* @see https://github.com/fastify/fastify/issues/4959
+*/
 function runBadClientCall (reqOptions, payload) {
   let innerResolve, innerReject
   const promise = new Promise((resolve, reject) => {
@@ -25,7 +32,9 @@ function runBadClientCall (reqOptions, payload) {
 
   // Kill the socket immediately (before sending data)
   req.on('socket', (socket) => {
-    setTimeout(() => { socket.destroy() }, 5)
+    socket.on('connect', () => {
+      setTimeout(() => { socket.destroy() }, 0)
+    })
   })
   req.on('error', innerResolve)
   req.write(postData)
@@ -34,7 +43,7 @@ function runBadClientCall (reqOptions, payload) {
   return promise
 }
 
-test('should handle a soket error', async (t) => {
+test('should handle a socket error', async (t) => {
   t.plan(4)
   const fastify = Fastify()
 

package/test/listen.4.test.js

@@ -3,10 +3,8 @@
 const { test, before } = require('node:test')
 const dns = require('node:dns').promises
 const dnsCb = require('node:dns')
-const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const helper = require('./helper')
-const { waitForCb } = require('./toolkit')
 
 let localhostForURL
 
@@ -90,7 +88,7 @@ test('listen logs the port as info', async t => {
 
 test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
-  t.plan(2 * localAddresses.length)
+  t.plan(3 * localAddresses.length)
 
   const app = Fastify()
   app.get('/', async () => 'hello localhost')
@@ -98,52 +96,42 @@ test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
   await app.listen({ port: 0, host: 'localhost' })
 
   for (const lookup of localAddresses) {
-    await new Promise((resolve, reject) => {
-      sget({
-        method: 'GET',
-        url: getUrl(app, lookup)
-      }, (err, response, body) => {
-        if (err) { return reject(err) }
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body.toString(), 'hello localhost')
-        resolve()
-      })
+    const result = await fetch(getUrl(app, lookup), {
+      method: 'GET'
     })
+
+    t.assert.ok(result.ok)
+    t.assert.deepEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.text(), 'hello localhost')
   }
 })
 
-test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', (t, done) => {
-  dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
-    t.plan(2 + (3 * lookups.length))
-    t.assert.ifError(err)
-
-    const app = Fastify()
-    app.get('/', async () => 'hello localhost')
-    app.listen({ port: 0, host: 'localhost' }, (err) => {
-      t.assert.ifError(err)
-      t.after(() => app.close())
-
-      const { stepIn, patience } = waitForCb({ steps: lookups.length })
-
-      // Loop over each lookup and perform the assertions
-      if (lookups.length > 0) {
-        for (const lookup of lookups) {
-          sget({
-            method: 'GET',
-            url: getUrl(app, lookup)
-          }, (err, response, body) => {
-            t.assert.ifError(err)
-            t.assert.strictEqual(response.statusCode, 200)
-            t.assert.deepStrictEqual(body.toString(), 'hello localhost')
-            // Call stepIn to report that a request has been completed
-            stepIn()
-          })
-        }
-        // When all requests have been completed, call done
-        patience.then(() => done())
-      }
+test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', async (t) => {
+  const lookups = await new Promise((resolve, reject) => {
+    dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
+      if (err) return reject(err)
+      resolve(lookups)
     })
   })
+
+  t.plan(3 * lookups.length)
+
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.after(() => app.close())
+
+  await app.listen({ port: 0, host: 'localhost' })
+
+  // Loop over each lookup and perform the assertions
+  for (const lookup of lookups) {
+    const result = await fetch(getUrl(app, lookup), {
+      method: 'GET'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.deepEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.text(), 'hello localhost')
+  }
 })
 
 test('addresses getter', async t => {