fastify 4.28.0 → 5.0.0-alpha.3

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-test('should expose 80 errors', t => {
+test('should expose 84 errors', t => {
   t.plan(1)
   const exportedKeys = Object.keys(errors)
   let counter = 0
@@ -14,11 +14,11 @@ test('should expose 80 errors', t => {
       counter++
     }
   }
-  t.equal(counter, 80)
+  t.equal(counter, 84)
 })
 
 test('ensure name and codes of Errors are identical', t => {
-  t.plan(80)
+  t.plan(84)
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -247,6 +247,16 @@ test('FST_ERR_DEC_AFTER_START', t => {
   t.ok(error instanceof Error)
 })
 
+test('FST_ERR_DEC_REFERENCE_TYPE', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_DEC_REFERENCE_TYPE()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_DEC_REFERENCE_TYPE')
+  t.equal(error.message, "The decorator '%s' of type '%s' is a reference type. Use the { getter, setter } interface instead.")
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof Error)
+})
+
 test('FST_ERR_HOOK_INVALID_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_HOOK_INVALID_TYPE()
@@ -327,6 +337,36 @@ test('FST_ERR_LOG_INVALID_LOGGER', t => {
   t.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_LOG_INVALID_LOGGER_INSTANCE', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_INVALID_LOGGER_INSTANCE()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_INVALID_LOGGER_INSTANCE')
+  t.equal(error.message, 'loggerInstance only accepts a logger instance.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
+test('FST_ERR_LOG_INVALID_LOGGER_CONFIG', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_INVALID_LOGGER_CONFIG()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_INVALID_LOGGER_CONFIG')
+  t.equal(error.message, 'logger options only accepts a configuration object.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
+test('FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED')
+  t.equal(error.message, 'You cannot provide both logger and loggerInstance. Please provide only one.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
 test('FST_ERR_REP_INVALID_PAYLOAD_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REP_INVALID_PAYLOAD_TYPE()
@@ -587,16 +627,6 @@ test('FST_ERR_ASYNC_CONSTRAINT', t => {
   t.ok(error instanceof Error)
 })
 
-test('FST_ERR_DEFAULT_ROUTE_INVALID_TYPE', t => {
-  t.plan(5)
-  const error = new errors.FST_ERR_DEFAULT_ROUTE_INVALID_TYPE()
-  t.equal(error.name, 'FastifyError')
-  t.equal(error.code, 'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE')
-  t.equal(error.message, 'The defaultRoute type should be a function')
-  t.equal(error.statusCode, 500)
-  t.ok(error instanceof TypeError)
-})
-
 test('FST_ERR_INVALID_URL', t => {
   t.plan(5)
   const error = new errors.FST_ERR_INVALID_URL()
@@ -757,6 +787,16 @@ test('FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE', t => {
   t.ok(error instanceof Error)
 })
 
+test('FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER('easter-egg')
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER')
+  t.equal(error.message, 'The easter-egg plugin being registered mixes async and callback styles. Async plugin should not mix async and callback style.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
 test('FST_ERR_PLUGIN_CALLBACK_NOT_FN', t => {
   t.plan(5)
   const error = new errors.FST_ERR_PLUGIN_CALLBACK_NOT_FN()
@@ -838,7 +878,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 })
 
 test('Ensure that all errors are in Errors.md TOC', t => {
-  t.plan(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -850,7 +890,7 @@ test('Ensure that all errors are in Errors.md TOC', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md TOC', t => {
-  t.plan(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
@@ -863,7 +903,7 @@ test('Ensure that non-existing errors are not in Errors.md TOC', t => {
 })
 
 test('Ensure that all errors are in Errors.md documented', t => {
-  t.plan(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -875,7 +915,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
-  t.plan(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g

package/test/internals/handleRequest.test.js

@@ -94,7 +94,11 @@ test('handler function - reply', t => {
     preValidation: [],
     preHandler: [],
     onSend: [],
-    onError: []
+    onError: [],
+    config: {
+      url: '',
+      method: ''
+    }
   }
   buildSchema(context, schemaValidator)
   internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))

package/test/internals/initialConfig.test.js

@@ -45,11 +45,11 @@ test('without options passed to Fastify, initialConfig should expose default val
     onProtoPoisoning: 'error',
     onConstructorPoisoning: 'error',
     pluginTimeout: 10000,
-    requestIdHeader: 'request-id',
+    requestIdHeader: false,
     requestIdLogLabel: 'reqId',
     http2SessionTimeout: 72000,
     exposeHeadRoutes: true,
-    useSemicolonDelimiter: true
+    useSemicolonDelimiter: false
   }
 
   t.same(Fastify().initialConfig, fastifyDefaultOptions)
@@ -105,7 +105,7 @@ test('Fastify.initialConfig should expose all options', t => {
     genReqId: function (req) {
       return reqId++
     },
-    logger: pino({ level: 'info' }),
+    loggerInstance: pino({ level: 'info' }),
     constraints: {
       version: versionStrategy
     },
@@ -285,11 +285,11 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       onProtoPoisoning: 'error',
       onConstructorPoisoning: 'error',
       pluginTimeout: 10000,
-      requestIdHeader: 'request-id',
+      requestIdHeader: false,
       requestIdLogLabel: 'reqId',
       http2SessionTimeout: 72000,
       exposeHeadRoutes: true,
-      useSemicolonDelimiter: true
+      useSemicolonDelimiter: false
     })
   } catch (error) {
     t.fail()

package/test/internals/logger.test.js

@@ -46,13 +46,42 @@ test('The logger should add a unique id for every request', t => {
   }
 })
 
-test('The logger should reuse request id header for req.id', t => {
+test('The logger should not reuse request id header for req.id', t => {
   const fastify = Fastify()
   fastify.get('/', (req, reply) => {
     t.ok(req.id)
     reply.send({ id: req.id })
   })
 
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: {
+        'Request-Id': 'request-id-1'
+      }
+    }, (err, res) => {
+      t.error(err)
+      const payload = JSON.parse(res.payload)
+      t.ok(payload.id !== 'request-id-1', 'the request id from the header should not be returned with default configuration')
+      t.ok(payload.id === 'req-1') // first request id when using the default configuration
+      fastify.close()
+      t.end()
+    })
+  })
+})
+
+test('The logger should reuse request id header for req.id if requestIdHeader is set', t => {
+  const fastify = Fastify({
+    requestIdHeader: 'request-id'
+  })
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
   fastify.listen({ port: 0 }, err => {
     t.error(err)
 
@@ -127,7 +156,7 @@ test('The serializer prevent fails if the request socket is undefined', t => {
     method: 'GET',
     url: '/',
     version: undefined,
-    hostname: undefined,
+    host: undefined,
     remoteAddress: undefined,
     remotePort: undefined
   })

package/test/internals/reply.test.js

@@ -19,7 +19,7 @@ const {
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
-const { FSTDEP010, FSTDEP019, FSTDEP020, FSTDEP021 } = require('../../lib/warnings')
+const { FSTDEP010, FSTDEP019, FSTDEP021 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -36,7 +36,7 @@ const doGet = function (url) {
 }
 
 test('Once called, Reply should return an object with methods', t => {
-  t.plan(16)
+  t.plan(15)
   const response = { res: 'res' }
   const context = { config: { onSend: [] }, schema: {} }
   const request = { [kRouteContext]: context, [kPublicRouteContext]: { config: context.config, schema: context.schema } }
@@ -49,7 +49,6 @@ test('Once called, Reply should return an object with methods', t => {
   t.equal(typeof reply.status, 'function')
   t.equal(typeof reply.header, 'function')
   t.equal(typeof reply.serialize, 'function')
-  t.equal(typeof reply.getResponseTime, 'function')
   t.equal(typeof reply[kReplyHeaders], 'object')
   t.same(reply.raw, response)
   t.equal(reply[kRouteContext], context)
@@ -1415,9 +1414,9 @@ test('.statusCode is getter and setter', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
-    t.ok(reply.statusCode, 200, 'default status value')
+    t.equal(reply.statusCode, 200, 'default status value')
     reply.statusCode = 418
-    t.ok(reply.statusCode, 418)
+    t.equal(reply.statusCode, 418)
     reply.send()
   })
 
@@ -1572,82 +1571,11 @@ test('should not throw error when attempting to set reply.sent if the underlinin
   })
 })
 
-test('reply.getResponseTime() should return 0 before the timer is initialised on the reply by setting up response listeners', t => {
+test('reply.elapsedTime should return 0 before the timer is initialised on the reply by setting up response listeners', t => {
   t.plan(1)
   const response = { statusCode: 200 }
   const reply = new Reply(response, null)
-  t.equal(reply.getResponseTime(), 0)
-})
-
-test('reply.getResponseTime() should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  fastify.addHook('onResponse', (req, reply) => {
-    t.ok(reply.getResponseTime() > 0)
-    t.end()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' })
-})
-
-test('should emit deprecation warning when trying to use reply.getResponseTime() and should return the time since a request started while inflight', t => {
-  t.plan(5)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  process.removeAllListeners('warning')
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.equal(warning.name, 'DeprecationWarning')
-    t.equal(warning.code, FSTDEP020.code)
-  }
-
-  fastify.addHook('preValidation', (req, reply, done) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
-    done()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
-    t.error(err)
-    t.pass()
-
-    process.removeListener('warning', onWarning)
-  })
-
-  FSTDEP020.emitted = false
-})
-
-test('reply.getResponseTime() should return the same value after a request is finished', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  fastify.addHook('onResponse', (req, reply) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
-    t.end()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' })
+  t.equal(reply.elapsedTime, 0)
 })
 
 test('reply.elapsedTime should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {

package/test/internals/request.test.js

@@ -60,7 +60,7 @@ test('Regular request', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, 'ip')
   t.equal(request.ips, undefined)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
   t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
@@ -142,7 +142,7 @@ test('Request with undefined config', t => {
 })
 
 test('Regular request - hostname from authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     ':authority': 'authority'
   }
@@ -155,11 +155,12 @@ test('Regular request - hostname from authority', t => {
 
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
-  t.equal(request.hostname, 'authority')
+  t.equal(request.host, 'authority')
+  t.equal(request.port, null)
 })
 
 test('Regular request - host header has precedence over authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     host: 'hostname',
     ':authority': 'authority'
@@ -172,7 +173,8 @@ test('Regular request - host header has precedence over authority', t => {
   }
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
+  t.equal(request.port, null)
 })
 
 test('Request with trust proxy', t => {
@@ -222,7 +224,7 @@ test('Request with trust proxy', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, '2.2.2.2')
   t.same(request.ips, ['ip', '1.1.1.1', '2.2.2.2'])
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
   t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
@@ -272,7 +274,7 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
 })
 
 test('Request with trust proxy - no x-forwarded-host header and fallback to authority', t => {
@@ -291,7 +293,7 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'authority')
+  t.equal(request.host, 'authority')
 })
 
 test('Request with trust proxy - x-forwarded-host header has precedence over host', t => {
@@ -311,7 +313,7 @@ test('Request with trust proxy - x-forwarded-host header has precedence over hos
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
 })
 
 test('Request with trust proxy - handles multiple entries in x-forwarded-host/proto', t => {
@@ -330,7 +332,7 @@ test('Request with trust proxy - handles multiple entries in x-forwarded-host/pr
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
   t.equal(request.protocol, 'https')
 })
 
@@ -373,7 +375,7 @@ test('Request with undefined socket', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, undefined)
   t.equal(request.ips, undefined)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
   t.same(request.body, null)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')

package/test/listen.1.test.js

@@ -29,25 +29,15 @@ test('Async/await listen with arguments', async t => {
     t.fail('should not be deprecated')
   })
 
-  t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
   const address = fastify.server.address()
-  t.equal(addr, `http://${address.address}:${address.port}`)
-})
-
-test('Promise listen with arguments', t => {
-  process.on('warning', () => {
-    t.fail('should not be deprecated')
-  })
-
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({ port: 0, host: '0.0.0.0' }).then(addr => {
-    const address = fastify.server.address()
-    t.equal(addr, `http://${address.address}:${address.port}`)
+  t.equal(addr, `http://127.0.0.1:${address.port}`)
+  t.same(address, {
+    address: '0.0.0.0',
+    family: 'IPv4',
+    port: address.port
   })
 })
 

package/test/listen.5.test.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const { test } = require('tap')
+const net = require('node:net')
+const Fastify = require('../fastify')
+const { once } = require('node:events')
+
+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.error(err)
+        fastify.close((err) => {
+          t.error(err)
+          promise.resolve()
+        })
+        break
+      }
+      case 5: {
+        server.close()
+        setTimeout(() => {
+          fastify.listen(option, callback)
+        }, 100)
+        break
+      }
+      default: {
+        // expect error
+        t.equal(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.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(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()
+})

package/test/logger/instantiation.test.js

@@ -32,9 +32,9 @@ t.test('logger instantiation', (t) => {
 
     const stream = split(JSON.parse)
 
-    const logger = require('pino')(stream)
+    const loggerInstance = require('pino')(stream)
 
-    const fastify = Fastify({ logger })
+    const fastify = Fastify({ loggerInstance })
     t.teardown(fastify.close.bind(fastify))
 
     fastify.get('/foo', function (req, reply) {
@@ -203,17 +203,17 @@ t.test('logger instantiation', (t) => {
   t.test('should be able to use a custom logger', (t) => {
     t.plan(7)
 
-    const logger = {
+    const loggerInstance = {
       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
+      child: () => loggerInstance
     }
 
-    const fastify = Fastify({ logger })
+    const fastify = Fastify({ loggerInstance })
     t.teardown(fastify.close.bind(fastify))
 
     fastify.log.fatal('fatal')
@@ -223,7 +223,7 @@ t.test('logger instantiation', (t) => {
     fastify.log.debug('debug')
     fastify.log.trace('trace')
     const child = fastify.log.child()
-    t.equal(child, logger)
+    t.equal(child, loggerInstance)
   })
 
   t.test('should throw in case a partially matching logger is provided', async (t) => {
@@ -246,7 +246,7 @@ t.test('logger instantiation', (t) => {
     t.plan(lines.length + 1)
 
     const stream = split(JSON.parse)
-    const logger = require('pino')({
+    const loggerInstance = require('pino')({
       level: 'info',
       serializers: {
         req: function (req) {
@@ -258,7 +258,7 @@ t.test('logger instantiation', (t) => {
     }, stream)
 
     const fastify = Fastify({
-      logger
+      loggerInstance
     })
     t.teardown(fastify.close.bind(fastify))
 

package/test/logger/logging.test.js

@@ -29,10 +29,10 @@ t.test('logging', (t) => {
 
     const stream = split(JSON.parse)
 
-    const logger = pino({ level: 'trace' }, stream)
+    const loggerInstance = pino({ level: 'trace' }, stream)
 
     const fastify = Fastify({
-      logger
+      loggerInstance
     })
     t.teardown(fastify.close.bind(fastify))
 
@@ -229,10 +229,10 @@ t.test('logging', (t) => {
     t.plan(lines.length + 1)
 
     const stream = split(JSON.parse)
-    const logger = pino(stream)
+    const loggerInstance = pino(stream)
 
     const fastify = Fastify({
-      logger
+      loggerInstance
     })
     t.teardown(fastify.close.bind(fastify))