fastify 2.4.1 → 2.7.1

package/test/fluent-schema.js

@@ -120,6 +120,60 @@ function fluentSchemaTest (t) {
 
     fastify.ready(t.error)
   })
+
+  test('Should call valueOf internally', t => {
+    t.plan(1)
+
+    const fastify = new Fastify()
+
+    const addressSchema = S.object()
+      .id('#address')
+      .prop('line1').required()
+      .prop('line2')
+      .prop('country').required()
+      .prop('city').required()
+      .prop('zipcode').required()
+
+    const commonSchemas = S.object()
+      .id('https://fastify/demo')
+      .definition('addressSchema', addressSchema)
+
+    fastify.addSchema(commonSchemas)
+
+    fastify.route({
+      method: 'POST',
+      url: '/query',
+      handler: () => {},
+      schema: {
+        query: S.object().prop('hello', S.string()).required(),
+        body: S.object().prop('hello', S.string()).required(),
+        params: S.object().prop('hello', S.string()).required(),
+        headers: S.object().prop('hello', S.string()).required(),
+        response: {
+          200: S.object().prop('hello', S.string()).required(),
+          201: S.object().prop('hello', S.string()).required()
+        }
+      }
+    })
+
+    fastify.route({
+      method: 'POST',
+      url: '/querystring',
+      handler: () => {},
+      schema: {
+        querystring: S.object().prop('hello', S.string()).required(),
+        body: S.object().prop('hello', S.string()).required(),
+        params: S.object().prop('hello', S.string()).required(),
+        headers: S.object().prop('hello', S.string()).required(),
+        response: {
+          200: S.object().prop('hello', S.string()).required(),
+          201: S.object().prop('hello', S.string()).required()
+        }
+      }
+    })
+
+    fastify.ready(t.error)
+  })
 }
 
 module.exports = fluentSchemaTest

package/test/hooks-async.js

@@ -4,7 +4,8 @@ const split = require('split2')
 const sget = require('simple-get').concat
 const Fastify = require('..')
 const fs = require('fs')
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const { promisify } = require('util')
+const sleep = promisify(setTimeout)
 
 function asyncHookTest (t) {
   const test = t.test
@@ -231,6 +232,53 @@ function asyncHookTest (t) {
     })
   })
 
+  test('preValidation hooks should be able to block a request with async onSend', t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.addHook('preValidation', async (req, reply) => {
+      reply.send('hello')
+    })
+
+    fastify.addHook('onSend', async (req, reply, payload) => {
+      await sleep(10)
+      t.equal(payload, 'hello')
+    })
+
+    fastify.addHook('preHandler', async (request, reply) => {
+      t.fail('we should not be here')
+    })
+
+    fastify.addHook('onResponse', async (request, reply) => {
+      t.ok('called')
+    })
+
+    fastify.post('/', {
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            hello: {
+              type: 'string'
+            }
+          },
+          required: ['hello']
+        }
+      }
+    }, function (request, reply) {
+      t.fail('we should not be here')
+    })
+
+    fastify.inject({
+      url: '/',
+      method: 'POST'
+    }, (err, res) => {
+      t.error(err)
+      t.is(res.statusCode, 200)
+      t.is(res.payload, 'hello')
+    })
+  })
+
   test('preSerialization hooks should be able to modify the payload', t => {
     t.plan(3)
     const fastify = Fastify()
@@ -339,6 +387,37 @@ function asyncHookTest (t) {
     })
   })
 
+  test('preHandler hooks should be able to block a request (last hook) with a delay in onSend', t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.addHook('preHandler', async (req, reply) => {
+      reply.send('hello')
+    })
+
+    fastify.addHook('onSend', async (req, reply, payload) => {
+      await sleep(10)
+      t.equal(payload, 'hello')
+    })
+
+    fastify.addHook('onResponse', async (request, reply) => {
+      t.ok('called')
+    })
+
+    fastify.get('/', function (request, reply) {
+      t.fail('we should not be here')
+    })
+
+    fastify.inject({
+      url: '/',
+      method: 'GET'
+    }, (err, res) => {
+      t.error(err)
+      t.is(res.statusCode, 200)
+      t.is(res.payload, 'hello')
+    })
+  })
+
   test('onRequest respond with a stream', t => {
     t.plan(4)
     const fastify = Fastify()

package/test/hooks.test.js

@@ -1935,7 +1935,7 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
     t.deepEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
-      'host': 'localhost:80',
+      host: 'localhost:80',
       'user-agent': 'lightMyRequest',
       'x-custom': 'hello'
     })
@@ -1949,7 +1949,7 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
     t.deepEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
-      'host': 'localhost:80',
+      host: 'localhost:80',
       'user-agent': 'lightMyRequest',
       'x-custom': 'hello'
     })
@@ -1963,7 +1963,7 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
     t.deepEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
-      'host': 'localhost:80',
+      host: 'localhost:80',
       'user-agent': 'lightMyRequest',
       'x-custom': 'hello'
     })
@@ -1977,7 +1977,7 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
     t.deepEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
-      'host': 'localhost:80',
+      host: 'localhost:80',
       'user-agent': 'lightMyRequest',
       'x-custom': 'hello'
     })

package/test/http2/closing.js

@@ -1,48 +1,101 @@
 'use strict'
 
 const t = require('tap')
-const test = t.test
 const Fastify = require('../..')
 const http2 = require('http2')
 const semver = require('semver')
 
-let fastify
-try {
-  fastify = Fastify({
-    http2: true
-  })
-  t.pass('http2 successfully loaded')
-} catch (e) {
-  t.fail('http2 loading failed', e)
-}
-
-fastify.listen(0, err => {
-  t.error(err)
-  fastify.server.unref()
-
-  // Skipped because there is likely a bug on Node 8.
-  test('http/2 request while fastify closing', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
-    const url = `http://127.0.0.1:${fastify.server.address().port}`
-    const session = http2.connect(url, function () {
-      this.request({
-        ':method': 'GET',
-        ':path': '/'
-      }).on('response', headers => {
-        t.strictEqual(headers[':status'], 503)
-        t.end()
-        this.destroy()
-      }).on('error', () => {
+t.test('http/2 request while fastify closing', t => {
+  let fastify
+  try {
+    fastify = Fastify({
+      http2: true
+    })
+    t.pass('http2 successfully loaded')
+  } catch (e) {
+    t.fail('http2 loading failed', e)
+  }
+
+  fastify.get('/', () => Promise.resolve({}))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    // Skipped because there is likely a bug on Node 8.
+    t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
+      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const session = http2.connect(url, function () {
+        this.request({
+          ':method': 'GET',
+          ':path': '/'
+        }).on('response', headers => {
+          t.strictEqual(headers[':status'], 503)
+          t.end()
+          this.destroy()
+        }).on('error', () => {
+          // Nothing to do here,
+          // we are not interested in this error that might
+          // happen or not
+        })
+        fastify.close()
+      })
+      session.on('error', () => {
         // Nothing to do here,
         // we are not interested in this error that might
         // happen or not
+        t.end()
       })
-      fastify.close()
     })
-    session.on('error', () => {
-      // Nothing to do here,
-      // we are not interested in this error that might
-      // happen or not
-      t.end()
+
+    t.end()
+  })
+})
+
+t.test('http/2 request while fastify closing - return503OnClosing: false', t => {
+  let fastify
+  try {
+    fastify = Fastify({
+      http2: true,
+      return503OnClosing: false
     })
+    t.pass('http2 successfully loaded')
+  } catch (e) {
+    t.fail('http2 loading failed', e)
+  }
+
+  fastify.get('/', () => Promise.resolve({}))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    // Skipped because there is likely a bug on Node 8.
+    t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
+      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const session = http2.connect(url, function () {
+        this.request({
+          ':method': 'GET',
+          ':path': '/'
+        }).on('response', headers => {
+          t.strictEqual(headers[':status'], 200)
+          t.end()
+          this.destroy()
+        }).on('error', () => {
+          // Nothing to do here,
+          // we are not interested in this error that might
+          // happen or not
+        })
+        fastify.close()
+      })
+      session.on('error', () => {
+        // Nothing to do here,
+        // we are not interested in this error that might
+        // happen or not
+        t.end()
+      })
+    })
+
+    t.end()
   })
 })

package/test/input-validation.test.js

@@ -27,7 +27,7 @@ test('case insensitive header validation', t => {
     method: 'GET',
     url: '/',
     headers: {
-      'FooBar': 'Baz'
+      FooBar: 'Baz'
     }
   }, (err, res) => {
     t.error(err)

package/test/internals/decorator.test.js

@@ -1,5 +1,7 @@
 'use strict'
 
+/* eslint no-prototype-builtins: 0 */
+
 const t = require('tap')
 const test = t.test
 const decorator = require('../../lib/decorate')

package/test/internals/initialConfig.test.js

@@ -59,7 +59,7 @@ test('Fastify.initialConfig should expose all options', t => {
     }
   }
 
-  let options = {
+  const options = {
     http2: true,
     https: {
       key: fs.readFileSync(path.join(__dirname, '..', 'https', 'fastify.key')),

package/test/internals/reply.test.js

@@ -14,7 +14,7 @@ const {
 } = require('../../lib/symbols')
 
 test('Once called, Reply should return an object with methods', t => {
-  t.plan(12)
+  t.plan(13)
   const response = { res: 'res' }
   function context () {}
   function request () {}
@@ -27,6 +27,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.is(typeof reply.status, 'function')
   t.is(typeof reply.header, 'function')
   t.is(typeof reply.serialize, 'function')
+  t.is(typeof reply.getResponseTime, 'function')
   t.is(typeof reply[kReplyHeaders], 'object')
   t.strictEqual(reply.res, response)
   t.strictEqual(reply.context, context)
@@ -977,3 +978,277 @@ test('should throw error when attempting to set reply.sent more than once', t =>
     t.pass()
   })
 })
+
+test('reply.getResponseTime() 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 context = {}
+  const reply = new Reply(response, context, 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 = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  fastify.addHook('onResponse', (req, reply) => {
+    t.true(reply.getResponseTime() > 0)
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply should use the custom serializer', t => {
+  t.plan(4)
+  const fastify = require('../..')()
+  fastify.setReplySerializer((payload, statusCode) => {
+    t.deepEqual(payload, { foo: 'bar' })
+    t.equal(statusCode, 200)
+    payload.foo = 'bar bar'
+    return JSON.stringify(payload)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ foo: 'bar' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"foo":"bar bar"}')
+  })
+})
+
+test('reply should use the right serializer in encapsulated context', t => {
+  t.plan(9)
+
+  const fastify = require('../..')()
+  fastify.setReplySerializer((payload) => {
+    t.deepEqual(payload, { foo: 'bar' })
+    payload.foo = 'bar bar'
+    return JSON.stringify(payload)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => { reply.send({ foo: 'bar' }) }
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.route({
+      method: 'GET',
+      url: '/sub',
+      handler: (req, reply) => { reply.send({ john: 'doo' }) }
+    })
+    instance.setReplySerializer((payload) => {
+      t.deepEqual(payload, { john: 'doo' })
+      payload.john = 'too too'
+      return JSON.stringify(payload)
+    })
+    next()
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.route({
+      method: 'GET',
+      url: '/sub',
+      handler: (req, reply) => { reply.send({ sweet: 'potato' }) }
+    })
+    instance.setReplySerializer((payload) => {
+      t.deepEqual(payload, { sweet: 'potato' })
+      payload.sweet = 'potato potato'
+      return JSON.stringify(payload)
+    })
+    next()
+  }, { prefix: 'sub' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"foo":"bar bar"}')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/sub'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"john":"too too"}')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/sub/sub'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"sweet":"potato potato"}')
+  })
+})
+
+test('reply should use the right serializer in deep encapsulated context', t => {
+  t.plan(8)
+
+  const fastify = require('../..')()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => { reply.send({ foo: 'bar' }) }
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.route({
+      method: 'GET',
+      url: '/sub',
+      handler: (req, reply) => { reply.send({ john: 'doo' }) }
+    })
+    instance.setReplySerializer((payload) => {
+      t.deepEqual(payload, { john: 'doo' })
+      payload.john = 'too too'
+      return JSON.stringify(payload)
+    })
+
+    instance.register(function (subInstance, opts, next) {
+      subInstance.route({
+        method: 'GET',
+        url: '/deep',
+        handler: (req, reply) => { reply.send({ john: 'deep' }) }
+      })
+      subInstance.setReplySerializer((payload) => {
+        t.deepEqual(payload, { john: 'deep' })
+        payload.john = 'deep deep'
+        return JSON.stringify(payload)
+      })
+      next()
+    })
+    next()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"foo":"bar"}')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/sub'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"john":"too too"}')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/deep'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"john":"deep deep"}')
+  })
+})
+
+test('reply should use the route serializer', t => {
+  t.plan(3)
+
+  const fastify = require('../..')()
+  fastify.setReplySerializer(() => {
+    t.fail('this serializer should not be executed')
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply
+        .serializer((payload) => {
+          t.deepEqual(payload, { john: 'doo' })
+          payload.john = 'too too'
+          return JSON.stringify(payload)
+        })
+        .send({ john: 'doo' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.payload, '{"john":"too too"}')
+  })
+})
+
+test('cannot set the replySerializer when the server is running', t => {
+  t.plan(2)
+
+  const fastify = require('../..')()
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(err => {
+    t.error(err)
+    try {
+      fastify.setReplySerializer(() => {})
+      t.fail('this serializer should not be setup')
+    } catch (e) {
+      t.is(e.message, 'Cannot call "setReplySerializer" when fastify instance is already started!')
+    }
+  })
+})
+
+test('reply should not call the custom serializer for errors and not found', t => {
+  t.plan(9)
+
+  const fastify = require('../..')()
+  fastify.setReplySerializer((payload, statusCode) => {
+    t.deepEqual(payload, { foo: 'bar' })
+    t.equal(statusCode, 200)
+    return JSON.stringify(payload)
+  })
+
+  fastify.get('/', (req, reply) => { reply.send({ foo: 'bar' }) })
+  fastify.get('/err', (req, reply) => { reply.send(new Error('an error')) })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 200)
+    t.strictEqual(res.payload, '{"foo":"bar"}')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/err'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 500)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/not-existing'
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 404)
+  })
+})