fastify 5.3.3 → 5.5.0

package/test/server.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
+const dns = require('node:dns')
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 const undici = require('undici')
+const proxyquire = require('proxyquire')
 
 test('listen should accept null port', async t => {
   const fastify = Fastify()
@@ -65,7 +66,7 @@ test('listen should reject string port', async (t) => {
   }
 })
 
-test('Test for hostname and port', (t, end) => {
+test('Test for hostname and port', async (t) => {
   const app = Fastify()
   t.after(() => app.close())
   app.get('/host', (req, res) => {
@@ -76,12 +77,149 @@ test('Test for hostname and port', (t, end) => {
     res.send('ok')
   })
 
-  app.listen({ port: 8000 }, () => {
-    sget('http://localhost:8000/host', () => { end() })
-  })
+  await app.listen({ port: 8000 })
+  await fetch('http://localhost:8000/host')
 })
 
 test('abort signal', async t => {
+  await t.test('should close server when aborted after', (t, end) => {
+    t.plan(2)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, (err) => {
+      t.assert.ifError(err)
+      controller.abort()
+    })
+  })
+
+  await t.test('should close server when aborted after - promise', async (t) => {
+    t.plan(2)
+    const resolver = {}
+    resolver.promise = new Promise(function (resolve) {
+      resolver.resolve = resolve
+    })
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      resolver.resolve()
+    }
+
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    const address = await fastify.listen({ port: 1234, signal: controller.signal })
+    t.assert.ok(address)
+    controller.abort()
+    await resolver.promise
+  })
+
+  await t.test('should close server when aborted during fastify.ready - promise', async (t) => {
+    t.plan(2)
+    const resolver = {}
+    resolver.promise = new Promise(function (resolve) {
+      resolver.resolve = resolve
+    })
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      resolver.resolve()
+    }
+
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    const promise = fastify.listen({ port: 1234, signal: controller.signal })
+    controller.abort()
+    const address = await promise
+    // since the main server is not listening yet, or will not listen
+    // it should return undefined
+    t.assert.strictEqual(address, undefined)
+    await resolver.promise
+  })
+
+  await t.test('should close server when aborted during dns.lookup - promise', async (t) => {
+    t.plan(2)
+    const Fastify = proxyquire('..', {
+      './lib/server.js': proxyquire('../lib/server.js', {
+        'node:dns': {
+          lookup: function (host, option, callback) {
+            controller.abort()
+            dns.lookup(host, option, callback)
+          }
+        }
+      })
+    })
+    const resolver = {}
+    resolver.promise = new Promise(function (resolve) {
+      resolver.resolve = resolve
+    })
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      resolver.resolve()
+    }
+
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    const address = await fastify.listen({ port: 1234, signal: controller.signal })
+    // since the main server is already listening then close
+    // it should return address
+    t.assert.ok(address)
+    await resolver.promise
+  })
+
+  await t.test('should close server when aborted before', (t, end) => {
+    t.plan(1)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+
+    const controller = new AbortController()
+    controller.abort()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, () => {
+      t.assert.fail('should not reach callback')
+    })
+  })
+
+  await t.test('should close server when aborted before - promise', async (t) => {
+    t.plan(2)
+    const resolver = {}
+    resolver.promise = new Promise(function (resolve) {
+      resolver.resolve = resolve
+    })
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      resolver.resolve()
+    }
+
+    const controller = new AbortController()
+    controller.abort()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    const address = await fastify.listen({ port: 1234, signal: controller.signal })
+    t.assert.strictEqual(address, undefined) // ensure the API signature
+    await resolver.promise
+  })
+
   await t.test('listen should not start server', (t, end) => {
     t.plan(2)
     function onClose (instance, done) {

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)
     })
   })
 }