fastify 4.6.0 → 4.7.0

package/test/handler-context.test.js

@@ -1,19 +1,9 @@
 'use strict'
-
-const http = require('http')
 const test = require('tap').test
+const { kRouteContext } = require('../lib/symbols')
 const fastify = require('../')
 
-function getUrl (app) {
-  const { address, port } = app.server.address()
-  if (address === '::1') {
-    return `http://[${address}]:${port}`
-  } else {
-    return `http://${address}:${port}`
-  }
-}
-
-test('handlers receive correct `this` context', (t) => {
+test('handlers receive correct `this` context', async (t) => {
   t.plan(4)
 
   // simulate plugin that uses fastify-plugin
@@ -32,32 +22,24 @@ test('handlers receive correct `this` context', (t) => {
     reply.send()
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    instance.server.unref()
-    if (err) t.threw(err)
-    t.ok(instance.foo)
-    t.equal(instance.foo, 'foo')
+  await instance.inject('/')
 
-    http.get(getUrl(instance), () => {}).on('error', t.threw)
-  })
+  t.ok(instance.foo)
+  t.equal(instance.foo, 'foo')
 })
 
-test('handlers have access to the internal context', (t) => {
+test('handlers have access to the internal context', async (t) => {
   t.plan(5)
 
   const instance = fastify()
   instance.get('/', { config: { foo: 'bar' } }, function (req, reply) {
-    t.ok(reply.context)
-    t.ok(reply.context.config)
-    t.type(reply.context.config, Object)
-    t.ok(reply.context.config.foo)
-    t.equal(reply.context.config.foo, 'bar')
+    t.ok(reply[kRouteContext])
+    t.ok(reply[kRouteContext].config)
+    t.type(reply[kRouteContext].config, Object)
+    t.ok(reply[kRouteContext].config.foo)
+    t.equal(reply[kRouteContext].config.foo, 'bar')
     reply.send()
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    instance.server.unref()
-    if (err) t.threw(err)
-    http.get(getUrl(instance), () => {}).on('error', t.threw)
-  })
+  await instance.inject('/')
 })

package/test/internals/contentTypeParser.test.js

@@ -4,7 +4,7 @@ const t = require('tap')
 const proxyquire = require('proxyquire')
 const test = t.test
 const { Readable } = require('stream')
-const { kTestInternals } = require('../../lib/symbols')
+const { kTestInternals, kRouteContext } = require('../../lib/symbols')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
@@ -50,7 +50,7 @@ test('rawBody function', t => {
   internals.rawBody(
     request,
     reply,
-    reply.context._parserOptions,
+    reply[kRouteContext]._parserOptions,
     parser,
     done
   )
@@ -103,7 +103,7 @@ test('Should support Webpack and faux modules', t => {
   internals.rawBody(
     request,
     reply,
-    reply.context._parserOptions,
+    reply[kRouteContext]._parserOptions,
     parser,
     done
   )

package/test/internals/handleRequest.test.js

@@ -5,6 +5,7 @@ const handleRequest = require('../../lib/handleRequest')
 const internals = require('../../lib/handleRequest')[Symbol.for('internals')]
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
+const { kRouteContext } = require('../../lib/symbols')
 const buildSchema = require('../../lib/validation').compileSchemasForValidation
 const sget = require('simple-get').concat
 
@@ -69,7 +70,7 @@ test('handler function - invalid schema', t => {
   buildSchema(context, schemaValidator)
   const request = {
     body: { hello: 'world' },
-    context
+    [kRouteContext]: context
   }
   internals.handler(request, new Reply(res, request))
 })
@@ -96,7 +97,7 @@ test('handler function - reply', t => {
     onError: []
   }
   buildSchema(context, schemaValidator)
-  internals.handler({}, new Reply(res, { context }))
+  internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))
 })
 
 test('handler function - preValidationCallback with finished response', t => {
@@ -121,7 +122,7 @@ test('handler function - preValidationCallback with finished response', t => {
     onError: []
   }
   buildSchema(context, schemaValidator)
-  internals.handler({}, new Reply(res, { context }))
+  internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))
 })
 
 test('request should be defined in onSend Hook on post request with content type application/json', t => {

package/test/internals/reply-serialize.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
-const { kReplySerializeWeakMap } = require('../../lib/symbols')
+const { kReplySerializeWeakMap, kRouteContext } = require('../../lib/symbols')
 const Fastify = require('../../fastify')
 
 function getDefaultSchema () {
@@ -172,9 +172,9 @@ test('Reply#compileSerializationSchema', t => {
     fastify.get('/', (req, reply) => {
       const input = { hello: 'world' }
 
-      t.equal(reply.context[kReplySerializeWeakMap], null)
+      t.equal(reply[kRouteContext][kReplySerializeWeakMap], null)
       t.equal(reply.compileSerializationSchema(getDefaultSchema())(input), JSON.stringify(input))
-      t.type(reply.context[kReplySerializeWeakMap], WeakMap)
+      t.type(reply[kRouteContext][kReplySerializeWeakMap], WeakMap)
       t.equal(reply.compileSerializationSchema(getDefaultSchema())(input), JSON.stringify(input))
 
       reply.send({ hello: 'world' })
@@ -231,7 +231,7 @@ test('Reply#getSerializationFunction', t => {
         (req, reply) => {
           const { id } = req.params
 
-          if (parseInt(id) === 1) {
+          if (Number(id) === 1) {
             const serialize4xx = reply.getSerializationFunction('4xx')
             const serialize201 = reply.getSerializationFunction(201)
             const serializeUndefined = reply.getSerializationFunction(undefined)
@@ -308,7 +308,7 @@ test('Reply#getSerializationFunction', t => {
         (req, reply) => {
           const { id } = req.params
 
-          if (parseInt(id) === 1) {
+          if (Number(id) === 1) {
             const serialize = reply.compileSerializationSchema(schemaObj)
 
             t.type(serialize, Function)
@@ -352,9 +352,9 @@ test('Reply#getSerializationFunction', t => {
 
     fastify.get('/', (req, reply) => {
       t.notOk(reply.getSerializationFunction(getDefaultSchema()))
-      t.equal(reply.context[kReplySerializeWeakMap], null)
+      t.equal(reply[kRouteContext][kReplySerializeWeakMap], null)
       t.notOk(reply.getSerializationFunction('200'))
-      t.equal(reply.context[kReplySerializeWeakMap], null)
+      t.equal(reply[kRouteContext][kReplySerializeWeakMap], null)
 
       reply.send({ hello: 'world' })
     })
@@ -568,9 +568,9 @@ test('Reply#serializeInput', t => {
 
     fastify.get('/', (req, reply) => {
       const input = { hello: 'world' }
-      t.equal(reply.context[kReplySerializeWeakMap], null)
+      t.equal(reply[kRouteContext][kReplySerializeWeakMap], null)
       t.equal(reply.serializeInput(input, getDefaultSchema()), JSON.stringify(input))
-      t.type(reply.context[kReplySerializeWeakMap], WeakMap)
+      t.type(reply[kRouteContext][kReplySerializeWeakMap], WeakMap)
 
       reply.send({ hello: 'world' })
     })

package/test/internals/reply.test.js

@@ -12,7 +12,8 @@ const {
   kReplyHeaders,
   kReplySerializer,
   kReplyIsError,
-  kReplySerializerDefault
+  kReplySerializerDefault,
+  kRouteContext
 } = require('../../lib/symbols')
 const fs = require('fs')
 const path = require('path')
@@ -34,7 +35,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.plan(13)
   const response = { res: 'res' }
   const context = {}
-  const request = { context }
+  const request = { [kRouteContext]: context }
   const reply = new Reply(response, request)
   t.equal(typeof reply, 'object')
   t.equal(typeof reply[kReplyIsError], 'boolean')
@@ -47,7 +48,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.equal(typeof reply.getResponseTime, 'function')
   t.equal(typeof reply[kReplyHeaders], 'object')
   t.same(reply.raw, response)
-  t.equal(reply.context, context)
+  t.equal(reply[kRouteContext], context)
   t.equal(reply.request, request)
 })
 
@@ -76,7 +77,7 @@ test('reply.send will logStream error and destroy the stream', t => {
     warn: () => {}
   }
 
-  const reply = new Reply(response, { context: { onSend: null } }, log)
+  const reply = new Reply(response, { [kRouteContext]: { onSend: null } }, log)
   reply.send(payload)
   payload.destroy(new Error('stream error'))
 
@@ -93,7 +94,7 @@ test('reply.send throw with circular JSON', t => {
     write: () => {},
     end: () => {}
   }
-  const reply = new Reply(response, { context: { onSend: [] } })
+  const reply = new Reply(response, { [kRouteContext]: { onSend: [] } })
   t.throws(() => {
     const obj = {}
     obj.obj = obj
@@ -111,7 +112,7 @@ test('reply.send returns itself', t => {
     write: () => {},
     end: () => {}
   }
-  const reply = new Reply(response, { context: { onSend: [] } })
+  const reply = new Reply(response, { [kRouteContext]: { onSend: [] } })
   t.equal(reply.send('hello'), reply)
 })
 
@@ -152,7 +153,7 @@ test('reply.serialize should serialize payload', t => {
   t.plan(1)
   const response = { statusCode: 200 }
   const context = {}
-  const reply = new Reply(response, { context })
+  const reply = new Reply(response, { [kRouteContext]: context })
   t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
 })
 
@@ -161,7 +162,7 @@ test('reply.serialize should serialize payload with a custom serializer', t => {
   let customSerializerCalled = false
   const response = { statusCode: 200 }
   const context = {}
-  const reply = new Reply(response, { context })
+  const reply = new Reply(response, { [kRouteContext]: context })
   reply.serializer((x) => (customSerializerCalled = true) && JSON.stringify(x))
   t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
   t.equal(customSerializerCalled, true, 'custom serializer not called')
@@ -172,7 +173,7 @@ test('reply.serialize should serialize payload with a context default serializer
   let customSerializerCalled = false
   const response = { statusCode: 200 }
   const context = { [kReplySerializerDefault]: (x) => (customSerializerCalled = true) && JSON.stringify(x) }
-  const reply = new Reply(response, { context })
+  const reply = new Reply(response, { [kRouteContext]: context })
   t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
   t.equal(customSerializerCalled, true, 'custom serializer not called')
 })

package/test/internals/request-validate.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('tap')
 const Ajv = require('ajv')
-const { kRequestValidateWeakMap } = require('../../lib/symbols')
+const { kRequestValidateWeakMap, kRouteContext } = require('../../lib/symbols')
 const Fastify = require('../../fastify')
 
 const defaultSchema = {
@@ -36,7 +36,7 @@ const requestSchema = {
 }
 
 test('#compileValidationSchema', subtest => {
-  subtest.plan(5)
+  subtest.plan(7)
 
   subtest.test('Should return a function - Route without schema', async t => {
     const fastify = Fastify()
@@ -59,6 +59,49 @@ test('#compileValidationSchema', subtest => {
     })
   })
 
+  subtest.test('Validate function errors property should be null after validation when input is valid', async t => {
+    const fastify = Fastify()
+
+    t.plan(3)
+
+    fastify.get('/', (req, reply) => {
+      const validate = req.compileValidationSchema(defaultSchema)
+
+      t.ok(validate({ hello: 'world' }))
+      t.ok(Object.prototype.hasOwnProperty.call(validate, 'errors'))
+      t.equal(validate.errors, null)
+
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.inject({
+      path: '/',
+      method: 'GET'
+    })
+  })
+
+  subtest.test('Validate function errors property should be an array of errors after validation when input is valid', async t => {
+    const fastify = Fastify()
+
+    t.plan(4)
+
+    fastify.get('/', (req, reply) => {
+      const validate = req.compileValidationSchema(defaultSchema)
+
+      t.notOk(validate({ world: 'foo' }))
+      t.ok(Object.prototype.hasOwnProperty.call(validate, 'errors'))
+      t.ok(Array.isArray(validate.errors))
+      t.ok(validate.errors.length > 0)
+
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.inject({
+      path: '/',
+      method: 'GET'
+    })
+  })
+
   subtest.test(
     'Should reuse the validate fn across multiple invocations - Route without schema',
     async t => {
@@ -188,11 +231,11 @@ test('#compileValidationSchema', subtest => {
       t.plan(5)
 
       fastify.get('/', (req, reply) => {
-        t.equal(req.context[kRequestValidateWeakMap], null)
+        t.equal(req[kRouteContext][kRequestValidateWeakMap], null)
         t.type(req.compileValidationSchema(defaultSchema), Function)
-        t.type(req.context[kRequestValidateWeakMap], WeakMap)
+        t.type(req[kRouteContext][kRequestValidateWeakMap], WeakMap)
         t.type(req.compileValidationSchema(Object.assign({}, defaultSchema)), Function)
-        t.type(req.context[kRequestValidateWeakMap], WeakMap)
+        t.type(req[kRouteContext][kRequestValidateWeakMap], WeakMap)
 
         reply.send({ hello: 'world' })
       })
@@ -206,7 +249,7 @@ test('#compileValidationSchema', subtest => {
 })
 
 test('#getValidationFunction', subtest => {
-  subtest.plan(4)
+  subtest.plan(6)
 
   subtest.test('Should return a validation function', async t => {
     const fastify = Fastify()
@@ -228,6 +271,51 @@ test('#getValidationFunction', subtest => {
     })
   })
 
+  subtest.test('Validate function errors property should be null after validation when input is valid', async t => {
+    const fastify = Fastify()
+
+    t.plan(3)
+
+    fastify.get('/', (req, reply) => {
+      req.compileValidationSchema(defaultSchema)
+      const validate = req.getValidationFunction(defaultSchema)
+
+      t.ok(validate({ hello: 'world' }))
+      t.ok(Object.prototype.hasOwnProperty.call(validate, 'errors'))
+      t.equal(validate.errors, null)
+
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.inject({
+      path: '/',
+      method: 'GET'
+    })
+  })
+
+  subtest.test('Validate function errors property should be an array of errors after validation when input is valid', async t => {
+    const fastify = Fastify()
+
+    t.plan(4)
+
+    fastify.get('/', (req, reply) => {
+      req.compileValidationSchema(defaultSchema)
+      const validate = req.getValidationFunction(defaultSchema)
+
+      t.notOk(validate({ world: 'foo' }))
+      t.ok(Object.prototype.hasOwnProperty.call(validate, 'errors'))
+      t.ok(Array.isArray(validate.errors))
+      t.ok(validate.errors.length > 0)
+
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.inject({
+      path: '/',
+      method: 'GET'
+    })
+  })
+
   subtest.test('Should return undefined if no schema compiled', async t => {
     const fastify = Fastify()
 
@@ -336,7 +424,7 @@ test('#getValidationFunction', subtest => {
       req.getValidationFunction(defaultSchema)
       req.getValidationFunction('body')
 
-      t.equal(req.context[kRequestValidateWeakMap], null)
+      t.equal(req[kRouteContext][kRequestValidateWeakMap], null)
       reply.send({ hello: 'world' })
     })
 
@@ -636,9 +724,9 @@ test('#validate', subtest => {
       t.plan(3)
 
       fastify.get('/', (req, reply) => {
-        t.equal(req.context[kRequestValidateWeakMap], null)
+        t.equal(req[kRouteContext][kRequestValidateWeakMap], null)
         t.equal(req.validateInput({ hello: 'world' }, defaultSchema), true)
-        t.type(req.context[kRequestValidateWeakMap], WeakMap)
+        t.type(req[kRouteContext][kRequestValidateWeakMap], WeakMap)
 
         reply.send({ hello: 'world' })
       })

package/test/internals/request.test.js

@@ -3,6 +3,12 @@
 const { test } = require('tap')
 
 const Request = require('../../lib/request')
+const Context = require('../../lib/context')
+const {
+  kPublicRouteContext,
+  kReply,
+  kRequest
+} = require('../../lib/symbols')
 
 process.removeAllListeners('warning')
 
@@ -16,8 +22,28 @@ test('Regular request', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request
+    }
+  })
   req.connection = req.socket
-  const request = new Request('id', 'params', req, 'query', 'log')
+  const request = new Request('id', 'params', req, 'query', 'log', context)
   t.type(request, Request)
   t.type(request.validateInput, Function)
   t.type(request.getValidationFunction, Function)
@@ -36,6 +62,10 @@ test('Regular request', t => {
   t.equal(request.url, '/')
   t.equal(request.socket, req.socket)
   t.equal(request.protocol, 'http')
+  t.equal(request.routerPath, context.config.url)
+  t.equal(request.routerMethod, context.config.method)
+  t.equal(request.routeConfig, context[kPublicRouteContext].config)
+  t.equal(request.routeSchema, context[kPublicRouteContext].schema)
 
   // This will be removed, it's deprecated
   t.equal(request.connection, req.connection)
@@ -77,7 +107,7 @@ test('Regular request - host header has precedence over authority', t => {
 })
 
 test('Request with trust proxy', t => {
-  t.plan(18)
+  t.plan(22)
   const headers = {
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'example.com'
@@ -88,9 +118,29 @@ test('Request with trust proxy', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request
+    }
+  })
 
   const TpRequest = Request.buildRequest(Request, true)
-  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  const request = new TpRequest('id', 'params', req, 'query', 'log', context)
   t.type(request, TpRequest)
   t.equal(request.id, 'id')
   t.equal(request.params, 'params')
@@ -109,6 +159,10 @@ test('Request with trust proxy', t => {
   t.type(request.validateInput, Function)
   t.type(request.getValidationFunction, Function)
   t.type(request.compileValidationSchema, Function)
+  t.equal(request.routerPath, context.config.url)
+  t.equal(request.routerMethod, context.config.method)
+  t.equal(request.routeConfig, context[kPublicRouteContext].config)
+  t.equal(request.routeSchema, context[kPublicRouteContext].schema)
 })
 
 test('Request with trust proxy, encrypted', t => {

package/test/internals/validation.test.js

@@ -268,6 +268,21 @@ test('build schema - headers are not lowercased in case of custom object', t =>
   })
 })
 
+test('build schema - headers are not lowercased in case of custom validator provided', t => {
+  t.plan(1)
+
+  class Headers {}
+  const opts = {
+    schema: {
+      headers: new Headers()
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
+    t.type(schema, Headers)
+    return () => {}
+  }, true)
+})
+
 test('build schema - uppercased headers are not included', t => {
   t.plan(1)
   const opts = {

package/test/plugin.test.js

@@ -885,7 +885,7 @@ test('pluginTimeout', t => {
   })
 })
 
-test('pluginTimeout - named function', { only: true }, t => {
+test('pluginTimeout - named function', t => {
   t.plan(5)
   const fastify = Fastify({
     pluginTimeout: 10

package/test/reply-code.test.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+
+test('code should handle null/undefined/float', t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.get('/null', function (request, reply) {
+    reply.status(null).send()
+  })
+
+  fastify.get('/undefined', function (request, reply) {
+    reply.status(undefined).send()
+  })
+
+  fastify.get('/404.5', function (request, reply) {
+    reply.status(404.5).send()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/null'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 500)
+    t.same(res.json(), {
+      statusCode: 500,
+      code: 'FST_ERR_BAD_STATUS_CODE',
+      error: 'Internal Server Error',
+      message: 'Called reply with an invalid status code: null'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefined'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 500)
+    t.same(res.json(), {
+      statusCode: 500,
+      code: 'FST_ERR_BAD_STATUS_CODE',
+      error: 'Internal Server Error',
+      message: 'Called reply with an invalid status code: undefined'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/404.5'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 404)
+  })
+})

package/test/route.test.js

@@ -1464,3 +1464,32 @@ test('invalid url attribute - non string URL', t => {
     t.equal(error.code, FST_ERR_INVALID_URL().code)
   }
 })
+
+test('exposeHeadRoute should not reuse the same route option', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  // we update the onRequest hook in onRoute hook
+  // if we reuse the same route option
+  // that means we will append another function inside the array
+  fastify.addHook('onRoute', function (routeOption) {
+    if (Array.isArray(routeOption.onRequest)) {
+      routeOption.onRequest.push(() => {})
+    } else {
+      routeOption.onRequest = [() => {}]
+    }
+  })
+
+  fastify.addHook('onRoute', function (routeOption) {
+    t.equal(routeOption.onRequest.length, 1)
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/more-coffee',
+    async handler () {
+      return 'hello world'
+    }
+  })
+})