fastify 2.7.1 → 2.11.0

package/test/fastify-instance.test.js

@@ -3,8 +3,37 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const {
+  kOptions
+} = require('../lib/symbols')
 
 test('root fastify instance is an object', t => {
   t.plan(1)
   t.type(Fastify(), 'object')
 })
+
+test('fastify instance should contains ajv options', t => {
+  t.plan(1)
+  const fastify = Fastify({
+    ajv: {
+      customOptions: {
+        nullable: false
+      }
+    }
+  })
+  t.same(fastify[kOptions].ajv, {
+    customOptions: {
+      nullable: false
+    },
+    plugins: []
+  })
+})
+
+test('fastify instance get invalid ajv options', t => {
+  t.plan(1)
+  t.throw(() => Fastify({
+    ajv: {
+      customOptions: 8
+    }
+  }))
+})

package/test/helper.js

@@ -221,7 +221,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
     })
 
     if (loMethod === 'options') {
-      test(`OPTIONS returns 415 - should return 415 if Content-Type is not json or plain text`, t => {
+      test('OPTIONS returns 415 - should return 415 if Content-Type is not json or plain text', t => {
         t.plan(2)
         sget({
           method: upMethod,
@@ -328,7 +328,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(res.payload), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })
@@ -344,7 +344,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(body.toString()), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })
@@ -361,7 +361,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(res.payload), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })
@@ -378,7 +378,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(body.toString()), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })
@@ -395,7 +395,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(res.payload), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })
@@ -412,7 +412,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         t.strictDeepEqual(JSON.parse(body.toString()), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
-          message: `FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'`,
+          message: "FST_ERR_CTP_EMPTY_JSON_BODY: Body cannot be empty when content-type is set to 'application/json'",
           statusCode: 400
         })
       })

package/test/hooks-async.js

@@ -520,7 +520,7 @@ function asyncHookTest (t) {
 
       stream.on('data', line => {
         t.strictEqual(line.level, 40)
-        t.true(line.msg.startsWith(`Async function has too many arguments. Async hooks should not use the 'next' argument.`))
+        t.true(line.msg.startsWith("Async function has too many arguments. Async hooks should not use the 'next' argument."))
         t.true(/test(\\|\/)hooks-async\.js/.test(line.msg))
       })
 
@@ -528,7 +528,7 @@ function asyncHookTest (t) {
     })
 
     t.test('4 arguments', t => {
-      t.plan(6)
+      t.plan(9)
       const stream = split(JSON.parse)
       const fastify = Fastify({
         logger: { stream }
@@ -536,12 +536,13 @@ function asyncHookTest (t) {
 
       stream.on('data', line => {
         t.strictEqual(line.level, 40)
-        t.true(line.msg.startsWith(`Async function has too many arguments. Async hooks should not use the 'next' argument.`))
+        t.true(line.msg.startsWith("Async function has too many arguments. Async hooks should not use the 'next' argument."))
         t.true(/test(\\|\/)hooks-async\.js/.test(line.msg))
       })
 
       fastify.addHook('onSend', async (req, reply, payload, next) => {})
       fastify.addHook('preSerialization', async (req, reply, payload, next) => {})
+      fastify.addHook('onError', async (req, reply, error, next) => {})
     })
 
     t.end()

package/test/hooks.test.js

@@ -14,7 +14,7 @@ const symbols = require('../lib/symbols.js')
 const payload = { hello: 'world' }
 
 test('hooks', t => {
-  t.plan(37)
+  t.plan(38)
   const fastify = Fastify()
 
   try {
@@ -99,6 +99,9 @@ test('hooks', t => {
       t.is(reply.test, 'the reply has come')
       reply.code(200).send(payload)
     },
+    onResponse: function (req, reply, done) {
+      t.ok('onResponse inside hook')
+    },
     response: {
       200: {
         type: 'object'
@@ -485,7 +488,7 @@ test('onRoute hook should pass correct route with custom prefix', t => {
 })
 
 test('onRoute hook should pass correct route with custom options', t => {
-  t.plan(5)
+  t.plan(6)
   const fastify = Fastify()
   fastify.register((instance, opts, next) => {
     instance.addHook('onRoute', function (route) {
@@ -493,8 +496,15 @@ test('onRoute hook should pass correct route with custom options', t => {
       t.strictEqual(route.url, '/foo')
       t.strictEqual(route.logLevel, 'info')
       t.strictEqual(route.bodyLimit, 100)
+      t.type(route.logSerializers.test, 'function')
     })
-    instance.get('/foo', { logLevel: 'info', bodyLimit: 100 }, function (req, reply) {
+    instance.get('/foo', {
+      logLevel: 'info',
+      bodyLimit: 100,
+      logSerializers: {
+        test: value => value
+      }
+    }, function (req, reply) {
       reply.send()
     })
     next()
@@ -2581,16 +2591,24 @@ test('preSerialization hooks should support encapsulation', t => {
 })
 
 test('onRegister hook should be called / 1', t => {
-  t.plan(3)
+  t.plan(4)
   const fastify = Fastify()
 
+  const pluginOpts = { prefix: 'hello', custom: 'world' }
   fastify.register((instance, opts, next) => {
     next()
-  })
+  }, pluginOpts)
 
-  fastify.addHook('onRegister', instance => {
+  let first = true
+  fastify.addHook('onRegister', (instance, opts) => {
     // duck typing for the win!
     t.ok(instance.addHook)
+    if (first) {
+      // the first call of the onRegister is the main fastify instance, not the registered ones
+      first = false
+    } else {
+      t.deepEquals(opts, pluginOpts)
+    }
   })
 
   fastify.ready(err => {
@@ -2655,7 +2673,7 @@ test('onRegister hook should be called / 3', t => {
 })
 
 test('onRegister hook should be called / 4', t => {
-  t.plan(2)
+  t.plan(3)
   const fastify = Fastify()
 
   function plugin (instance, opts, next) {
@@ -2665,9 +2683,10 @@ test('onRegister hook should be called / 4', t => {
 
   fastify.register(plugin)
 
-  fastify.addHook('onRegister', instance => {
+  fastify.addHook('onRegister', (instance, opts) => {
     // duck typing for the win!
     t.ok(instance.addHook)
+    t.deepEquals(opts, {})
   })
 
   fastify.ready(err => {

package/test/input-validation.test.js

@@ -3,6 +3,7 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const ajvMergePatch = require('ajv-merge-patch')
 
 test('case insensitive header validation', t => {
   t.plan(2)
@@ -67,3 +68,128 @@ test('not evaluate json-schema $schema keyword', t => {
     t.equal(res.payload, 'world')
   })
 })
+
+test('Should handle $merge keywords in body', t => {
+  t.plan(5)
+  const fastify = Fastify({
+    ajv: {
+      plugins: [
+        ajvMergePatch
+      ]
+    }
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {
+      body: {
+        $merge: {
+          source: {
+            type: 'object',
+            properties: {
+              q: {
+                type: 'string'
+              }
+            }
+          },
+          with: {
+            required: ['q']
+          }
+        }
+      }
+    },
+    handler (req, reply) {
+      reply.send({ ok: 1 })
+    }
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'POST',
+      url: '/'
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      body: {
+        q: 'foo'
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+    })
+  })
+})
+
+test('Should handle $patch keywords in body', t => {
+  t.plan(5)
+  const fastify = Fastify({
+    ajv: {
+      plugins: [
+        ajvMergePatch
+      ]
+    }
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {
+      body: {
+        $patch: {
+          source: {
+            type: 'object',
+            properties: {
+              q: {
+                type: 'string'
+              }
+            }
+          },
+          with: [
+            {
+              op: 'add',
+              path: '/properties/q',
+              value: { type: 'number' }
+            }
+          ]
+        }
+      }
+    },
+    handler (req, reply) {
+      reply.send({ ok: 1 })
+    }
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      body: {
+        q: 'foo'
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      body: {
+        q: 10
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+    })
+  })
+})

package/test/internals/errors.test.js

@@ -78,7 +78,7 @@ test('Should throw when error code has no message', t => {
   try {
     createError('code')
   } catch (err) {
-    t.equal(err.message, `Fastify error message must not be empty`)
+    t.equal(err.message, 'Fastify error message must not be empty')
   }
 })
 
@@ -94,3 +94,11 @@ test('Create error with different base', t => {
   t.equal(err.statusCode, 500)
   t.ok(err.stack)
 })
+
+test('Error has appropriate string tag', t => {
+  t.plan(1)
+  const NewError = createError('CODE', 'foo')
+  const err = new NewError()
+  const str = Object.prototype.toString.call(err)
+  t.equal(str, '[object Error]')
+})

package/test/internals/initialConfig.test.js

@@ -25,6 +25,7 @@ test('without options passed to Fastify, initialConfig should expose default val
     ignoreTrailingSlash: false,
     maxParamLength: 100,
     onProtoPoisoning: 'error',
+    onConstructorPoisoning: 'ignore',
     pluginTimeout: 10000,
     requestIdHeader: 'request-id',
     requestIdLogLabel: 'reqId'
@@ -55,7 +56,7 @@ test('Fastify.initialConfig should expose all options', t => {
       }
     },
     deriveVersion: (req, ctx) => {
-      return req.headers['accept']
+      return req.headers.accept
     }
   }
 
@@ -153,7 +154,7 @@ test('Return an error if options do not match the validation schema', t => {
   } catch (error) {
     t.type(error, Error)
     t.equal(error.name, 'FastifyError [FST_ERR_INIT_OPTS_INVALID]')
-    t.equal(error.message, `FST_ERR_INIT_OPTS_INVALID: Invalid initialization options: '["should be boolean"]'`)
+    t.equal(error.message, 'FST_ERR_INIT_OPTS_INVALID: Invalid initialization options: \'["should be boolean"]\'')
     t.equal(error.code, 'FST_ERR_INIT_OPTS_INVALID')
     t.ok(error.stack)
     t.pass()
@@ -228,6 +229,7 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       ignoreTrailingSlash: true,
       maxParamLength: 100,
       onProtoPoisoning: 'error',
+      onConstructorPoisoning: 'ignore',
       pluginTimeout: 10000,
       requestIdHeader: 'request-id',
       requestIdLogLabel: 'reqId'

package/test/internals/plugin.test.js

@@ -7,7 +7,7 @@ const pluginUtilsPublic = require('../../lib/pluginUtils.js')
 const pluginUtils = require('../../lib/pluginUtils')[Symbol.for('internals')]
 const symbols = require('../../lib/symbols.js')
 
-test(`shouldSkipOverride should check the 'skip-override' symbol`, t => {
+test("shouldSkipOverride should check the 'skip-override' symbol", t => {
   t.plan(2)
 
   yes[Symbol.for('skip-override')] = true
@@ -19,7 +19,7 @@ test(`shouldSkipOverride should check the 'skip-override' symbol`, t => {
   function no () {}
 })
 
-test(`getMeta should return the object stored with the 'plugin-meta' symbol`, t => {
+test("getMeta should return the object stored with the 'plugin-meta' symbol", t => {
   t.plan(1)
 
   const meta = { hello: 'world' }
@@ -76,7 +76,7 @@ test('checkDecorators should check if the given decorator is present in the inst
     pluginUtils.checkDecorators.call(context, fn)
     t.fail('should throw')
   } catch (err) {
-    t.is(err.message, `The decorator 'plugin' is not present in Request`)
+    t.is(err.message, "The decorator 'plugin' is not present in Request")
   }
 
   function fn () {}
@@ -117,7 +117,7 @@ test('checkDependencies should check if the given dependency is present in the i
     pluginUtils.checkDependencies.call(context, fn)
     t.fail('should throw')
   } catch (err) {
-    t.is(err.message, `The dependency 'plugin' of plugin 'test-plugin' is not registered`)
+    t.is(err.message, "The dependency 'plugin' of plugin 'test-plugin' is not registered")
   }
 
   function fn () {}

package/test/internals/reply.test.js

@@ -6,6 +6,7 @@ const sget = require('simple-get').concat
 const http = require('http')
 const NotFound = require('http-errors').NotFound
 const Reply = require('../../lib/reply')
+const { Writable } = require('readable-stream')
 const {
   kReplyErrorHandlerCalled,
   kReplyHeaders,
@@ -36,14 +37,32 @@ test('Once called, Reply should return an object with methods', t => {
 
 test('reply.send throw with circular JSON', t => {
   t.plan(1)
-  const request = {}
-  const response = { setHeader: () => {} }
-  const reply = new Reply(request, response, null)
+  const response = {
+    setHeader: () => {},
+    hasHeader: () => false,
+    getHeader: () => undefined,
+    writeHead: () => {},
+    end: () => {}
+  }
+  const reply = new Reply(response, { onSend: [] }, null)
   t.throws(() => {
     var obj = {}
     obj.obj = obj
     reply.send(JSON.stringify(obj))
-  })
+  }, 'Converting circular structure to JSON')
+})
+
+test('reply.send returns itself', t => {
+  t.plan(1)
+  const response = {
+    setHeader: () => {},
+    hasHeader: () => false,
+    getHeader: () => undefined,
+    writeHead: () => {},
+    end: () => {}
+  }
+  const reply = new Reply(response, { onSend: [] }, null)
+  t.equal(reply.send('hello'), reply)
 })
 
 test('reply.serializer should set a custom serializer', t => {
@@ -262,7 +281,7 @@ test('within an instance', t => {
       http.get(url, (response) => {
         t.strictEqual(response.headers['x-onsend'], 'yes')
         t.strictEqual(response.headers['content-length'], '0')
-        t.strictEqual(response.headers['location'], '/')
+        t.strictEqual(response.headers.location, '/')
       })
     })
 
@@ -419,7 +438,7 @@ test('stream using reply.res.writeHead should return customize headers', t => {
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
       t.error(err)
-      t.strictEqual(response.headers['location'], '/')
+      t.strictEqual(response.headers.location, '/')
       t.strictEqual(response.headers['Content-Type'], undefined)
       t.deepEqual(body, buf)
     })
@@ -905,6 +924,23 @@ test('.status() is an alias for .code()', t => {
   })
 })
 
+test('.statusCode is getter and setter', t => {
+  t.plan(4)
+  const fastify = require('../..')()
+
+  fastify.get('/', function (req, reply) {
+    t.ok(reply.statusCode, 200, 'default status value')
+    reply.statusCode = 418
+    t.ok(reply.statusCode, 418)
+    reply.send()
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.is(res.statusCode, 418)
+  })
+})
+
 test('reply.header setting multiple cookies as multiple Set-Cookie headers', t => {
   t.plan(7)
 
@@ -1252,3 +1288,39 @@ test('reply should not call the custom serializer for errors and not found', t =
     t.strictEqual(res.statusCode, 404)
   })
 })
+
+test('reply.then', t => {
+  t.plan(2)
+
+  function context () {}
+  function request () {}
+
+  t.test('without an error', t => {
+    t.plan(1)
+
+    const response = new Writable()
+    const reply = new Reply(response, context, request)
+
+    reply.then(function () {
+      t.pass('fullfilled called')
+    })
+
+    response.destroy()
+  })
+
+  t.test('with an error', t => {
+    t.plan(1)
+
+    const response = new Writable()
+    const reply = new Reply(response, context, request)
+    const _err = new Error('kaboom')
+
+    reply.then(function () {
+      t.fail('fullfilled called')
+    }, function (err) {
+      t.equal(err, _err)
+    })
+
+    response.destroy(_err)
+  })
+})

package/test/internals/schemas.test.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const test = require('tap').test
+const { Schemas } = require('../../lib/schemas')
+
+test('Should not change resolved schema', t => {
+  t.plan(4)
+
+  const schemas = new Schemas()
+  schemas.add({
+    $id: 'A',
+    field: 'value'
+  })
+  const schema = {
+    a: 'A#'
+  }
+  const resolvedSchema = schemas.resolveRefs(schema)
+
+  t.same(resolvedSchema.a, {
+    field: 'value'
+  })
+  t.same(resolvedSchema.$id, undefined)
+
+  schemas.getJsonSchemas()
+
+  t.same(resolvedSchema.a, {
+    field: 'value'
+  })
+  t.same(resolvedSchema.$id, undefined)
+})

package/test/internals/validation.test.js

@@ -226,3 +226,21 @@ test('build schema - headers are not lowercased in case of custom object', t =>
     return () => {}
   }, new Schemas())
 })
+
+test('build schema - uppercased headers are not included', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: {
+          'Content-Type': { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.build(opts, schema => {
+    t.notOk('Content-Type' in schema.properties, 'uppercase does not exist')
+    return () => {}
+  }, new Schemas())
+})

package/test/listen.test.js

@@ -190,7 +190,7 @@ if (os.platform() !== 'win32') {
     const fastify = Fastify()
     t.tearDown(fastify.close.bind(fastify))
 
-    const sockFile = path.join(os.tmpdir(), 'server.sock')
+    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').substr(2, 8)}-server.sock`)
     try {
       fs.unlinkSync(sockFile)
     } catch (e) { }