node-fastify 5.8.3

package/test/listen.2.test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+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
+
+before(async function () {
+  [, localhostForURL] = await helper.getLoopbackHost()
+})
+
+test('register after listen using Promise.resolve()', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  const handler = (req, res) => res.send({})
+  await Promise.resolve()
+    .then(() => {
+      fastify.get('/', handler)
+      fastify.register((f2, options, done) => {
+        f2.get('/plugin', handler)
+        done()
+      })
+      return fastify.ready()
+    })
+    .catch((err) => {
+      t.assert.fail(err.message)
+    })
+    .then(() => t.assert.ok('resolved'))
+})
+
+test('double listen errors', (t, done) => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 }, (err) => {
+    t.assert.ifError(err)
+    fastify.listen({ port: fastify.server.address().port }, (err, address) => {
+      t.assert.strictEqual(address, null)
+      t.assert.ok(err)
+      done()
+    })
+  })
+})
+
+test('double listen errors callback with (err, address)', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 }, (err1, address1) => {
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
+    fastify.listen({ port: fastify.server.address().port }, (err2, address2) => {
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
+    })
+  })
+})
+
+test('nonlocalhost double listen errors callback with (err, address)', { skip: isIPv6Missing }, (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ host: '::1', port: 0 }, (err, address) => {
+    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.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
+    })
+  })
+})
+
+test('listen twice on the same port', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 }, (err1, address1) => {
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
+    const s2 = Fastify()
+    t.after(() => fastify.close())
+    s2.listen({ port: fastify.server.address().port }, (err2, address2) => {
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
+    })
+  })
+})
+
+test('listen twice on the same port callback with (err, address)', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 }, (err1, address1) => {
+    const _port = fastify.server.address().port
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${_port}`)
+    t.assert.ifError(err1)
+    const s2 = Fastify()
+    t.after(() => fastify.close())
+    s2.listen({ port: _port }, (err2, address2) => {
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
+    })
+  })
+})

package/test/listen.3.test.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const os = require('node:os')
+const path = require('node:path')
+const fs = require('node:fs')
+const { test, before } = require('node:test')
+const Fastify = require('..')
+const helper = require('./helper')
+
+let localhostForURL
+
+before(async function () {
+  [, localhostForURL] = await helper.getLoopbackHost()
+})
+
+// https://nodejs.org/api/net.html#net_ipc_support
+if (os.platform() !== 'win32') {
+  test('listen on socket', async t => {
+    t.plan(2)
+    const fastify = Fastify()
+    t.after(() => fastify.close())
+
+    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').slice(2, 10)}-server.sock`)
+    try {
+      fs.unlinkSync(sockFile)
+    } catch (e) { }
+
+    await fastify.listen({ path: sockFile })
+    t.assert.deepStrictEqual(fastify.addresses(), [sockFile])
+    t.assert.strictEqual(fastify.server.address(), sockFile)
+  })
+} else {
+  test('listen on socket', async t => {
+    t.plan(2)
+    const fastify = Fastify()
+    t.after(() => fastify.close())
+
+    const sockFile = `\\\\.\\pipe\\${(Math.random().toString(16) + '0000000').slice(2, 10)}-server-sock`
+
+    await fastify.listen({ path: sockFile })
+    t.assert.deepStrictEqual(fastify.addresses(), [sockFile])
+    t.assert.strictEqual(fastify.server.address(), sockFile)
+  })
+}
+
+test('listen without callback with (address)', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  const address = await fastify.listen({ port: 0 })
+  t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+})
+
+test('double listen without callback rejects', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 })
+    .then(() => {
+      fastify.listen({ port: 0 })
+        .catch(err => {
+          t.assert.ok(err)
+          done()
+        })
+    })
+    .catch(err => t.assert.ifError(err))
+})
+
+test('double listen without callback with (address)', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 })
+    .then(address => {
+      t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+      fastify.listen({ port: 0 })
+        .catch(err => {
+          t.assert.ok(err)
+          done()
+        })
+    })
+    .catch(err => t.assert.ifError(err))
+})

package/test/listen.4.test.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const { test, before } = require('node:test')
+const dns = require('node:dns').promises
+const dnsCb = require('node:dns')
+const Fastify = require('../fastify')
+const helper = require('./helper')
+
+let localhostForURL
+
+function getUrl (fastify, lookup) {
+  const { port } = fastify.server.address()
+  if (lookup.family === 6) {
+    return `http://[${lookup.address}]:${port}/`
+  } else {
+    return `http://${lookup.address}:${port}/`
+  }
+}
+
+before(async function () {
+  [, localhostForURL] = await helper.getLoopbackHost()
+})
+
+test('listen twice on the same port without callback rejects', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.listen({ port: 0 })
+    .then(() => {
+      const server2 = Fastify()
+      t.after(() => server2.close())
+      server2.listen({ port: fastify.server.address().port })
+        .catch(err => {
+          t.assert.ok(err)
+          done()
+        })
+    })
+    .catch(err => {
+      t.assert.ifError(err)
+    })
+})
+
+test('listen twice on the same port without callback rejects with (address)', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.listen({ port: 0 })
+    .then(address => {
+      const server2 = Fastify()
+      t.after(() => server2.close())
+      t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+
+      server2.listen({ port: fastify.server.address().port })
+        .catch(err => {
+          t.assert.ok(err)
+          done()
+        })
+    })
+    .catch(err => {
+      t.assert.ifError(err)
+    })
+})
+
+test('listen on invalid port without callback rejects', t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  return fastify.listen({ port: -1 })
+    .catch(err => {
+      t.assert.ok(err)
+      return true
+    })
+})
+
+test('listen logs the port as info', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  const msgs = []
+  fastify.log.info = function (msg) {
+    msgs.push(msg)
+  }
+
+  await fastify.listen({ port: 0 })
+  t.assert.ok(/http:\/\//.test(msgs[0]))
+})
+
+test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
+  const localAddresses = await dns.lookup('localhost', { all: true })
+  t.plan(3 * localAddresses.length)
+
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.after(() => app.close())
+  await app.listen({ port: 0, host: 'localhost' })
+
+  for (const lookup of localAddresses) {
+    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', 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 => {
+  let localAddresses = await dns.lookup('localhost', { all: true })
+
+  t.plan(4)
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.after(() => app.close())
+
+  t.assert.deepStrictEqual(app.addresses(), [], 'before ready')
+  await app.ready()
+
+  t.assert.deepStrictEqual(app.addresses(), [], 'after ready')
+  await app.listen({ port: 0, host: 'localhost' })
+
+  // fix citgm
+  // dns lookup may have duplicated addresses (rhel8-s390x rhel8-ppc64le debian10-x64)
+
+  localAddresses = [...new Set([...localAddresses.map(a => JSON.stringify({
+    address: a.address,
+    family: typeof a.family === 'number' ? 'IPv' + a.family : a.family
+  }))])].sort()
+
+  const appAddresses = app.addresses().map(a => JSON.stringify({
+    address: a.address,
+    family: typeof a.family === 'number' ? 'IPv' + a.family : a.family
+  })).sort()
+
+  t.assert.deepStrictEqual(appAddresses, localAddresses, 'after listen')
+
+  await app.close()
+  t.assert.deepStrictEqual(app.addresses(), [], 'after close')
+})

package/test/listen.5.test.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { test } = require('node:test')
+const net = require('node:net')
+const Fastify = require('../fastify')
+const { once } = require('node:events')
+const { FSTWRN003 } = require('../lib/warnings.js')
+
+function createDeferredPromise () {
+  const promise = {}
+  promise.promise = new Promise((resolve) => {
+    promise.resolve = resolve
+  })
+  return promise
+}
+
+test('same port conflict and success should not fire callback multiple times - callback', async (t) => {
+  t.plan(7)
+  const server = net.createServer()
+  server.listen({ port: 0, host: '127.0.0.1' })
+  await once(server, 'listening')
+  const option = { port: server.address().port, host: server.address().address }
+  let count = 0
+  const fastify = Fastify()
+  const promise = createDeferredPromise()
+  function callback (err) {
+    switch (count) {
+      case 6: {
+        // success in here
+        t.assert.ifError(err)
+        fastify.close((err) => {
+          t.assert.ifError(err)
+          promise.resolve()
+        })
+        break
+      }
+      case 5: {
+        server.close()
+        setTimeout(() => {
+          fastify.listen(option, callback)
+        }, 100)
+        break
+      }
+      default: {
+        // expect error
+        t.assert.strictEqual(err.code, 'EADDRINUSE')
+        setTimeout(() => {
+          fastify.listen(option, callback)
+        }, 100)
+      }
+    }
+    count++
+  }
+  fastify.listen(option, callback)
+  await promise.promise
+})
+
+test('same port conflict and success should not fire callback multiple times - promise', async (t) => {
+  t.plan(5)
+  const server = net.createServer()
+  server.listen({ port: 0, host: '127.0.0.1' })
+  await once(server, 'listening')
+  const option = { port: server.address().port, host: server.address().address }
+  const fastify = Fastify()
+
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
+  }
+
+  server.close()
+
+  await once(server, 'close')
+
+  // when ever we can listen, and close properly
+  // which means there is no problem on the callback
+  await fastify.listen()
+  await fastify.close()
+})
+
+test('should emit a warning when using async callback', (t, done) => {
+  t.plan(2)
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN003.code)
+  }
+
+  const fastify = Fastify()
+
+  t.after(async () => {
+    await fastify.close()
+    process.removeListener('warning', onWarning)
+    FSTWRN003.emitted = false
+  })
+
+  fastify.listen({ port: 0 }, async function doNotUseAsyncCallback () {
+    done()
+  })
+})