node-fastify 5.8.3

package/test/server.test.js

@@ -0,0 +1,347 @@
+'use strict'
+
+const dns = require('node:dns')
+const { networkInterfaces } = require('node:os')
+const { test } = require('node:test')
+const Fastify = require('..')
+const undici = require('undici')
+const proxyquire = require('proxyquire')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
+test('listen should accept null port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: null })
+  )
+})
+
+test('listen should accept undefined port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: undefined })
+  )
+})
+
+test('listen should accept stringified number port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: '1234' })
+  )
+})
+
+test('listen should accept log text resolution function', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({
+      host: '127.0.0.1',
+      port: '1234',
+      listenTextResolver: (address) => {
+        t.assert.strictEqual(address, 'http://127.0.0.1:1234')
+        return 'hardcoded text'
+      }
+    })
+  )
+})
+
+test('listen should reject string port', async (t) => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  try {
+    await fastify.listen({ port: 'hello-world' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+
+  try {
+    await fastify.listen({ port: '1234hello' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+})
+
+test('Test for hostname and port', async (t) => {
+  t.plan(3)
+  const app = Fastify()
+  t.after(() => app.close())
+  app.get('/host', (req, res) => {
+    t.assert.strictEqual(req.host, 'localhost:8000')
+    t.assert.strictEqual(req.hostname, 'localhost')
+    t.assert.strictEqual(req.port, 8000)
+    res.send('ok')
+  })
+
+  await app.listen({ port: 8000 })
+  await fetch('http://localhost:8000/host')
+})
+
+test('Test for IPV6 port', { skip: isIPv6Missing }, async (t) => {
+  t.plan(3)
+  const app = Fastify()
+  t.after(() => app.close())
+  app.get('/host', (req, res) => {
+    t.assert.strictEqual(req.host, '[::1]:3040')
+    t.assert.strictEqual(req.hostname, '[::1]')
+    t.assert.strictEqual(req.port, 3040)
+    res.send('ok')
+  })
+
+  await app.listen({
+    port: 3040,
+    host: '::1'
+  })
+  await fetch('http://[::1]:3040/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) {
+      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()
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should not start server if already aborted', (t, end) => {
+    t.plan(2)
+    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 }, (err) => {
+      t.assert.ifError(err)
+    })
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should throw if received invalid signal', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    try {
+      fastify.listen({ port: 1234, signal: {} }, (err) => {
+        t.assert.ifError(err)
+      })
+      t.assert.fail('should throw')
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_LISTEN_OPTIONS_INVALID')
+      t.assert.strictEqual(e.message, 'Invalid listen options: \'Invalid options.signal\'')
+    }
+  })
+})
+
+test('#5180 - preClose should be called before closing secondary server', async (t) => {
+  t.plan(2)
+  const fastify = Fastify({ forceCloseConnections: true })
+  let flag = false
+  t.after(() => fastify.close())
+
+  fastify.addHook('preClose', () => {
+    flag = true
+  })
+
+  fastify.get('/', async (req, reply) => {
+    // request will be pending for 1 second to simulate a slow request
+    await new Promise((resolve) => { setTimeout(resolve, 1000) })
+    return { hello: 'world' }
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.assert.ifError(err)
+    const addresses = fastify.addresses()
+    const mainServerAddress = fastify.server.address()
+    let secondaryAddress
+    for (const addr of addresses) {
+      if (addr.family !== mainServerAddress.family) {
+        secondaryAddress = addr
+        secondaryAddress.address = secondaryAddress.family === 'IPv6'
+          ? `[${secondaryAddress.address}]`
+          : secondaryAddress.address
+        break
+      }
+    }
+
+    if (!secondaryAddress) {
+      t.assert.ok(true, 'Secondary address not found')
+      return
+    }
+
+    undici.request(`http://${secondaryAddress.address}:${secondaryAddress.port}/`)
+      .then(
+        () => { t.assert.fail('Request should not succeed') },
+        () => {
+          t.assert.ok(flag)
+        }
+      )
+
+    // Close the server while the slow request is pending
+    setTimeout(fastify.close, 250)
+  })
+
+  // Wait 1000ms to ensure that the test is finished and async operations are
+  // completed
+  await new Promise((resolve) => { setTimeout(resolve, 1000) })
+})

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

@@ -0,0 +1,69 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+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)
+  const fastify = Fastify()
+
+  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 overridden 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()
+})