fastify 5.2.1 → 5.3.0

package/test/hooks.on-listen.test.js

@@ -6,6 +6,9 @@ const fp = require('fastify-plugin')
 const split = require('split2')
 const helper = require('./helper')
 const { kState } = require('../lib/symbols')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhost
 before(async function () {
@@ -405,7 +408,7 @@ test('localhost onListen encapsulation should be called in order and should log
   })
 })
 
-test('non-localhost onListen should be called in order', t => {
+test('non-localhost onListen should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -428,7 +431,7 @@ test('non-localhost onListen should be called in order', t => {
   })
 })
 
-test('non-localhost async onListen should be called in order', async t => {
+test('non-localhost async onListen should be called in order', { skip: isIPv6Missing }, async t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -448,7 +451,7 @@ test('non-localhost async onListen should be called in order', async t => {
   })
 })
 
-test('non-localhost sync onListen should log errors as warnings and continue', t => {
+test('non-localhost sync onListen should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -488,7 +491,7 @@ test('non-localhost sync onListen should log errors as warnings and continue', t
   })
 })
 
-test('non-localhost async onListen should log errors as warnings and continue', async t => {
+test('non-localhost async onListen should log errors as warnings and continue', { skip: isIPv6Missing }, async t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -529,7 +532,7 @@ test('non-localhost async onListen should log errors as warnings and continue',
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(3)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -562,7 +565,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin', t =>
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -608,7 +611,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order', t => {
+test('non-localhost onListen encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -640,7 +643,7 @@ test('non-localhost onListen encapsulation should be called in order', t => {
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', t => {
+test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -874,7 +877,7 @@ test('onListen localhost with callback encapsulation should be called in order',
   })
 })
 
-test('onListen non-localhost should work in order with callback in sync', t => {
+test('onListen non-localhost should work in order with callback in sync', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -896,7 +899,7 @@ test('onListen non-localhost should work in order with callback in sync', t => {
   })
 })
 
-test('onListen non-localhost should work in order with callback in async', t => {
+test('onListen non-localhost should work in order with callback in async', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -916,7 +919,7 @@ test('onListen non-localhost should work in order with callback in async', t =>
   })
 })
 
-test('onListen non-localhost sync with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost sync with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -960,7 +963,7 @@ test('onListen non-localhost sync with callback should log errors as warnings an
   })
 })
 
-test('onListen non-localhost async with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost async with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -1002,7 +1005,7 @@ test('onListen non-localhost async with callback should log errors as warnings a
   })
 })
 
-test('Register onListen hook non-localhost with callback after a plugin inside a plugin', t => {
+test('Register onListen hook non-localhost with callback after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(5)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -1035,7 +1038,7 @@ test('Register onListen hook non-localhost with callback after a plugin inside a
   })
 })
 
-test('onListen non-localhost with callback encapsulation should be called in order', t => {
+test('onListen non-localhost with callback encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(8)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))

package/test/internals/content-type-parser.test.js

@@ -61,7 +61,7 @@ test('Should support Webpack and faux modules', t => {
   t.plan(2)
 
   const internals = proxyquire('../../lib/contentTypeParser', {
-    'tiny-lru': { default: () => { } }
+    'toad-cache': { default: () => { } }
   })[kTestInternals]
 
   const body = Buffer.from('你好 世界')

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)
@@ -21,6 +21,7 @@ test(`should expose ${expectedErrors} errors`, t => {
 
 test('ensure name and codes of Errors are identical', t => {
   t.plan(expectedErrors)
+
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -249,6 +250,16 @@ test('FST_ERR_DEC_REFERENCE_TYPE', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_DEC_UNDECLARED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_DEC_UNDECLARED('myDecorator', 'request')
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_DEC_UNDECLARED')
+  t.assert.strictEqual(error.message, "No decorator 'myDecorator' has been declared on request.")
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_HOOK_INVALID_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_HOOK_INVALID_TYPE()
@@ -881,6 +892,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 
 test('Ensure that all errors are in Errors.md TOC', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -918,6 +930,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g

package/test/issue-4959.test.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { test } = require('node:test')
+const http = require('node:http')
+const Fastify = require('../fastify')
+
+function runBadClientCall (reqOptions, payload) {
+  let innerResolve, innerReject
+  const promise = new Promise((resolve, reject) => {
+    innerResolve = resolve
+    innerReject = reject
+  })
+
+  const postData = JSON.stringify(payload)
+
+  const req = http.request({
+    ...reqOptions,
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(postData),
+    }
+  }, () => {
+    innerReject(new Error('Request should have failed'))
+  })
+
+  // Kill the socket immediately (before sending data)
+  req.on('socket', (socket) => {
+    setTimeout(() => { socket.destroy() }, 5)
+  })
+  req.on('error', innerResolve)
+  req.write(postData)
+  req.end()
+
+  return promise
+}
+
+test('should handle a soket error', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  function shouldNotHappen () {
+    t.assert.fail('This should not happen')
+  }
+  process.on('unhandledRejection', shouldNotHappen)
+
+  t.after(() => {
+    fastify.close()
+    process.removeListener('unhandledRejection', shouldNotHappen)
+  })
+
+  fastify.addHook('onRequest', async (request, reply) => {
+    t.assert.ok('onRequest hook called')
+  })
+
+  fastify.addHook('onSend', async (request, reply, payload) => {
+    if (request.onSendCalled) {
+      t.assert.fail('onSend hook called more than once')
+      return
+    }
+
+    t.assert.ok('onSend hook called')
+    request.onSendCalled = true
+
+    // Introduce a delay
+    await new Promise(resolve => setTimeout(resolve, 5))
+    return payload
+  })
+
+  // The handler must be async to trigger the error
+  fastify.put('/', async (request, reply) => {
+    t.assert.ok('PUT handler called')
+    return reply.send({ hello: 'world' })
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const err = await runBadClientCall({
+    hostname: 'localhost',
+    port: fastify.server.address().port,
+    path: '/',
+    method: 'PUT',
+  }, { test: 'me' })
+  t.assert.equal(err.code, 'ECONNRESET')
+})

package/test/listen.1.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
 
@@ -13,69 +13,70 @@ before(async function () {
 
 test('listen works without arguments', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen()
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })
 
 test('Async/await listen with arguments', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
   const address = fastify.server.address()
-  t.equal(addr, `http://127.0.0.1:${address.port}`)
-  t.same(address, {
+  t.assert.strictEqual(addr, `http://127.0.0.1:${address.port}`)
+  t.assert.deepEqual(address, {
     address: '0.0.0.0',
     family: 'IPv4',
     port: address.port
   })
 })
 
-test('listen accepts a callback', t => {
+test('listen accepts a callback', (t, done) => {
   t.plan(2)
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   fastify.listen({ port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    done()
   })
 })
 
-test('listen accepts options and a callback', t => {
+test('listen accepts options and a callback', (t, done) => {
   t.plan(1)
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
@@ -88,40 +89,42 @@ test('listen accepts options and a callback', t => {
     writableAll: false,
     ipv6Only: false
   }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
+    done()
   })
 })
 
-test('listen after Promise.resolve()', t => {
+test('listen after Promise.resolve()', (t, done) => {
   t.plan(2)
-  const f = Fastify()
-  t.teardown(f.close.bind(f))
+  const fastify = Fastify()
+  t.after(() => fastify.close())
   Promise.resolve()
     .then(() => {
-      f.listen({ port: 0 }, (err, address) => {
-        f.server.unref()
-        t.equal(address, `http://${localhostForURL}:${f.server.address().port}`)
-        t.error(err)
+      fastify.listen({ port: 0 }, (err, address) => {
+        fastify.server.unref()
+        t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+        t.assert.ifError(err)
+        done()
       })
     })
 })
 
 test('listen works with undefined host', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  t.teardown(() => {
+  t.after(() => fastify.close())
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen({ host: undefined, port: 0 })
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })
 
 test('listen works with null host', async t => {
@@ -131,13 +134,13 @@ test('listen works with null host', async t => {
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  t.teardown(() => {
+  t.after(() => fastify.close())
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen({ host: null, port: 0 })
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })

package/test/listen.2.test.js

@@ -1,8 +1,11 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhostForURL
 
@@ -10,94 +13,101 @@ before(async function () {
   [, localhostForURL] = await helper.getLoopbackHost()
 })
 
-test('register after listen using Promise.resolve()', t => {
+test('register after listen using Promise.resolve()', async t => {
   t.plan(1)
-  const f = Fastify()
+  const fastify = Fastify()
 
   const handler = (req, res) => res.send({})
-  Promise.resolve()
+  await Promise.resolve()
     .then(() => {
-      f.get('/', handler)
-      f.register((f2, options, done) => {
+      fastify.get('/', handler)
+      fastify.register((f2, options, done) => {
         f2.get('/plugin', handler)
         done()
       })
-      return f.ready()
+      return fastify.ready()
+    })
+    .catch((err) => {
+      t.assert.fail(err.message)
     })
-    .catch(t.error)
-    .then(() => t.pass('resolved'))
+    .then(() => t.assert.ok('resolved'))
 })
 
-test('double listen errors', t => {
+test('double listen errors', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
     fastify.listen({ port: fastify.server.address().port }, (err, address) => {
-      t.equal(address, null)
-      t.ok(err)
+      t.assert.strictEqual(address, null)
+      t.assert.ok(err)
+      done()
     })
   })
 })
 
-test('double listen errors callback with (err, address)', t => {
+test('double listen errors callback with (err, address)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
-    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
     fastify.listen({ port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('nonlocalhost double listen errors callback with (err, address)', t => {
+test('nonlocalhost double listen errors callback with (err, address)', { skip: isIPv6Missing }, (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ host: '::1', port: 0 }, (err, address) => {
-    t.equal(address, `http://${'[::1]'}:${fastify.server.address().port}`)
-    t.error(err)
+    t.assert.strictEqual(address, `http://${'[::1]'}:${fastify.server.address().port}`)
+    t.assert.ifError(err)
     fastify.listen({ host: '::1', port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('listen twice on the same port', t => {
+test('listen twice on the same port', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
-    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
     const s2 = Fastify()
-    t.teardown(s2.close.bind(s2))
+    t.after(() => fastify.close())
     s2.listen({ port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('listen twice on the same port callback with (err, address)', t => {
+test('listen twice on the same port callback with (err, address)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
     const _port = fastify.server.address().port
-    t.equal(address1, `http://${localhostForURL}:${_port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${_port}`)
+    t.assert.ifError(err1)
     const s2 = Fastify()
-    t.teardown(s2.close.bind(s2))
+    t.after(() => fastify.close())
     s2.listen({ port: _port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })