fastify 3.26.0 → 4.0.0-alpha.1

package/test/route.test.js

@@ -5,9 +5,19 @@ 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)
@@ -202,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) => {
@@ -535,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')
   }
 })
 
@@ -552,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')
   }
@@ -580,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)
 
@@ -810,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, '')
   })
@@ -958,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!')
@@ -991,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({
@@ -1247,24 +1337,130 @@ 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('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: 'HEAD',
+      path: '/shouldThrow',
+      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 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: 'POST',
-      url: '/test',
-      handler: function () {},
-      errorHandler: ''
+      method: ['HEAD', 'GET'],
+      path: '/shouldThrowHead',
+      schema: {
+        body: {}
+      },
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
     })
-  }, new Error('Error Handler for POST:/test route, if defined, must be a function'))
+  }, 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(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öö')
+    })
+  })
+})
+
+test('invalid url attribute - non string URL', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(/^\/(donations|skills|blogs)/, () => {})
+  } catch (error) {
+    t.equal(error.code, FST_ERR_INVALID_URL().code)
+  }
 })

package/test/router-options.test.js

@@ -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')
 
@@ -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)
   }

package/test/schema-serialization.test.js

@@ -163,7 +163,7 @@ test('Use shared schema and $ref with $id in response ($ref to $id)', t => {
     t.equal(res.statusCode, 400)
     t.same(res.json(), {
       error: 'Bad Request',
-      message: "body should have required property 'address'",
+      message: "body must have required property 'address'",
       statusCode: 400
     })
   })
@@ -236,8 +236,7 @@ test('Shared schema should be pass to serializer and validator ($ref to shared s
     $schema: 'http://json-schema.org/draft-07/schema#',
     title: 'List of Asset locations',
     type: 'array',
-    items: { $ref: 'http://example.com/asset.json#' },
-    default: []
+    items: { $ref: 'http://example.com/asset.json#' }
   }
 
   fastify.post('/', {
@@ -273,7 +272,7 @@ test('Shared schema should be pass to serializer and validator ($ref to shared s
       t.equal(res.statusCode, 400)
       t.same(res.json(), {
         error: 'Bad Request',
-        message: 'body[0].location.email should match format "email"',
+        message: 'body/0/location/email must match format "email"',
         statusCode: 400
       })
     })
@@ -282,7 +281,7 @@ test('Shared schema should be pass to serializer and validator ($ref to shared s
 
 test('Custom setSerializerCompiler', t => {
   t.plan(7)
-  const fastify = Fastify()
+  const fastify = Fastify({ exposeHeadRoutes: false })
 
   const outSchema = {
     $id: 'test',
@@ -355,7 +354,6 @@ test('Custom setSerializerCompiler returns bad serialized output', t => {
     t.error(err)
     t.equal(res.statusCode, 500)
     t.strictSame(res.json(), {
-      error: 'Internal Server Error',
       code: 'FST_ERR_REP_INVALID_PAYLOAD_TYPE',
       message: 'Attempted to send payload of invalid type \'object\'. Expected a string or Buffer.',
       statusCode: 500
@@ -410,11 +408,11 @@ test('Custom serializer per route', async t => {
   res = await fastify.inject('/route')
   t.equal(res.json().mean, 'route')
 
-  t.equal(hit, 2, 'the custom and route serializer has been called')
+  t.equal(hit, 4, 'the custom and route serializer has been called')
 })
 
 test('Reply serializer win over serializer ', t => {
-  t.plan(5)
+  t.plan(6)
 
   const fastify = Fastify()
   fastify.setReplySerializer(function (payload, statusCode) {
@@ -453,7 +451,7 @@ test('Reply serializer win over serializer ', t => {
 })
 
 test('Reply serializer win over serializer ', t => {
-  t.plan(5)
+  t.plan(6)
 
   const fastify = Fastify()
   fastify.setReplySerializer(function (payload, statusCode) {
@@ -570,11 +568,13 @@ test('do not crash if status code serializer errors', async t => {
   const fastify = Fastify()
 
   const requiresFoo = {
+    type: 'object',
     properties: { foo: { type: 'string' } },
     required: ['foo']
   }
 
   const someUserErrorType2 = {
+    type: 'object',
     properties: {
       code: { type: 'number' }
     },
@@ -670,3 +670,44 @@ test('error in custom schema serialize compiler, throw FST_ERR_SCH_SERIALIZATION
     t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
   })
 })
+
+test('Errors in searilizer sended to errorHandler', async t => {
+  let savedError
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            power: { type: 'string' }
+          },
+          required: ['name']
+        }
+      }
+    }
+
+  }, function (req, reply) {
+    reply.code(200).send({ no: 'thing' })
+  })
+  fastify.setErrorHandler((error, request, reply) => {
+    savedError = error
+    reply.code(500).send(error)
+  })
+
+  const res = await fastify.inject('/')
+
+  t.equal(res.statusCode, 500)
+
+  // t.same(savedError, new Error('"name" is required!'));
+  t.same(res.json(), {
+    statusCode: 500,
+    error: 'Internal Server Error',
+    message: '"name" is required!'
+  })
+  t.ok(savedError, 'error presents')
+  t.ok(savedError.serialization, 'Serialization sign presents')
+  t.end()
+})