fastify 3.9.2 → 3.12.0

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

@@ -90,22 +90,22 @@ t.test('listen and onReady order', async t => {
   const fastify = Fastify()
   let order = 0
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.ready(checkOrder.bind(null, 0))
     instance.addHook('onReady', checkOrder.bind(null, 4))
 
-    instance.register((subinstance, opts, next) => {
+    instance.register((subinstance, opts, done) => {
       subinstance.ready(checkOrder.bind(null, 1))
       subinstance.addHook('onReady', checkOrder.bind(null, 5))
 
-      subinstance.register((realSubInstance, opts, next) => {
+      subinstance.register((realSubInstance, opts, done) => {
         realSubInstance.ready(checkOrder.bind(null, 2))
         realSubInstance.addHook('onReady', checkOrder.bind(null, 6))
-        next()
+        done()
       })
-      next()
+      done()
     })
-    next()
+    done()
   })
 
   fastify.addHook('onReady', checkOrder.bind(null, 3))
@@ -347,19 +347,19 @@ t.test('ready return registered', t => {
   t.plan(4)
   const fastify = Fastify()
 
-  fastify.register((one, opts, next) => {
+  fastify.register((one, opts, done) => {
     one.ready().then(itself => { t.deepEquals(itself, one) })
-    next()
+    done()
   })
 
-  fastify.register((two, opts, next) => {
+  fastify.register((two, opts, done) => {
     two.ready().then(itself => { t.deepEquals(itself, two) })
 
-    two.register((twoDotOne, opts, next) => {
+    two.register((twoDotOne, opts, done) => {
       twoDotOne.ready().then(itself => { t.deepEquals(itself, twoDotOne) })
-      next()
+      done()
     })
-    next()
+    done()
   })
 
   fastify.ready()

package/test/hooks.test.js

@@ -429,14 +429,14 @@ test('onRoute hook should be called (encapsulation support) / 4', t => {
     t.pass()
   })
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
       t.pass()
     })
     instance.get('/nested', opts, function (req, reply) {
       reply.send()
     })
-    next()
+    done()
   })
 
   fastify.get('/', function (req, reply) {
@@ -456,14 +456,14 @@ test('onRoute hook should be called (encapsulation support) / 5', t => {
     reply.send()
   })
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
       t.pass()
     })
     instance.get('/nested', opts, function (req, reply) {
       reply.send()
     })
-    next()
+    done()
   })
 
   fastify.get('/second', function (req, reply) {
@@ -664,12 +664,55 @@ test('onRoute hook should preserve handler function in options of shorthand rout
   })
 })
 
+// issue ref https://github.com/fastify/fastify-compress/issues/140
+test('onRoute hook should be called once when prefixTrailingSlash', t => {
+  t.plan(3)
+
+  let onRouteCalled = 0
+  let routePatched = 0
+
+  const fastify = Fastify({ ignoreTrailingSlash: false })
+
+  // a plugin that patches route options, similar to fastify-compress
+  fastify.register(fp(function myPlugin (instance, opts, next) {
+    function patchTheRoute () {
+      routePatched++
+    }
+
+    instance.addHook('onRoute', function (routeOptions) {
+      onRouteCalled++
+      patchTheRoute(routeOptions)
+    })
+
+    next()
+  }))
+
+  fastify.register(function routes (instance, opts, next) {
+    instance.route({
+      method: 'GET',
+      url: '/',
+      prefixTrailingSlash: 'both',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  fastify.ready(err => {
+    t.error(err)
+    t.is(onRouteCalled, 1) // onRoute hook was called once
+    t.is(routePatched, 1) // and plugin acted once and avoided redundaunt route patching
+  })
+})
+
 test('onRoute hook should able to change the route url', t => {
   t.plan(5)
 
   const fastify = Fastify()
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
       t.strictEqual(route.url, '/föö')
       route.url = encodeURI(route.url)
@@ -679,7 +722,7 @@ test('onRoute hook should able to change the route url', t => {
       reply.send('here /föö')
     })
 
-    next()
+    done()
   })
 
   fastify.listen(0, err => {
@@ -701,14 +744,14 @@ test('onRoute hook that throws should be caught ', t => {
   t.plan(1)
   const fastify = Fastify()
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
       throw new Error('snap')
     })
     instance.get('/', opts, function (req, reply) {
       reply.send()
     })
-    next()
+    done()
   })
 
   fastify.ready(err => {
@@ -726,17 +769,17 @@ test('onRoute hook with many prefix', t => {
     { routePath: '/aPath', prefix: '/one', url: '/one/aPath' }
   ]
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
       t.like(route, onRouteChecks.pop())
     })
     instance.route({ method: 'GET', url: '/aPath', handler })
 
-    instance.register((instance, opts, next) => {
+    instance.register((instance, opts, done) => {
       instance.route({ method: 'GET', path: '/anotherPath', handler })
-      next()
+      done()
     }, { prefix: '/two' })
-    next()
+    done()
   }, { prefix: '/one' })
 
   fastify.ready(err => { t.error(err) })
@@ -1619,7 +1662,7 @@ test('preHandler respond with a stream', t => {
   })
 
   // we are calling `reply.send` inside the `preHandler` hook with a stream,
-  // this triggers the `onSend` hook event if `preHanlder` has not yet finished
+  // this triggers the `onSend` hook event if `preHandler` has not yet finished
   const order = [1, 2]
 
   fastify.addHook('preHandler', (req, reply, done) => {
@@ -2941,8 +2984,8 @@ test('onRegister hook should be called / 1', t => {
   })
 
   const pluginOpts = { prefix: 'hello', custom: 'world' }
-  fastify.register((instance, opts, next) => {
-    next()
+  fastify.register((instance, opts, done) => {
+    done()
   }, pluginOpts)
 
   fastify.ready(err => { t.error(err) })
@@ -2957,15 +3000,15 @@ test('onRegister hook should be called / 2', t => {
     t.ok(instance.addHook)
   })
 
-  fastify.register((instance, opts, next) => {
-    instance.register((instance, opts, next) => {
-      next()
+  fastify.register((instance, opts, done) => {
+    instance.register((instance, opts, done) => {
+      done()
     })
-    next()
+    done()
   })
 
-  fastify.register((instance, opts, next) => {
-    next()
+  fastify.register((instance, opts, done) => {
+    done()
   })
 
   fastify.ready(err => {
@@ -2983,20 +3026,20 @@ test('onRegister hook should be called / 3', t => {
     instance.data = instance.data.slice()
   })
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.data.push(1)
-    instance.register((instance, opts, next) => {
+    instance.register((instance, opts, done) => {
       instance.data.push(2)
       t.deepEqual(instance.data, [1, 2])
-      next()
+      done()
     })
     t.deepEqual(instance.data, [1])
-    next()
+    done()
   })
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     t.deepEqual(instance.data, [])
-    next()
+    done()
   })
 
   fastify.ready(err => {
@@ -3008,8 +3051,8 @@ test('onRegister hook should be called (encapsulation)', t => {
   t.plan(1)
   const fastify = Fastify()
 
-  function plugin (instance, opts, next) {
-    next()
+  function plugin (instance, opts, done) {
+    done()
   }
   plugin[Symbol.for('skip-override')] = true
 
@@ -3051,7 +3094,7 @@ test('reply.send should throw if undefined error is thrown', t => {
   t.plan(3)
   const fastify = Fastify()
 
-  fastify.addHook('onRequest', function (req, reply, next) {
+  fastify.addHook('onRequest', function (req, reply, done) {
     return Promise.reject()
   })
 
@@ -3078,9 +3121,9 @@ test('onTimeout should be triggered', t => {
   t.plan(6)
   const fastify = Fastify({ connectionTimeout: 500 })
 
-  fastify.addHook('onTimeout', function (req, res, next) {
+  fastify.addHook('onTimeout', function (req, res, done) {
     t.ok('called', 'onTimeout')
-    next()
+    done()
   })
 
   fastify.get('/', async (req, reply) => {

package/test/http2/closing.test.js

@@ -4,9 +4,11 @@ const t = require('tap')
 const Fastify = require('../..')
 const http2 = require('http2')
 const semver = require('semver')
+const fs = require('fs')
+const path = require('path')
 const { promisify } = require('util')
 const connect = promisify(http2.connect)
-const once = require('events.once')
+const { once } = require('events')
 
 t.test('http/2 request while fastify closing', t => {
   let fastify
@@ -119,6 +121,26 @@ t.test('http/2 closes successfully with async await', { skip: semver.lt(process.
   await fastify.close()
 })
 
+// Skipped because there is likely a bug on Node 8.
+t.test('https/2 closes successfully with async await', { skip: semver.lt(process.versions.node, '10.15.0') }, async t => {
+  const fastify = Fastify({
+    http2SessionTimeout: 100,
+    http2: true,
+    https: {
+      key: fs.readFileSync(path.join(__dirname, '..', 'https', 'fastify.key')),
+      cert: fs.readFileSync(path.join(__dirname, '..', 'https', 'fastify.cert'))
+    }
+  })
+
+  await fastify.listen(0)
+
+  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const session = await connect(url)
+  // An error might or might not happen, as it's OS dependent.
+  session.on('error', () => {})
+  await fastify.close()
+})
+
 // Skipped because there is likely a bug on Node 8.
 t.test('http/2 server side session emits a timeout event', { skip: semver.lt(process.versions.node, '10.15.0') }, async t => {
   let _resolve

package/test/inject.test.js

@@ -19,12 +19,12 @@ test('should wait for the ready event', t => {
   const fastify = Fastify()
   const payload = { hello: 'world' }
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     instance.get('/', (req, reply) => {
       reply.send(payload)
     })
 
-    setTimeout(next, 500)
+    setTimeout(done, 500)
   })
 
   fastify.inject({
@@ -311,8 +311,8 @@ test('should reject in error case', t => {
   const fastify = Fastify()
 
   const error = new Error('DOOM!')
-  fastify.register((instance, opts, next) => {
-    setTimeout(next, 500, error)
+  fastify.register((instance, opts, done) => {
+    setTimeout(done, 500, error)
   })
 
   fastify.inject({
@@ -444,8 +444,8 @@ test('should support builder-style injection with non-ready app', async (t) => {
 test('should handle errors in builder-style injection correctly', async (t) => {
   t.plan(2)
   const fastify = Fastify()
-  fastify.register((instance, opts, next) => {
-    next(new Error('Kaboom'))
+  fastify.register((instance, opts, done) => {
+    done(new Error('Kaboom'))
   })
 
   try {

package/test/input-validation.js

@@ -94,7 +94,7 @@ module.exports.payloadMethod = function (method, t) {
         reply.send(req.body)
       })
 
-      fastify.register(function (fastify2, opts, next) {
+      fastify.register(function (fastify2, opts, done) {
         fastify2.setValidatorCompiler(function schema ({ schema, method, url, httpPart }) {
           return body => ({ error: new Error('From custom schema compiler!') })
         })
@@ -125,7 +125,7 @@ module.exports.payloadMethod = function (method, t) {
         }
         fastify2[loMethod]('/plugin/custom', optsWithCustomValidator2, (req, reply) => reply.send({ hello: 'never here!' }))
 
-        next()
+        done()
       })
       t.pass()
     } catch (e) {

package/test/internals/hookRunner.test.js

@@ -9,26 +9,26 @@ test('hookRunner - Basic', t => {
 
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
-    return fn(a, b, next)
+  function iterator (fn, a, b, done) {
+    return fn(a, b, done)
   }
 
-  function fn1 (a, b, next) {
+  function fn1 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
-  function fn2 (a, b, next) {
+  function fn2 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
-  function fn3 (a, b, next) {
+  function fn3 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
   function done (err, a, b) {
@@ -43,20 +43,20 @@ test('hookRunner - In case of error should skip to done', t => {
 
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
-    return fn(a, b, next)
+  function iterator (fn, a, b, done) {
+    return fn(a, b, done)
   }
 
-  function fn1 (a, b, next) {
+  function fn1 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
-  function fn2 (a, b, next) {
+  function fn2 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next(new Error('kaboom'))
+    done(new Error('kaboom'))
   }
 
   function fn3 () {
@@ -75,17 +75,17 @@ test('hookRunner - Should handle throw', t => {
 
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
-    return fn(a, b, next)
+  function iterator (fn, a, b, done) {
+    return fn(a, b, done)
   }
 
-  function fn1 (a, b, next) {
+  function fn1 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
-  function fn2 (a, b, next) {
+  function fn2 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
     throw new Error('kaboom')
@@ -107,8 +107,8 @@ test('hookRunner - Should handle promises', t => {
 
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
-    return fn(a, b, next)
+  function iterator (fn, a, b, done) {
+    return fn(a, b, done)
   }
 
   function fn1 (a, b) {
@@ -141,8 +141,8 @@ test('hookRunner - In case of error should skip to done (with promises)', t => {
 
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
-    return fn(a, b, next)
+  function iterator (fn, a, b, done) {
+    return fn(a, b, done)
   }
 
   function fn1 (a, b) {
@@ -174,17 +174,17 @@ test('hookRunner - Be able to exit before its natural end', t => {
   let shouldStop = false
   hookRunner([fn1, fn2, fn3], iterator, 'a', 'b', done)
 
-  function iterator (fn, a, b, next) {
+  function iterator (fn, a, b, done) {
     if (shouldStop) {
       return undefined
     }
-    return fn(a, b, next)
+    return fn(a, b, done)
   }
 
-  function fn1 (a, b, next) {
+  function fn1 (a, b, done) {
     t.strictEqual(a, 'a')
     t.strictEqual(b, 'b')
-    next()
+    done()
   }
 
   function fn2 (a, b) {
@@ -210,21 +210,21 @@ test('hookRunner - Promises that resolve to a value do not change the state', t
 
   hookRunner([fn1, fn2, fn3], iterator, originalState, 'b', done)
 
-  function iterator (fn, state, b, next) {
-    return fn(state, b, next)
+  function iterator (fn, state, b, done) {
+    return fn(state, b, done)
   }
 
-  function fn1 (state, b, next) {
+  function fn1 (state, b, done) {
     t.strictEqual(state, originalState)
     return Promise.resolve(null)
   }
 
-  function fn2 (state, b, next) {
+  function fn2 (state, b, done) {
     t.strictEqual(state, originalState)
     return Promise.resolve('string')
   }
 
-  function fn3 (state, b, next) {
+  function fn3 (state, b, done) {
     t.strictEqual(state, originalState)
     return Promise.resolve({ object: true })
   }
@@ -244,25 +244,25 @@ test('onSendHookRunner - Basic', t => {
 
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, originalPayload, done)
 
-  function fn1 (request, reply, payload, next) {
+  function fn1 (request, reply, payload, done) {
     t.deepEqual(request, originalRequest)
     t.deepEqual(reply, originalReply)
     t.strictEqual(payload, originalPayload)
-    next()
+    done()
   }
 
-  function fn2 (request, reply, payload, next) {
+  function fn2 (request, reply, payload, done) {
     t.deepEqual(request, originalRequest)
     t.deepEqual(reply, originalReply)
     t.strictEqual(payload, originalPayload)
-    next()
+    done()
   }
 
-  function fn3 (request, reply, payload, next) {
+  function fn3 (request, reply, payload, done) {
     t.deepEqual(request, originalRequest)
     t.deepEqual(reply, originalReply)
     t.strictEqual(payload, originalPayload)
-    next()
+    done()
   }
 
   function done (err, request, reply, payload) {
@@ -285,19 +285,19 @@ test('onSendHookRunner - Can change the payload', t => {
 
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
-  function fn1 (request, reply, payload, next) {
+  function fn1 (request, reply, payload, done) {
     t.deepEqual(payload, v1)
-    next(null, v2)
+    done(null, v2)
   }
 
-  function fn2 (request, reply, payload, next) {
+  function fn2 (request, reply, payload, done) {
     t.deepEqual(payload, v2)
-    next(null, v3)
+    done(null, v3)
   }
 
-  function fn3 (request, reply, payload, next) {
+  function fn3 (request, reply, payload, done) {
     t.deepEqual(payload, v3)
-    next(null, v4)
+    done(null, v4)
   }
 
   function done (err, request, reply, payload) {
@@ -318,14 +318,14 @@ test('onSendHookRunner - In case of error should skip to done', t => {
 
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
-  function fn1 (request, reply, payload, next) {
+  function fn1 (request, reply, payload, done) {
     t.deepEqual(payload, v1)
-    next(null, v2)
+    done(null, v2)
   }
 
-  function fn2 (request, reply, payload, next) {
+  function fn2 (request, reply, payload, done) {
     t.deepEqual(payload, v2)
-    next(new Error('kaboom'))
+    done(new Error('kaboom'))
   }
 
   function fn3 () {
@@ -417,9 +417,9 @@ test('onSendHookRunner - Be able to exit before its natural end', t => {
 
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
-  function fn1 (request, reply, payload, next) {
+  function fn1 (request, reply, payload, done) {
     t.deepEqual(payload, v1)
-    next(null, v2)
+    done(null, v2)
   }
 
   function fn2 (request, reply, payload) {