fastify 4.23.2 → 4.24.1

package/test/listen.4.test.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const { test, before } = require('tap')
+const dns = require('node:dns').promises
+const dnsCb = require('node:dns')
+const sget = require('simple-get').concat
+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 => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen({ port: 0 })
+    .then(() => {
+      const s2 = Fastify()
+      t.teardown(s2.close.bind(s2))
+      s2.listen({ port: fastify.server.address().port })
+        .catch(err => {
+          t.ok(err)
+        })
+    })
+    .catch(err => t.error(err))
+})
+
+test('listen twice on the same port without callback rejects with (address)', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  fastify.listen({ port: 0 })
+    .then(address => {
+      const s2 = Fastify()
+      t.teardown(s2.close.bind(s2))
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+      s2.listen({ port: fastify.server.address().port })
+        .catch(err => {
+          t.ok(err)
+        })
+    })
+    .catch(err => t.error(err))
+})
+
+test('listen on invalid port without callback rejects', t => {
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  return fastify.listen({ port: -1 })
+    .catch(err => {
+      t.ok(err)
+      return true
+    })
+})
+
+test('listen logs the port as info', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  const msgs = []
+  fastify.log.info = function (msg) {
+    msgs.push(msg)
+  }
+
+  fastify.listen({ port: 0 })
+    .then(() => {
+      t.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(2 * localAddresses.length)
+
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.teardown(app.close.bind(app))
+  await app.listen({ port: 0, host: 'localhost' })
+
+  for (const lookup of localAddresses) {
+    await new Promise((resolve, reject) => {
+      sget({
+        method: 'GET',
+        url: getUrl(app, lookup)
+      }, (err, response, body) => {
+        if (err) { return reject(err) }
+        t.equal(response.statusCode, 200)
+        t.same(body.toString(), 'hello localhost')
+        resolve()
+      })
+    })
+  }
+})
+
+test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', t => {
+  dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
+    t.plan(2 + (3 * lookups.length))
+    t.error(err)
+
+    const app = Fastify()
+    app.get('/', async () => 'hello localhost')
+    app.listen({ port: 0, host: 'localhost' }, (err) => {
+      t.error(err)
+      t.teardown(app.close.bind(app))
+
+      for (const lookup of lookups) {
+        sget({
+          method: 'GET',
+          url: getUrl(app, lookup)
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+          t.same(body.toString(), '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.same(app.addresses(), [], 'before ready')
+  await app.ready()
+
+  t.same(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.same(appAddresses, localAddresses, 'after listen')
+
+  await app.close()
+  t.same(app.addresses(), [], 'after close')
+})

package/test/listen.deprecated.test.js

@@ -4,22 +4,16 @@
 // removed when the deprecation is complete.
 
 const { test, before } = require('tap')
-const dns = require('node:dns').promises
 const Fastify = require('..')
+const helper = require('./helper')
 
 let localhost
 let localhostForURL
 
 process.removeAllListeners('warning')
 
-before(async function (t) {
-  const lookup = await dns.lookup('localhost')
-  localhost = lookup.address
-  if (lookup.family === 6) {
-    localhostForURL = `[${lookup.address}]`
-  } else {
-    localhostForURL = localhost
-  }
+before(async () => {
+  [localhost, localhostForURL] = await helper.getLoopbackHost()
 })
 
 test('listen accepts a port and a callback', t => {

package/test/logger/instantiation.test.js

@@ -0,0 +1,347 @@
+'use strict'
+
+const stream = require('node:stream')
+const os = require('node:os')
+const fs = require('node:fs')
+
+const t = require('tap')
+const split = require('split2')
+
+const { streamSym } = require('pino/lib/symbols')
+
+const Fastify = require('../../fastify')
+const helper = require('../helper')
+const { FST_ERR_LOG_INVALID_LOGGER } = require('../../lib/errors')
+const { once, on } = stream
+const { createTempFile, request } = require('./logger-test-utils')
+
+t.test('logger instantiation', (t) => {
+  t.setTimeout(60000)
+
+  let localhost
+  let localhostForURL
+
+  t.plan(11)
+  t.before(async function () {
+    [localhost, localhostForURL] = await helper.getLoopbackHost()
+  })
+
+  t.test('can use external logger instance', async (t) => {
+    const lines = [/^Server listening at /, /^incoming request$/, /^log success$/, /^request completed$/]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const logger = require('pino')(stream)
+
+    const fastify = Fastify({ logger })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/foo', function (req, reply) {
+      t.ok(req.log)
+      req.log.info('log success')
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.listen({ port: 0, host: localhost })
+
+    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/foo')
+
+    for await (const [line] of on(stream, 'data')) {
+      const regex = lines.shift()
+      t.ok(regex.test(line.msg), '"' + line.msg + '" dont match "' + regex + '"')
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('should create a default logger if provided one is invalid', (t) => {
+    t.plan(8)
+
+    const logger = new Date()
+
+    const fastify = Fastify({ logger })
+    t.teardown(fastify.close.bind(fastify))
+
+    t.equal(typeof fastify.log, 'object')
+    t.equal(typeof fastify.log.fatal, 'function')
+    t.equal(typeof fastify.log.error, 'function')
+    t.equal(typeof fastify.log.warn, 'function')
+    t.equal(typeof fastify.log.info, 'function')
+    t.equal(typeof fastify.log.debug, 'function')
+    t.equal(typeof fastify.log.trace, 'function')
+    t.equal(typeof fastify.log.child, 'function')
+  })
+
+  t.test('expose the logger', async (t) => {
+    t.plan(2)
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        level: 'info'
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    await fastify.ready()
+
+    t.ok(fastify.log)
+    t.same(typeof fastify.log, 'object')
+  })
+
+  t.test('Wrap IPv6 address in listening log message', async (t) => {
+    t.plan(1)
+
+    const interfaces = os.networkInterfaces()
+    const ipv6 = Object.keys(interfaces)
+      .filter(name => name.substr(0, 2) === 'lo')
+      .map(name => interfaces[name])
+      .reduce((list, set) => list.concat(set), [])
+      .filter(info => info.family === 'IPv6')
+      .map(info => info.address)
+      .shift()
+
+    if (ipv6 === undefined) {
+      t.pass('No IPv6 loopback interface')
+    } else {
+      const stream = split(JSON.parse)
+      const fastify = Fastify({
+        logger: {
+          stream,
+          level: 'info'
+        }
+      })
+      t.teardown(fastify.close.bind(fastify))
+
+      await fastify.ready()
+      await fastify.listen({ port: 0, host: ipv6 })
+
+      {
+        const [line] = await once(stream, 'data')
+        t.same(line.msg, `Server listening at http://[${ipv6}]:${fastify.server.address().port}`)
+      }
+    }
+  })
+
+  t.test('Do not wrap IPv4 address', async (t) => {
+    t.plan(1)
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        level: 'info'
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    await fastify.ready()
+    await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+    {
+      const [line] = await once(stream, 'data')
+      t.same(line.msg, `Server listening at http://127.0.0.1:${fastify.server.address().port}`)
+    }
+  })
+
+  t.test('file option', async (t) => {
+    const lines = [
+      { msg: /Server listening at/ },
+      { reqId: /req-/, req: { method: 'GET', url: '/' }, msg: 'incoming request' },
+      { reqId: /req-/, res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+
+    const { file, cleanup } = createTempFile(t)
+    if (process.env.CITGM) { fs.writeFileSync(file, '') }
+
+    const fastify = Fastify({
+      logger: { file }
+    })
+
+    t.teardown(async () => {
+      await helper.sleep(250)
+      // may fail on win
+      try {
+        // cleanup the file after sonic-boom closed
+        // otherwise we may face racing condition
+        fastify.log[streamSym].once('close', cleanup)
+        // we must flush the stream ourself
+        // otherwise buffer may whole sonic-boom
+        fastify.log[streamSym].flushSync()
+        // end after flushing to actually close file
+        fastify.log[streamSym].end()
+      } catch (err) {
+        console.warn(err)
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/', function (req, reply) {
+      t.ok(req.log)
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    await fastify.listen({ port: 0, host: localhost })
+    await request(`http://${localhostForURL}:` + fastify.server.address().port)
+
+    await helper.sleep(250)
+
+    const log = fs.readFileSync(file, 'utf8').split('\n')
+    // strip last line
+    log.pop()
+
+    let id
+    for (let line of log) {
+      line = JSON.parse(line)
+      if (id === undefined && line.reqId) id = line.reqId
+      if (id !== undefined && line.reqId) t.equal(line.reqId, id)
+      t.match(line, lines.shift())
+    }
+  })
+
+  t.test('should be able to use a custom logger', (t) => {
+    t.plan(7)
+
+    const logger = {
+      fatal: (msg) => { t.equal(msg, 'fatal') },
+      error: (msg) => { t.equal(msg, 'error') },
+      warn: (msg) => { t.equal(msg, 'warn') },
+      info: (msg) => { t.equal(msg, 'info') },
+      debug: (msg) => { t.equal(msg, 'debug') },
+      trace: (msg) => { t.equal(msg, 'trace') },
+      child: () => logger
+    }
+
+    const fastify = Fastify({ logger })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.log.fatal('fatal')
+    fastify.log.error('error')
+    fastify.log.warn('warn')
+    fastify.log.info('info')
+    fastify.log.debug('debug')
+    fastify.log.trace('trace')
+    const child = fastify.log.child()
+    t.equal(child, logger)
+  })
+
+  t.test('should throw in case a partially matching logger is provided', async (t) => {
+    t.plan(1)
+
+    try {
+      const fastify = Fastify({ logger: console })
+      await fastify.ready()
+    } catch (err) {
+      t.equal(
+        err instanceof FST_ERR_LOG_INVALID_LOGGER,
+        true,
+        "Invalid logger object provided. The logger instance should have these functions(s): 'fatal,child'."
+      )
+    }
+  })
+
+  t.test('can use external logger instance with custom serializer', async (t) => {
+    const lines = [['level', 30], ['req', { url: '/foo' }], ['level', 30], ['res', { statusCode: 200 }]]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+    const logger = require('pino')({
+      level: 'info',
+      serializers: {
+        req: function (req) {
+          return {
+            url: req.url
+          }
+        }
+      }
+    }, stream)
+
+    const fastify = Fastify({
+      logger
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/foo', function (req, reply) {
+      t.ok(req.log)
+      req.log.info('log success')
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    await fastify.listen({ port: 0, host: localhost })
+
+    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/foo')
+
+    for await (const [line] of on(stream, 'data')) {
+      const check = lines.shift()
+      const key = check[0]
+      const value = check[1]
+      t.same(line[key], value)
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('The logger should accept custom serializer', async (t) => {
+    const lines = [
+      { msg: /^Server listening at / },
+      { req: { url: '/custom' }, msg: 'incoming request' },
+      { res: { statusCode: 500 }, msg: 'kaboom' },
+      { res: { statusCode: 500 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        level: 'info',
+        serializers: {
+          req: function (req) {
+            return {
+              url: req.url
+            }
+          }
+        }
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/custom', function (req, reply) {
+      t.ok(req.log)
+      reply.send(new Error('kaboom'))
+    })
+
+    await fastify.ready()
+    await fastify.listen({ port: 0, host: localhost })
+
+    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/custom')
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('should throw in case the external logger provided does not have a child method', async (t) => {
+    t.plan(1)
+    const loggerInstance = {
+      info: console.info,
+      error: console.error,
+      debug: console.debug,
+      fatal: console.error,
+      warn: console.warn,
+      trace: console.trace
+    }
+
+    try {
+      const fastify = Fastify({ logger: loggerInstance })
+      await fastify.ready()
+    } catch (err) {
+      t.equal(
+        err instanceof FST_ERR_LOG_INVALID_LOGGER,
+        true,
+        "Invalid logger object provided. The logger instance should have these functions(s): 'child'."
+      )
+    }
+  })
+})

package/test/logger/logger-test-utils.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const http = require('node:http')
+const os = require('node:os')
+const fs = require('node:fs')
+
+const path = require('node:path')
+
+function createDeferredPromise () {
+  const promise = {}
+  promise.promise = new Promise(function (resolve) {
+    promise.resolve = resolve
+  })
+  return promise
+}
+
+let count = 0
+function createTempFile () {
+  const file = path.join(os.tmpdir(), `sonic-boom-${process.pid}-${count++}`)
+  function cleanup () {
+    try {
+      fs.unlinkSync(file)
+    } catch { }
+  }
+  return { file, cleanup }
+}
+
+function request (url, cleanup = () => { }) {
+  const promise = createDeferredPromise()
+  http.get(url, (res) => {
+    const chunks = []
+    // we consume the response
+    res.on('data', function (chunk) {
+      chunks.push(chunk)
+    })
+    res.once('end', function () {
+      cleanup(res, Buffer.concat(chunks).toString())
+      promise.resolve()
+    })
+  })
+  return promise.promise
+}
+
+module.exports = {
+  request,
+  createTempFile
+}