fastify 5.3.2 → 5.4.0

package/test/set-error-handler.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const { FST_ERR_ERROR_HANDLER_NOT_FN } = require('../lib/errors')
+const { FST_ERR_ERROR_HANDLER_NOT_FN, FST_ERR_ERROR_HANDLER_ALREADY_SET } = require('../lib/errors')
 
 test('setErrorHandler should throw an error if the handler is not a function', t => {
   t.plan(1)
@@ -10,3 +10,60 @@ test('setErrorHandler should throw an error if the handler is not a function', t
 
   t.assert.throws(() => fastify.setErrorHandler('not a function'), new FST_ERR_ERROR_HANDLER_NOT_FN())
 })
+
+test('setErrorHandler can be set independently in parent and child scopes', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  t.assert.doesNotThrow(() => {
+    fastify.setErrorHandler(() => {})
+    fastify.register(async (child) => {
+      child.setErrorHandler(() => {})
+    })
+  })
+})
+
+test('setErrorHandler can be overriden if allowErrorHandlerOverride is set to true', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(async (child) => {
+    child.setErrorHandler(() => {})
+    t.assert.doesNotThrow(() => child.setErrorHandler(() => {}))
+  })
+
+  fastify.setErrorHandler(() => {})
+  t.assert.doesNotThrow(() => fastify.setErrorHandler(() => {}))
+
+  await fastify.ready()
+})
+
+test('if `allowErrorHandlerOverride` is disabled, setErrorHandler should throw if called more than once in the same scope', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    allowErrorHandlerOverride: false
+  })
+
+  fastify.setErrorHandler(() => {})
+  t.assert.throws(() => fastify.setErrorHandler(() => {}), new FST_ERR_ERROR_HANDLER_ALREADY_SET())
+})
+
+test('if `allowErrorHandlerOverride` is disabled, setErrorHandler should throw if called more than once in the same scope 2', async t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    allowErrorHandlerOverride: false
+  })
+  t.after(() => fastify.close())
+
+  fastify.register(async (child) => {
+    child.setErrorHandler(() => {})
+    t.assert.throws(() => child.setErrorHandler(() => {}), new FST_ERR_ERROR_HANDLER_ALREADY_SET())
+  })
+
+  await fastify.ready()
+})

package/test/skip-reply-send.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test, describe } = require('node:test')
 const split = require('split2')
 const net = require('node:net')
 const Fastify = require('../fastify')
@@ -19,7 +19,7 @@ const lifecycleHooks = [
   'onError'
 ]
 
-test('skip automatic reply.send() with reply.hijack and a body', (t) => {
+test('skip automatic reply.send() with reply.hijack and a body', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -28,8 +28,8 @@ test('skip automatic reply.send() with reply.hijack and a body', (t) => {
   })
 
   stream.on('data', (line) => {
-    t.not(line.level, 40) // there are no errors
-    t.not(line.level, 50) // there are no errors
+    t.assert.notStrictEqual(line.level, 40) // there are no errors
+    t.assert.notStrictEqual(line.level, 50) // there are no errors
   })
 
   app.get('/', (req, reply) => {
@@ -39,16 +39,16 @@ test('skip automatic reply.send() with reply.hijack and a body', (t) => {
     return Promise.resolve('this will be skipped')
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
-test('skip automatic reply.send() with reply.hijack and no body', (t) => {
+test('skip automatic reply.send() with reply.hijack and no body', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -57,8 +57,8 @@ test('skip automatic reply.send() with reply.hijack and no body', (t) => {
   })
 
   stream.on('data', (line) => {
-    t.not(line.level, 40) // there are no error
-    t.not(line.level, 50) // there are no error
+    t.assert.notStrictEqual(line.level, 40) // there are no error
+    t.assert.notStrictEqual(line.level, 50) // there are no error
   })
 
   app.get('/', (req, reply) => {
@@ -68,16 +68,16 @@ test('skip automatic reply.send() with reply.hijack and no body', (t) => {
     return Promise.resolve()
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
-test('skip automatic reply.send() with reply.hijack and an error', (t) => {
+test('skip automatic reply.send() with reply.hijack and an error', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -90,8 +90,8 @@ test('skip automatic reply.send() with reply.hijack and an error', (t) => {
   stream.on('data', (line) => {
     if (line.level === 50) {
       errorSeen = true
-      t.equal(line.err.message, 'kaboom')
-      t.equal(line.msg, 'Promise errored, but reply.sent = true was set')
+      t.assert.strictEqual(line.err.message, 'kaboom')
+      t.assert.strictEqual(line.msg, 'Promise errored, but reply.sent = true was set')
     }
   })
 
@@ -102,13 +102,13 @@ test('skip automatic reply.send() with reply.hijack and an error', (t) => {
     return Promise.reject(new Error('kaboom'))
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(errorSeen, true)
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(errorSeen, true)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
@@ -117,11 +117,8 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
   const previousHooks = lifecycleHooks.slice(0, idx)
   const nextHooks = lifecycleHooks.slice(idx + 1)
 
-  test(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, t => {
-    t.plan(4)
-    const test = t.test
-
-    test('Sending a response using reply.raw => onResponse hook is called', t => {
+  describe(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, () => {
+    test('Sending a response using reply.raw => onResponse hook is called', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
@@ -130,11 +127,11 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
       })
 
       stream.on('data', (line) => {
-        t.not(line.level, 40) // there are no errors
-        t.not(line.level, 50) // there are no errors
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -146,41 +143,41 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           reply.raw.end(`hello from ${hookOrHandler}`)
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
       nextHooks.forEach(h => {
         if (h === 'onResponse') {
-          app.addHook(h, async (req, reply) => t.pass(`${h} should be called`))
+          app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`))
         } else {
-          app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`))
+          app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`))
         }
       })
 
-      return app.inject({
+      await app.inject({
         method: 'GET',
         url: '/'
       }).then((res) => {
-        t.equal(res.statusCode, 200)
-        t.equal(res.body, `hello from ${hookOrHandler}`)
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.strictEqual(res.body, `hello from ${hookOrHandler}`)
       })
     })
 
-    test('Sending a response using req.socket => onResponse not called', t => {
+    test('Sending a response using req.socket => onResponse not called', (t, testDone) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
           stream
         }
       })
-      t.teardown(() => app.close())
+      t.after(() => app.close())
 
       stream.on('data', (line) => {
-        t.not(line.level, 40) // there are no errors
-        t.not(line.level, 50) // there are no errors
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -196,13 +193,13 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           req.socket.write(`hello from ${hookOrHandler}`)
           req.socket.end()
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
       app.listen({ port: 0 }, err => {
-        t.error(err)
+        t.assert.ifError(err)
         const client = net.createConnection({ port: (app.server.address()).port }, () => {
           client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
@@ -213,36 +210,36 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           })
 
           client.on('end', function () {
-            t.match(chunks, new RegExp(`hello from ${hookOrHandler}`, 'i'))
-            t.end()
+            t.assert.match(chunks, new RegExp(`hello from ${hookOrHandler}`, 'i'))
+            testDone()
           })
         })
       })
     })
 
-    test('Throwing an error does not trigger any hooks', t => {
+    test('Throwing an error does not trigger any hooks', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
           stream
         }
       })
-      t.teardown(() => app.close())
+      t.after(() => app.close())
 
       let errorSeen = false
       stream.on('data', (line) => {
         if (hookOrHandler === 'handler') {
           if (line.level === 40) {
             errorSeen = true
-            t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+            t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
           }
         } else {
-          t.not(line.level, 40) // there are no errors
-          t.not(line.level, 50) // there are no errors
+          t.assert.notStrictEqual(line.level, 40) // there are no errors
+          t.assert.notStrictEqual(line.level, 50) // there are no errors
         }
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -254,23 +251,22 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           throw new Error('This wil be skipped')
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
-      return Promise.race([
+      await Promise.race([
         app.inject({ method: 'GET', url: '/' }),
         new Promise((resolve, reject) => setTimeout(resolve, 1000))
-      ]).then((err, res) => {
-        t.error(err)
-        if (hookOrHandler === 'handler') {
-          t.equal(errorSeen, true)
-        }
-      })
+      ])
+
+      if (hookOrHandler === 'handler') {
+        t.assert.strictEqual(errorSeen, true)
+      }
     })
 
-    test('Calling reply.send() after hijacking logs a warning', t => {
+    test('Calling reply.send() after hijacking logs a warning', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
@@ -283,11 +279,11 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
       stream.on('data', (line) => {
         if (line.level === 40) {
           errorSeen = true
-          t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+          t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
         }
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -299,18 +295,17 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           return reply.send('hello from reply.send()')
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
-      return Promise.race([
+      await Promise.race([
         app.inject({ method: 'GET', url: '/' }),
         new Promise((resolve, reject) => setTimeout(resolve, 1000))
-      ]).then((err, res) => {
-        t.error(err)
-        t.equal(errorSeen, true)
-      })
+      ])
+
+      t.assert.strictEqual(errorSeen, true)
     })
   })
 }

package/test/stream.1.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fs = require('node:fs')
 const Fastify = require('../fastify')
 
-test('should respond with a stream', t => {
+test('should respond with a stream', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -16,23 +15,24 @@ test('should respond with a stream', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
-      t.error(err)
-      t.equal(response.headers['content-type'], undefined)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], undefined)
+      t.assert.strictEqual(response.statusCode, 200)
 
       fs.readFile(__filename, (err, expected) => {
-        t.error(err)
-        t.equal(expected.toString(), data.toString())
+        t.assert.ifError(err)
+        t.assert.strictEqual(expected.toString(), data.toString())
+        testDone()
       })
     })
   })
 })
 
-test('should respond with a stream (error)', t => {
+test('should respond with a stream (error)', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -42,17 +42,18 @@ test('should respond with a stream (error)', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      testDone()
     })
   })
 })
 
-test('should trigger the onSend hook', t => {
+test('should trigger the onSend hook', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -61,7 +62,7 @@ test('should trigger the onSend hook', t => {
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok(payload._readableState)
+    t.assert.ok(payload._readableState)
     reply.header('Content-Type', 'application/javascript')
     done()
   })
@@ -69,14 +70,15 @@ test('should trigger the onSend hook', t => {
   fastify.inject({
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/javascript')
-    t.equal(res.payload, fs.readFileSync(__filename, 'utf8'))
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-type'], 'application/javascript')
+    t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
     fastify.close()
+    testDone()
   })
 })
 
-test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', t => {
+test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -87,22 +89,23 @@ test('should trigger the onSend hook only twice if pumping the stream fails, fir
   let counter = 0
   fastify.addHook('onSend', (req, reply, payload, done) => {
     if (counter === 0) {
-      t.ok(payload._readableState)
+      t.assert.ok(payload._readableState)
     } else if (counter === 1) {
       const error = JSON.parse(payload)
-      t.equal(error.statusCode, 500)
+      t.assert.strictEqual(error.statusCode, 500)
     }
     counter++
     done()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget(`http://localhost:${fastify.server.address().port}`, function (err, response) {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      testDone()
     })
   })
 })

package/test/stream.2.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const proxyquire = require('proxyquire')
 const fs = require('node:fs')
 const resolve = require('node:path').resolve
 const zlib = require('node:zlib')
 const pipeline = require('node:stream').pipeline
 const Fastify = require('..')
+const { waitForCb } = require('./toolkit')
 
 test('onSend hook stream', t => {
   t.plan(4)
@@ -17,6 +17,8 @@ test('onSend hook stream', t => {
     reply.send({ hello: 'world' })
   })
 
+  const { stepIn, patience } = waitForCb({ steps: 2 })
+
   fastify.addHook('onSend', (req, reply, payload, done) => {
     const gzStream = zlib.createGzip()
 
@@ -24,7 +26,10 @@ test('onSend hook stream', t => {
     pipeline(
       fs.createReadStream(resolve(__filename), 'utf8'),
       gzStream,
-      t.error
+      (err) => {
+        t.assert.ifError(err)
+        stepIn()
+      }
     )
     done(null, gzStream)
   })
@@ -33,16 +38,19 @@ test('onSend hook stream', t => {
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-encoding'], 'gzip')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-encoding'], 'gzip')
     const file = fs.readFileSync(resolve(__filename), 'utf8')
     const payload = zlib.gunzipSync(res.rawPayload)
-    t.equal(payload.toString('utf-8'), file)
+    t.assert.strictEqual(payload.toString('utf-8'), file)
     fastify.close()
+    stepIn()
   })
+
+  return patience
 })
 
-test('onSend hook stream should work even if payload is not a proper stream', t => {
+test('onSend hook stream should work even if payload is not a proper stream', (t, testDone) => {
   t.plan(1)
 
   const reply = proxyquire('../lib/reply', {
@@ -59,8 +67,9 @@ test('onSend hook stream should work even if payload is not a proper stream', t
     fatal: () => { },
     error: () => { },
     warn: (message) => {
-      t.equal(message, 'stream payload does not end properly')
+      t.assert.strictEqual(message, 'stream payload does not end properly')
       fastify.close()
+      testDone()
     },
     info: () => { },
     debug: () => { },
@@ -83,7 +92,7 @@ test('onSend hook stream should work even if payload is not a proper stream', t
   })
 })
 
-test('onSend hook stream should work on payload with "close" ending function', t => {
+test('onSend hook stream should work on payload with "close" ending function', (t, testDone) => {
   t.plan(1)
 
   const reply = proxyquire('../lib/reply', {
@@ -106,7 +115,8 @@ test('onSend hook stream should work on payload with "close" ending function', t
       pipe: () => { },
       close: (cb) => {
         cb()
-        t.pass()
+        t.assert.ok('close callback called')
+        testDone()
       }
     }
     done(null, fakeStream)