fastify 4.23.2 → 4.24.1

package/test/reply-code.test.js

@@ -57,3 +57,67 @@ test('code should handle null/undefined/float', t => {
     t.equal(res.statusCode, 404)
   })
 })
+
+test('code should handle 204', t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204)
+    return null
+  })
+
+  fastify.get('/undefined/204', function (request, reply) {
+    reply.status(204).send({ message: 'hello' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefined/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+  })
+})
+
+test('code should handle onSend hook on 204', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    return {
+      ...payload,
+      world: 'hello'
+    }
+  })
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204).send({
+      hello: 'world'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+    t.equal(res.headers['content-type'], undefined)
+  })
+})

package/test/reply-trailers.test.js

@@ -5,8 +5,7 @@ const test = t.test
 const Fastify = require('..')
 const { Readable } = require('node:stream')
 const { createHash } = require('node:crypto')
-const { promisify } = require('node:util')
-const sleep = promisify(setTimeout)
+const { sleep } = require('./helper')
 
 test('send trailers when payload is empty string', t => {
   t.plan(5)

package/test/route.1.test.js

@@ -0,0 +1,309 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('..')
+const {
+  FST_ERR_INSTANCE_ALREADY_LISTENING,
+  FST_ERR_ROUTE_METHOD_INVALID
+} = require('../lib/errors')
+const { getServerUrl } = require('./helper')
+
+test('route', t => {
+  t.plan(10)
+  const test = t.test
+
+  test('route - get', t => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() =>
+      fastify.route({
+        method: 'GET',
+        url: '/',
+        schema: {
+          response: {
+            '2xx': {
+              type: 'object',
+              properties: {
+                hello: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        },
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      })
+    )
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'GET',
+        url: getServerUrl(fastify) + '/'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('missing schema - route', t => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() =>
+      fastify.route({
+        method: 'GET',
+        url: '/missing',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      })
+    )
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'GET',
+        url: getServerUrl(fastify) + '/missing'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('invalid handler attribute - route', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+    t.throws(() => fastify.get('/', { handler: 'not a function' }, () => { }))
+  })
+
+  test('Add Multiple methods per route all uppercase', t => {
+    t.plan(7)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() =>
+      fastify.route({
+        method: ['GET', 'DELETE'],
+        url: '/multiple',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }))
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'GET',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+
+      sget({
+        method: 'DELETE',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('Add Multiple methods per route all lowercase', t => {
+    t.plan(7)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() =>
+      fastify.route({
+        method: ['get', 'delete'],
+        url: '/multiple',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }))
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'GET',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+
+      sget({
+        method: 'DELETE',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('Add Multiple methods per route mixed uppercase and lowercase', t => {
+    t.plan(7)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() =>
+      fastify.route({
+        method: ['GET', 'delete'],
+        url: '/multiple',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }))
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'GET',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+
+      sget({
+        method: 'DELETE',
+        url: getServerUrl(fastify) + '/multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('Add invalid Multiple methods per route', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+    t.throws(() =>
+      fastify.route({
+        method: ['GET', 1],
+        url: '/invalid-method',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }), new FST_ERR_ROUTE_METHOD_INVALID())
+  })
+
+  test('Add method', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+    t.throws(() =>
+      fastify.route({
+        method: 1,
+        url: '/invalid-method',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }), new FST_ERR_ROUTE_METHOD_INVALID())
+  })
+
+  test('Add additional multiple methods to existing route', t => {
+    t.plan(7)
+
+    const fastify = Fastify()
+    t.doesNotThrow(() => {
+      fastify.get('/add-multiple', function (req, reply) {
+        reply.send({ hello: 'Bob!' })
+      })
+      fastify.route({
+        method: ['PUT', 'DELETE'],
+        url: '/add-multiple',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      })
+    })
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      sget({
+        method: 'PUT',
+        url: getServerUrl(fastify) + '/add-multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+
+      sget({
+        method: 'DELETE',
+        url: getServerUrl(fastify) + '/add-multiple'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+  })
+
+  test('cannot add another route after binding', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+
+    fastify.listen({ port: 0 }, function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+
+      t.throws(() => fastify.route({
+        method: 'GET',
+        url: '/another-get-route',
+        handler: function (req, reply) {
+          reply.send({ hello: 'world' })
+        }
+      }), new FST_ERR_INSTANCE_ALREADY_LISTENING('Cannot add route!'))
+    })
+  })
+})
+
+test('invalid schema - route', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.route({
+    handler: () => { },
+    method: 'GET',
+    url: '/invalid',
+    schema: {
+      querystring: {
+        id: 'string'
+      }
+    }
+  })
+  fastify.after(err => {
+    t.notOk(err, 'the error is throw on preReady')
+  })
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.match(err.message, /Failed building the validation schema for GET: \/invalid/)
+  })
+})

package/test/route.2.test.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('../fastify')
+
+test('same route definition object on multiple prefixes', async t => {
+  t.plan(2)
+
+  const routeObject = {
+    handler: () => { },
+    method: 'GET',
+    url: '/simple'
+  }
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  fastify.register(async function (f) {
+    f.addHook('onRoute', (routeOptions) => {
+      t.equal(routeOptions.url, '/v1/simple')
+    })
+    f.route(routeObject)
+  }, { prefix: '/v1' })
+  fastify.register(async function (f) {
+    f.addHook('onRoute', (routeOptions) => {
+      t.equal(routeOptions.url, '/v2/simple')
+    })
+    f.route(routeObject)
+  }, { prefix: '/v2' })
+
+  await fastify.ready()
+})
+
+test('path can be specified in place of uri', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    path: '/path',
+    handler: function (req, reply) {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  const reqOpts = {
+    method: 'GET',
+    url: '/path'
+  }
+
+  fastify.inject(reqOpts, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
+test('invalid bodyLimit option - route', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.route({
+      bodyLimit: false,
+      method: 'PUT',
+      handler: () => null
+    })
+    t.fail('bodyLimit must be an integer')
+  } catch (err) {
+    t.equal(err.message, "'bodyLimit' option must be an integer > 0. Got 'false'")
+  }
+
+  try {
+    fastify.post('/url', { bodyLimit: 10000.1 }, () => null)
+    t.fail('bodyLimit must be an integer')
+  } catch (err) {
+    t.equal(err.message, "'bodyLimit' option must be an integer > 0. Got '10000.1'")
+  }
+})
+
+test('handler function in options of shorthand route should works correctly', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/foo', {
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})

package/test/route.3.test.js

@@ -0,0 +1,205 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const joi = require('joi')
+const Fastify = require('..')
+
+test('does not mutate joi schemas', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  function validatorCompiler ({ schema, method, url, httpPart }) {
+    // Needed to extract the params part,
+    // without the JSON-schema encapsulation
+    // that is automatically added by the short
+    // form of params.
+    schema = joi.object(schema.properties)
+
+    return validateHttpData
+
+    function validateHttpData (data) {
+      return schema.validate(data)
+    }
+  }
+
+  fastify.setValidatorCompiler(validatorCompiler)
+
+  fastify.route({
+    path: '/foo/:an_id',
+    method: 'GET',
+    schema: {
+      params: { an_id: joi.number() }
+    },
+    handler (req, res) {
+      t.same(req.params, { an_id: 42 })
+      res.send({ hello: 'world' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/42'
+  }, (err, result) => {
+    t.error(err)
+    t.equal(result.statusCode, 200)
+    t.same(JSON.parse(result.payload), { hello: 'world' })
+  })
+})
+
+test('multiple routes with one schema', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  const schema = {
+    query: {
+      id: { type: 'number' }
+    }
+  }
+
+  fastify.route({
+    schema,
+    method: 'GET',
+    path: '/first/:id',
+    handler (req, res) {
+      res.send({ hello: 'world' })
+    }
+  })
+
+  fastify.route({
+    schema,
+    method: 'GET',
+    path: '/second/:id',
+    handler (req, res) {
+      res.send({ hello: 'world' })
+    }
+  })
+
+  fastify.ready(error => {
+    t.error(error)
+    t.same(schema, schema)
+  })
+})
+
+test('route error handler overrides default error handler', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  const customRouteErrorHandler = (error, request, reply) => {
+    t.equal(error.message, 'Wrong Pot Error')
+
+    reply.code(418).send({
+      message: 'Make a brew',
+      statusCode: 418,
+      error: 'Wrong Pot Error'
+    })
+  }
+
+  fastify.route({
+    method: 'GET',
+    path: '/coffee',
+    handler: (req, res) => {
+      res.send(new Error('Wrong Pot Error'))
+    },
+    errorHandler: customRouteErrorHandler
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/coffee'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 418)
+    t.same(JSON.parse(res.payload), {
+      message: 'Make a brew',
+      statusCode: 418,
+      error: 'Wrong Pot Error'
+    })
+  })
+})
+
+test('route error handler does not affect other routes', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  const customRouteErrorHandler = (error, request, reply) => {
+    t.equal(error.message, 'Wrong Pot Error')
+
+    reply.code(418).send({
+      message: 'Make a brew',
+      statusCode: 418,
+      error: 'Wrong Pot Error'
+    })
+  }
+
+  fastify.route({
+    method: 'GET',
+    path: '/coffee',
+    handler: (req, res) => {
+      res.send(new Error('Wrong Pot Error'))
+    },
+    errorHandler: customRouteErrorHandler
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/tea',
+    handler: (req, res) => {
+      res.send(new Error('No tea today'))
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/tea'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 500)
+    t.same(JSON.parse(res.payload), {
+      message: 'No tea today',
+      statusCode: 500,
+      error: 'Internal Server Error'
+    })
+  })
+})
+
+test('async error handler for a route', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  const customRouteErrorHandler = async (error, request, reply) => {
+    t.equal(error.message, 'Delayed Pot Error')
+    reply.code(418)
+    return {
+      message: 'Make a brew sometime later',
+      statusCode: 418,
+      error: 'Delayed Pot Error'
+    }
+  }
+
+  fastify.route({
+    method: 'GET',
+    path: '/late-coffee',
+    handler: (req, res) => {
+      res.send(new Error('Delayed Pot Error'))
+    },
+    errorHandler: customRouteErrorHandler
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/late-coffee'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 418)
+    t.same(JSON.parse(res.payload), {
+      message: 'Make a brew sometime later',
+      statusCode: 418,
+      error: 'Delayed Pot Error'
+    })
+  })
+})