fastify 3.27.3 → 4.0.0-alpha.2

package/test/route-hooks.test.js

@@ -7,11 +7,11 @@ const Fastify = require('../')
 
 process.removeAllListeners('warning')
 
-function endRouteHook (doneOrPayload, done) {
+function endRouteHook (doneOrPayload, done, doneValue) {
   if (typeof doneOrPayload === 'function') {
-    doneOrPayload()
+    doneOrPayload(doneValue)
   } else {
-    done()
+    done(doneValue)
   }
 }
 
@@ -152,9 +152,9 @@ function testBeforeHandlerHook (hook) {
     const fastify = Fastify()
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
+      [hook]: (req, reply, doneOrPayload, done) => {
         req.hello = 'earth'
-        done()
+        endRouteHook(doneOrPayload, done)
       }
     }, (req, reply) => {
       reply.send({ hello: req.hello })
@@ -190,8 +190,8 @@ function testBeforeHandlerHook (hook) {
     const fastify = Fastify()
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
-        done(new Error('kaboom'))
+      [hook]: (req, reply, doneOrPayload, done) => {
+        endRouteHook(doneOrPayload, done, new Error('kaboom'))
       }
     }, (req, reply) => {
       reply.send(req.body)
@@ -221,7 +221,7 @@ function testBeforeHandlerHook (hook) {
 
     fastify.setErrorHandler(async (error, request, reply) => {
       t.same(error, myError, 'the error object throws by the user')
-      reply.send({ this: 'is', my: 'error' })
+      return reply.code(500).send({ this: 'is', my: 'error' })
     })
 
     fastify.get('/', {
@@ -271,9 +271,9 @@ function testBeforeHandlerHook (hook) {
     const fastify = Fastify()
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
+      [hook]: (req, reply, doneOrPayload, done) => {
         reply.code(401)
-        done(new Error('go away'))
+        endRouteHook(doneOrPayload, done, new Error('go away'))
       }
     }, (req, reply) => {
       reply.send(req.body)
@@ -302,10 +302,10 @@ function testBeforeHandlerHook (hook) {
     fastify.decorate('foo', 42)
 
     fastify.post('/', {
-      [hook]: function (req, reply, done) {
+      [hook]: function (req, reply, doneOrPayload, done) {
         t.equal(this.foo, 42)
         this.foo += 1
-        done()
+        endRouteHook(doneOrPayload, done)
       }
     }, function (req, reply) {
       reply.send({ foo: this.foo })
@@ -329,10 +329,10 @@ function testBeforeHandlerHook (hook) {
     fastify.decorate('foo', 42)
 
     fastify.post('/', {
-      [hook]: [function (req, reply, done) {
+      [hook]: [function (req, reply, doneOrPayload, done) {
         t.equal(this.foo, 42)
         this.foo += 1
-        done()
+        endRouteHook(doneOrPayload, done)
       }]
     }, function (req, reply) {
       reply.send({ foo: this.foo })
@@ -423,7 +423,7 @@ test('preParsing option should be called before preValidation hook', t => {
   })
 
   fastify.post('/', {
-    preParsing: (req, reply, done) => {
+    preParsing: (req, reply, payload, done) => {
       req.called = true
       done()
     }
@@ -473,7 +473,7 @@ test('onRequest option should be called before preParsing', t => {
   t.plan(3)
   const fastify = Fastify()
 
-  fastify.addHook('preParsing', (req, reply, done) => {
+  fastify.addHook('preParsing', (req, reply, payload, done) => {
     t.ok(req.called)
     done()
   })
@@ -503,14 +503,14 @@ test('onTimeout on route', t => {
   const fastify = Fastify({ connectionTimeout: 500 })
 
   fastify.get('/timeout', {
-    async  handler (request, reply) { },
+    handler (request, reply) { },
     onTimeout (request, reply, done) {
       t.pass('onTimeout called')
       done()
     }
   })
 
-  fastify.listen(0, (err, address) => {
+  fastify.listen({ port: 0 }, (err, address) => {
     t.error(err)
     t.teardown(() => fastify.close())
 

package/test/route-prefix.test.js

@@ -565,7 +565,8 @@ test('matches only /prefix/  with a / route - prefixTrailingSlash: "slash", igno
 test('calls onRoute only once when prefixing', async t => {
   t.plan(1)
   const fastify = Fastify({
-    ignoreTrailingSlash: false
+    ignoreTrailingSlash: false,
+    exposeHeadRoutes: false
   })
 
   let onRouteCalled = 0

package/test/route.test.js

@@ -5,11 +5,20 @@ const split = require('split2')
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
-const joi = require('@hapi/joi')
+const joi = require('joi')
 const Fastify = require('..')
 const proxyquire = require('proxyquire')
 const { FST_ERR_INVALID_URL } = require('../lib/errors')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('route', t => {
   t.plan(9)
   const test = t.test
@@ -104,7 +113,7 @@ test('route', t => {
     }
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     if (err) t.error(err)
     fastify.server.unref()
 
@@ -203,7 +212,7 @@ test('same route definition object on multiple prefixes', async t => {
     url: '/simple'
   }
 
-  const fastify = Fastify()
+  const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.register(async function (f) {
     f.addHook('onRoute', (routeOptions) => {
@@ -536,15 +545,15 @@ test('throws when route with empty url', async t => {
 
   const fastify = Fastify()
   try {
-    await fastify.route({
+    fastify.route({
       method: 'GET',
       url: '',
       handler: (req, res) => {
         res.send('hi!')
       }
-    }).ready()
+    })
   } catch (err) {
-    t.equal(err.message, 'The first character of a path should be `/` or `*`')
+    t.equal(err.message, 'The path could not be empty')
   }
 })
 
@@ -553,10 +562,10 @@ test('throws when route with empty url in shorthand declaration', async t => {
 
   const fastify = Fastify()
   try {
-    await fastify.get(
+    fastify.get(
       '',
       async function handler () { return {} }
-    ).ready()
+    )
   } catch (err) {
     t.equal(err.message, 'The path could not be empty')
   }
@@ -581,6 +590,86 @@ test('throws when route-level error handler is not a function', t => {
   }
 })
 
+test('Creates a HEAD route for each GET one (default)', t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    path: '/more-coffee',
+    handler: (req, reply) => {
+      reply.send({ here: 'is coffee' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/some-light',
+    handler: (req, reply) => {
+      reply.send('Get some light!')
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/more-coffee'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.same(res.body, '')
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/some-light'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['content-type'], 'text/plain; charset=utf-8')
+    t.equal(res.body, '')
+  })
+})
+
+test('Do not create a HEAD route for each GET one (exposeHeadRoutes: false)', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  fastify.route({
+    method: 'GET',
+    path: '/more-coffee',
+    handler: (req, reply) => {
+      reply.send({ here: 'is coffee' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/some-light',
+    handler: (req, reply) => {
+      reply.send('Get some light!')
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/more-coffee'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 404)
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/some-light'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 404)
+  })
+})
+
 test('Creates a HEAD route for each GET one', t => {
   t.plan(8)
 
@@ -811,7 +900,7 @@ test('HEAD route should handle properly each response type', t => {
   }, (error, res) => {
     t.error(error)
     t.equal(res.statusCode, 200)
-    t.equal(res.headers['content-type'], 'application/octet-stream')
+    t.equal(res.headers['content-type'], undefined)
     t.equal(res.headers['content-length'], undefined)
     t.equal(res.body, '')
   })
@@ -916,7 +1005,7 @@ test('no warning for exposeHeadRoute', async t => {
 
   process.on('warning', listener)
 
-  await fastify.listen(0)
+  await fastify.listen({ port: 0 })
 
   process.removeListener('warning', listener)
 
@@ -959,11 +1048,11 @@ test("HEAD route should handle stream.on('error')", t => {
   }, (error, res) => {
     t.error(error)
     t.equal(res.statusCode, 200)
-    t.equal(res.headers['content-type'], 'application/octet-stream')
+    t.equal(res.headers['content-type'], undefined)
   })
 })
 
-test('HEAD route should not be exposed by default', t => {
+test('HEAD route should be exposed by default', t => {
   t.plan(7)
 
   const resStream = stream.Readable.from('Hello with error!')
@@ -992,7 +1081,7 @@ test('HEAD route should not be exposed by default', t => {
     url: '/without-flag'
   }, (error, res) => {
     t.error(error)
-    t.equal(res.statusCode, 404)
+    t.equal(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -1248,26 +1337,121 @@ test('Will not try to re-createprefixed HEAD route if it already exists and expo
   t.ok(true)
 })
 
-test('Correct error message is produced if "path" option is used', t => {
-  t.plan(2)
+test('GET route with body schema should throw', t => {
+  t.plan(1)
 
   const fastify = Fastify()
 
   t.throws(() => {
     fastify.route({
       method: 'GET',
-      path: '/test'
+      path: '/get',
+      schema: {
+        body: {}
+      },
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
     })
-  }, new Error('Missing handler function for GET:/test route.'))
+  }, new Error('Body validation schema for GET:/get route is not supported!'))
+})
+
+test('HEAD route with body schema should throw', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
 
   t.throws(() => {
     fastify.route({
-      method: 'POST',
-      url: '/test',
-      handler: function () {},
-      errorHandler: ''
+      method: 'HEAD',
+      path: '/shouldThrow',
+      schema: {
+        body: {}
+      },
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
+    })
+  }, new Error('Body validation schema for HEAD:/shouldThrow route is not supported!'))
+})
+
+test('[HEAD, GET] route with body schema should throw', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  t.throws(() => {
+    fastify.route({
+      method: ['HEAD', 'GET'],
+      path: '/shouldThrowHead',
+      schema: {
+        body: {}
+      },
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
+    })
+  }, new Error('Body validation schema for HEAD:/shouldThrowHead route is not supported!'))
+})
+
+test('GET route with body schema should throw - shorthand', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  t.throws(() => {
+    fastify.get('/shouldThrow', {
+      schema: {
+        body: {}
+      }
+    },
+    function (req, reply) {
+      reply.send({ hello: 'world' })
+    }
+    )
+  }, new Error('Body validation schema for GET:/shouldThrow route is not supported!'))
+})
+
+test('HEAD route with body schema should throw - shorthand', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  t.throws(() => {
+    fastify.head('/shouldThrow2', {
+      schema: {
+        body: {}
+      }
+    },
+    function (req, reply) {
+      reply.send({ hello: 'world' })
+    }
+    )
+  }, new Error('Body validation schema for HEAD:/shouldThrow2 route is not supported!'))
+})
+
+test('route with non-english characters', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/föö', (request, reply) => {
+    reply.send('here /föö')
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    sget({
+      method: 'GET',
+      url: getUrl(fastify) + encodeURI('/föö')
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), 'here /föö')
     })
-  }, new Error('Error Handler for POST:/test route, if defined, must be a function'))
+  })
 })
 
 test('invalid url attribute - non string URL', t => {

package/test/router-options.test.js

@@ -24,7 +24,7 @@ test('Should honor ignoreTrailingSlash option', t => {
     res.send('test')
   })
 
-  fastify.listen(0, (err) => {
+  fastify.listen({ port: 0 }, (err) => {
     fastify.server.unref()
     if (err) t.threw(err)
 
@@ -133,7 +133,7 @@ test('Should honor frameworkErrors option', t => {
     },
     (err, res) => {
       t.error(err)
-      t.equal(res.body, '\'%world\' is not a valid url component - FST_ERR_BAD_URL')
+      t.equal(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
     }
   )
 })

package/test/schema-examples.test.js

@@ -98,7 +98,13 @@ test('Example - get schema encapsulated', async t => {
 
 test('Example - validation', t => {
   t.plan(1)
-  const fastify = Fastify()
+  const fastify = Fastify({
+    ajv: {
+      customOptions: {
+        allowUnionTypes: true
+      }
+    }
+  })
   const handler = () => { }
 
   const bodyJsonSchema = {
@@ -224,7 +230,7 @@ test('Example Joi', t => {
   const fastify = Fastify()
   const handler = () => { }
 
-  const Joi = require('@hapi/joi')
+  const Joi = require('joi')
   fastify.post('/the/url', {
     schema: {
       body: Joi.object().keys({
@@ -431,7 +437,7 @@ test('Example - schemas examples', t => {
     }
   }
 
-  fastify.get('/', {
+  fastify.post('/', {
     handler,
     schema: {
       body: refToId,
@@ -450,7 +456,7 @@ test('should return custom error messages with ajv-errors', t => {
 
   const fastify = Fastify({
     ajv: {
-      customOptions: { allErrors: true, jsonPointers: true },
+      customOptions: { allErrors: true },
       plugins: [
         require('ajv-errors')
       ]
@@ -545,7 +551,7 @@ test('should return localized error messages with ajv-i18n', t => {
   }, (err, res) => {
     t.error(err)
     t.same(JSON.parse(res.payload), [{
-      dataPath: '',
+      instancePath: '',
       keyword: 'required',
       message: 'должно иметь обязательное поле work',
       params: { missingProperty: 'work' },

package/test/schema-feature.test.js

@@ -3,6 +3,7 @@
 const { test } = require('tap')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
+const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
 
@@ -22,7 +23,7 @@ const echoBody = (req, reply) => { reply.send(req.body) }
     t.plan(2)
     const fastify = Fastify()
     t.teardown(fastify.close.bind(fastify))
-    fastify.listen(0, err => {
+    fastify.listen({ port: 0 }, err => {
       t.error(err)
       try {
         fastify[f](() => { })
@@ -287,7 +288,7 @@ test('First level $ref', t => {
 
 test('Customize validator compiler in instance and route', t => {
   t.plan(28)
-  const fastify = Fastify()
+  const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
     t.equal(method, 'POST') // run 4 times
@@ -827,7 +828,7 @@ test('Validation context in validation result', t => {
     t.equal(err.validationContext, 'body')
     reply.send()
   })
-  fastify.get('/', {
+  fastify.post('/', {
     handler: echoParams,
     schema: {
       body: {
@@ -840,7 +841,7 @@ test('Validation context in validation result', t => {
     }
   })
   fastify.inject({
-    method: 'GET',
+    method: 'POST',
     url: '/',
     payload: {} // body lacks required field, will fail validation
   }, (err, res) => {
@@ -881,7 +882,7 @@ test('The schema build should not modify the input', t => {
     ]
   })
 
-  fastify.get('/', {
+  fastify.post('/', {
     schema: {
       description: 'get',
       body: { $ref: 'second#' },
@@ -918,7 +919,11 @@ test('Cross schema reference with encapsulation references', t => {
   t.plan(1)
 
   const fastify = Fastify()
-  fastify.addSchema({ $id: 'http://foo/item', type: 'object', properties: { foo: { type: 'string' } } })
+  fastify.addSchema({
+    $id: 'http://foo/item',
+    type: 'object',
+    properties: { foo: { type: 'string' } }
+  })
 
   const refItem = { $ref: 'http://foo/item#' }
 
@@ -949,15 +954,15 @@ test('Cross schema reference with encapsulation references', t => {
       }
     }
 
-    instance.get('/get', { schema: { response: { 200: multipleRef } } }, () => { })
-    instance.get('/double-get', { schema: { body: multipleRef, response: { 200: multipleRef } } }, () => { })
+    instance.get('/get', { schema: { response: { 200: deepClone(multipleRef) } } }, () => { })
+    instance.get('/double-get', { schema: { querystring: multipleRef, response: { 200: multipleRef } } }, () => { })
     instance.post('/post', { schema: { body: multipleRef, response: { 200: multipleRef } } }, () => { })
     instance.post('/double', { schema: { response: { 200: { $ref: 'encapsulation' } } } }, () => { })
     done()
   }, { prefix: '/foo' })
 
   fastify.post('/post', { schema: { body: refItem, response: { 200: refItem } } }, () => { })
-  fastify.get('/get', { schema: { body: refItem, response: { 200: refItem } } }, () => { })
+  fastify.get('/get', { schema: { params: refItem, response: { 200: refItem } } }, () => { })
 
   fastify.ready(err => {
     t.error(err)
@@ -1009,7 +1014,7 @@ test('onReady hook has the compilers ready', t => {
   fastify.get(`/${Math.random()}`, {
     handler: (req, reply) => reply.send(),
     schema: {
-      body: { type: 'object' },
+      headers: { type: 'object' },
       response: { 200: { type: 'object' } }
     }
   })
@@ -1099,7 +1104,7 @@ test('Check how many AJV instances are built #2 - verify validatorPool', t => {
 })
 
 function addRandomRoute (server) {
-  server.get(`/${Math.random()}`,
+  server.post(`/${Math.random()}`,
     { schema: { body: { type: 'object' } } },
     (req, reply) => reply.send()
   )
@@ -1370,7 +1375,7 @@ test('setSchemaController: Inherits correctly parent schemas with a customized v
   })
   const json = res.json()
 
-  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(json.message, 'querystring/msg must be array')
   t.equal(json.statusCode, 400)
   t.equal(res.statusCode, 400, 'Should not coearce the string into array')
 })
@@ -1481,7 +1486,7 @@ test('setSchemaController: Inherits buildSerializer from parent if not present w
   const json = res.json()
 
   t.equal(json.statusCode, 400)
-  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(json.message, 'querystring/msg must be array')
   t.equal(rootSerializerCalled, 1, 'Should be called from the child')
   t.equal(rootValidatorCalled, 0, 'Should not be called from the child')
   t.equal(childValidatorCalled, 1, 'Should be called from the child')
@@ -1598,7 +1603,7 @@ test('setSchemaController: Inherits buildValidator from parent if not present wi
   const json = res.json()
 
   t.equal(json.statusCode, 400)
-  t.equal(json.message, 'querystring.msg should be array')
+  t.equal(json.message, 'querystring/msg must be array')
   t.equal(rootSerializerCalled, 0, 'Should be called from the child')
   t.equal(rootValidatorCalled, 1, 'Should not be called from the child')
   t.equal(childSerializerCalled, 1, 'Should be called from the child')
@@ -1683,14 +1688,14 @@ test('Should throw if not default validator passed', async t => {
       }
     })
 
-    t.equal(res.json().message, 'querystring.msg should be array')
+    t.equal(res.json().message, 'querystring/msg must be array')
     t.equal(res.statusCode, 400, 'Should not coearce the string into array')
   } catch (err) {
     t.error(err)
   }
 })
 
-test('Should throw if not default validator passed', async t => {
+test('Should coerce the array if the default validator is used', async t => {
   t.plan(2)
   const someSchema = {
     $id: 'some',
@@ -1728,7 +1733,7 @@ test('Should throw if not default validator passed', async t => {
         }
       },
       (req, reply) => {
-        reply.send({ noop: 'noop' })
+        reply.send(req.query)
       }
     )
 
@@ -1740,12 +1745,12 @@ test('Should throw if not default validator passed', async t => {
       method: 'POST',
       url: '/',
       query: {
-        msg: ['string']
+        msg: 'string'
       }
     })
 
-    t.equal(res.json().message, 'querystring.msg should be array')
-    t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), { msg: ['string'] }, 'Should coearce the string into array')
   } catch (err) {
     t.error(err)
   }