fastify 4.25.2 → 4.26.0

package/test/hooks.on-listen.test.js

@@ -5,9 +5,7 @@ const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
 const split = require('split2')
 const helper = require('./helper')
-
-// fix citgm @aix72-ppc64
-const LISTEN_READYNESS = process.env.CITGM ? 250 : 50
+const { kState } = require('../lib/symbols')
 
 let localhost
 before(async function () {
@@ -274,8 +272,8 @@ test('localhost Register onListen hook after a plugin inside a plugin should log
   })
 })
 
-test('localhost onListen encapsulation should be called in order', t => {
-  t.plan(6)
+test('localhost onListen encapsulation should be called in order', async t => {
+  t.plan(8)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
@@ -287,20 +285,75 @@ test('localhost onListen encapsulation should be called in order', t => {
     done()
   })
 
-  fastify.register(async (childOne, o) => {
+  await fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
       t.equal(++order, 2, 'called in childOne')
       t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
-    childOne.register(async (childTwo, o) => {
+
+    await childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
         t.equal(++order, 3, 'called in childTwo')
         t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
+
+    await childOne.register(async (childTwoPeer, o) => {
+      childTwoPeer.addHook('onListen', async function () {
+        t.equal(++order, 4, 'called second in childTwo')
+        t.equal(this.pluginName, childTwoPeer.pluginName, 'the this binding is the right instance')
+      })
+    })
   })
-  fastify.listen({
+  await fastify.listen({
+    host: 'localhost',
+    port: 0
+  })
+})
+
+test('localhost onListen encapsulation with only nested hook', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  await fastify.register(async (child) => {
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+  })
+
+  await fastify.listen({
+    host: 'localhost',
+    port: 0
+  })
+})
+
+test('localhost onListen peer encapsulations with only nested hooks', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  await fastify.register(async (child) => {
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+  })
+
+  await fastify.listen({
     host: 'localhost',
     port: 0
   })
@@ -1056,36 +1109,35 @@ test('async onListen does not need to be awaited', t => {
 
 test('onListen hooks do not block /1', t => {
   t.plan(2)
+
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
   fastify.addHook('onListen', function (done) {
-    setTimeout(done, 500)
+    t.equal(fastify[kState].listening, true)
+    done()
   })
 
-  const startDate = new Date()
   fastify.listen({
     host: 'localhost',
     port: 0
   }, err => {
     t.error(err)
-    t.ok(new Date() - startDate < LISTEN_READYNESS)
   })
 })
 
 test('onListen hooks do not block /2', async t => {
   t.plan(1)
+
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
   fastify.addHook('onListen', async function () {
-    await new Promise(resolve => setTimeout(resolve, 500))
+    t.equal(fastify[kState].listening, true)
   })
 
-  const startDate = new Date()
   await fastify.listen({
     host: 'localhost',
     port: 0
   })
-  t.ok(new Date() - startDate < LISTEN_READYNESS)
 })

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 78 errors', t => {
+test('should expose 79 errors', t => {
   t.plan(1)
   const exportedKeys = Object.keys(errors)
   let counter = 0
@@ -14,11 +14,11 @@ test('should expose 78 errors', t => {
       counter++
     }
   }
-  t.equal(counter, 78)
+  t.equal(counter, 79)
 })
 
 test('ensure name and codes of Errors are identical', t => {
-  t.plan(78)
+  t.plan(79)
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -337,6 +337,16 @@ test('FST_ERR_REP_INVALID_PAYLOAD_TYPE', t => {
   t.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_REP_RESPONSE_BODY_CONSUMED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_REP_RESPONSE_BODY_CONSUMED()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_REP_RESPONSE_BODY_CONSUMED')
+  t.equal(error.message, 'Response.body is already consumed.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof Error)
+})
+
 test('FST_ERR_REP_ALREADY_SENT', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REP_ALREADY_SENT('/hello', 'GET')
@@ -818,7 +828,7 @@ test('FST_ERR_LISTEN_OPTIONS_INVALID', t => {
 })
 
 test('Ensure that all errors are in Errors.md TOC', t => {
-  t.plan(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -830,7 +840,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(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
@@ -843,7 +853,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(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -855,7 +865,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(78)
+  t.plan(79)
   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/initialConfig.test.js

@@ -48,14 +48,15 @@ test('without options passed to Fastify, initialConfig should expose default val
     requestIdHeader: 'request-id',
     requestIdLogLabel: 'reqId',
     http2SessionTimeout: 72000,
-    exposeHeadRoutes: true
+    exposeHeadRoutes: true,
+    useSemicolonDelimiter: true
   }
 
   t.same(Fastify().initialConfig, fastifyDefaultOptions)
 })
 
 test('Fastify.initialConfig should expose all options', t => {
-  t.plan(21)
+  t.plan(22)
 
   const serverFactory = (handler, opts) => {
     const server = http.createServer((req, res) => {
@@ -99,6 +100,7 @@ test('Fastify.initialConfig should expose all options', t => {
     allowUnsafeRegex: false,
     requestIdHeader: 'request-id-alt',
     pluginTimeout: 20000,
+    useSemicolonDelimiter: false,
     querystringParser: str => str,
     genReqId: function (req) {
       return reqId++
@@ -123,6 +125,7 @@ test('Fastify.initialConfig should expose all options', t => {
   t.equal(fastify.initialConfig.bodyLimit, 1049600)
   t.equal(fastify.initialConfig.onProtoPoisoning, 'remove')
   t.equal(fastify.initialConfig.caseSensitive, true)
+  t.equal(fastify.initialConfig.useSemicolonDelimiter, false)
   t.equal(fastify.initialConfig.allowUnsafeRegex, false)
   t.equal(fastify.initialConfig.requestIdHeader, 'request-id-alt')
   t.equal(fastify.initialConfig.pluginTimeout, 20000)
@@ -285,7 +288,8 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       requestIdHeader: 'request-id',
       requestIdLogLabel: 'reqId',
       http2SessionTimeout: 72000,
-      exposeHeadRoutes: true
+      exposeHeadRoutes: true,
+      useSemicolonDelimiter: true
     })
   } catch (error) {
     t.fail()

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 { FSTDEP019, FSTDEP010 } = require('../../lib/warnings')
+const { FSTDEP010, FSTDEP019, FSTDEP020 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -1598,7 +1598,40 @@ test('reply.getResponseTime() should return a number greater than 0 after the ti
   fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.getResponseTime() should return the time since a request started while inflight', t => {
+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({
@@ -1609,19 +1642,61 @@ test('reply.getResponseTime() should return the time since a request started whi
     }
   })
 
+  fastify.addHook('onResponse', (req, reply) => {
+    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply.elapsedTime 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.elapsedTime > 0)
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply.elapsedTime should return the time since a request started while inflight', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  let preValidationElapsedTime
+
   fastify.addHook('preValidation', (req, reply, done) => {
-    t.not(reply.getResponseTime(), reply.getResponseTime())
+    preValidationElapsedTime = reply.elapsedTime
+
     done()
   })
 
   fastify.addHook('onResponse', (req, reply) => {
+    t.ok(reply.elapsedTime > preValidationElapsedTime)
     t.end()
   })
 
   fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.getResponseTime() should return the same value after a request is finished', t => {
+test('reply.elapsedTime should return the same value after a request is finished', t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1633,7 +1708,7 @@ test('reply.getResponseTime() should return the same value after a request is fi
   })
 
   fastify.addHook('onResponse', (req, reply) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    t.equal(reply.elapsedTime, reply.elapsedTime)
     t.end()
   })
 

package/test/schema-serialization.test.js

@@ -593,6 +593,47 @@ test('Custom setSerializerCompiler returns bad serialized output', t => {
   })
 })
 
+test('Custom setSerializerCompiler with addSchema', t => {
+  t.plan(6)
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  const outSchema = {
+    $id: 'test',
+    type: 'object',
+    whatever: 'need to be parsed by the custom serializer'
+  }
+
+  fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {
+    t.equal(method, 'GET')
+    t.equal(url, '/foo/:id')
+    t.equal(httpStatus, '200')
+    t.same(schema, outSchema)
+    return _data => JSON.stringify({ id: 2 })
+  })
+
+  // provoke re-creation of serialization compiler in setupSerializer
+  fastify.addSchema({ $id: 'dummy', type: 'object' })
+
+  fastify.get('/foo/:id', {
+    handler (_req, reply) {
+      reply.send({ id: 1 })
+    },
+    schema: {
+      response: {
+        200: outSchema
+      }
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/123'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ id: 2 }))
+  })
+})
+
 test('Custom serializer per route', async t => {
   const fastify = Fastify()
 

package/test/schema-validation.test.js

@@ -106,7 +106,7 @@ test('Basic validation test', t => {
 })
 
 test('External AJV instance', t => {
-  t.plan(4)
+  t.plan(5)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -118,6 +118,7 @@ test('External AJV instance', t => {
   fastify.addSchema(schemaBRefToA)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
+    t.pass('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -151,7 +152,7 @@ test('External AJV instance', t => {
 })
 
 test('Encapsulation', t => {
-  t.plan(19)
+  t.plan(21)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -164,6 +165,7 @@ test('Encapsulation', t => {
 
   fastify.register((instance, opts, done) => {
     const validator = ({ schema, method, url, httpPart }) => {
+      t.pass('custom validator compiler called')
       return ajv.compile(schema)
     }
     instance.setValidatorCompiler(validator)
@@ -271,7 +273,7 @@ test('Encapsulation', t => {
 })
 
 test('Triple $ref with a simple $id', t => {
-  t.plan(6)
+  t.plan(7)
 
   const fastify = Fastify()
   const ajv = new AJV()
@@ -285,6 +287,7 @@ test('Triple $ref with a simple $id', t => {
   fastify.addSchema(schemaCRefToB)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
+    t.pass('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -1024,19 +1027,125 @@ test("The same $id in route's schema must not overwrite others", t => {
 
 test('Custom validator compiler should not mutate schema', async t => {
   t.plan(2)
-  class Headers {}
+  class Headers { }
   const fastify = Fastify()
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
     t.type(schema, Headers)
-    return () => {}
+    return () => { }
   })
 
   fastify.get('/', {
     schema: {
       headers: new Headers()
     }
-  }, () => {})
+  }, () => { })
+
+  await fastify.ready()
+})
+
+test('Custom validator builder override by custom validator compiler', async t => {
+  t.plan(3)
+  const ajvDefaults = {
+    removeAdditional: true,
+    coerceTypes: true,
+    allErrors: true
+  }
+  const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
+  const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
+  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+
+  fastify.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
+
+  fastify.post('/two/:id', {
+    schema: {
+      params: {
+        type: 'object',
+        extended_two: true,
+        properties: {
+          id: { type: 'number' }
+        },
+        required: ['id']
+      }
+    },
+    handler: (req, _reply) => {
+      t.same(typeof req.params.id, 'number')
+      t.same(req.params.id, 43)
+      return 'ok'
+    }
+  })
 
   await fastify.ready()
+
+  const two = await fastify.inject({
+    method: 'POST',
+    url: '/two/43'
+  })
+  t.equal(two.statusCode, 200)
+})
+
+test('Custom validator builder override by custom validator compiler in child instance', async t => {
+  t.plan(6)
+  const ajvDefaults = {
+    removeAdditional: true,
+    coerceTypes: true,
+    allErrors: true
+  }
+  const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
+  const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
+  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+
+  fastify.register((embedded, _opts, done) => {
+    embedded.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
+    embedded.post('/two/:id', {
+      schema: {
+        params: {
+          type: 'object',
+          extended_two: true,
+          properties: {
+            id: { type: 'number' }
+          },
+          required: ['id']
+        }
+      },
+      handler: (req, _reply) => {
+        t.same(typeof req.params.id, 'number')
+        t.same(req.params.id, 43)
+        return 'ok'
+      }
+    })
+    done()
+  })
+
+  fastify.post('/one/:id', {
+    schema: {
+      params: {
+        type: 'object',
+        extended_one: true,
+        properties: {
+          id: { type: 'number' }
+        },
+        required: ['id']
+      }
+    },
+    handler: (req, _reply) => {
+      t.same(typeof req.params.id, 'number')
+      t.same(req.params.id, 42)
+      return 'ok'
+    }
+  })
+
+  await fastify.ready()
+
+  const one = await fastify.inject({
+    method: 'POST',
+    url: '/one/42'
+  })
+  t.equal(one.statusCode, 200)
+
+  const two = await fastify.inject({
+    method: 'POST',
+    url: '/two/43'
+  })
+  t.equal(two.statusCode, 200)
 })