fastify 3.27.4 → 4.0.0-alpha.3

package/test/reply-trailers.test.js

@@ -0,0 +1,270 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const { Readable } = require('stream')
+const { createHash } = require('crypto')
+
+test('send trailers when payload is empty string', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is empty buffer', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(Buffer.alloc(0))
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is undefined', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is json', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const data = JSON.stringify({ hello: 'world' })
+  const hash = createHash('md5')
+  hash.update(data)
+  const md5 = hash.digest('hex')
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('Content-MD5', function (reply, payload) {
+      t.equal(data, payload)
+      const hash = createHash('md5')
+      hash.update(payload)
+      return hash.digest('hex')
+    })
+    reply.send(data)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'content-md5')
+    t.equal(res.trailers['content-md5'], md5)
+  })
+})
+
+test('send trailers when payload is stream', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      t.same(payload, null)
+      return 'custom-etag'
+    })
+    const stream = Readable.from([JSON.stringify({ hello: 'world' })])
+    reply.send(stream)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('removeTrailer', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.removeTrailer('ETag') // remove nothing
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    reply.removeTrailer('Should-Not-Call')
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+  })
+})
+
+test('hasTrailer', t => {
+  t.plan(9)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    t.equal(reply.hasTrailer('ETag'), false)
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    t.equal(reply.hasTrailer('ETag'), true)
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    t.equal(reply.hasTrailer('Should-Not-Call'), true)
+    reply.removeTrailer('Should-Not-Call')
+    t.equal(reply.hasTrailer('Should-Not-Call'), false)
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+  })
+})
+
+test('throw error when trailer header name is not allowed', t => {
+  const INVALID_TRAILERS = [
+    'transfer-encoding',
+    'content-length',
+    'host',
+    'cache-control',
+    'max-forwards',
+    'te',
+    'authorization',
+    'set-cookie',
+    'content-encoding',
+    'content-type',
+    'content-range',
+    'trailer'
+  ]
+  t.plan(INVALID_TRAILERS.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const key of INVALID_TRAILERS) {
+      try {
+        reply.trailer(key, () => {})
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer with an invalid header name: ${key}`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('throw error when trailer header value is not function', t => {
+  const INVALID_TRAILERS_VALUE = [
+    undefined,
+    null,
+    true,
+    false,
+    'invalid',
+    [],
+    new Date(),
+    {}
+  ]
+  t.plan(INVALID_TRAILERS_VALUE.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const value of INVALID_TRAILERS_VALUE) {
+      try {
+        reply.trailer('invalid', value)
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer('invalid', fn) with an invalid type: ${typeof value}. Expected a function.`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})

package/test/request-error.test.js

@@ -43,7 +43,7 @@ test('default 400 on request error with custom error handler', t => {
 
   fastify.setErrorHandler(function (err, request, reply) {
     t.type(request, 'object')
-    t.type(request, fastify[kRequest])
+    t.type(request, fastify[kRequest].parent)
     reply
       .code(err.statusCode)
       .type('application/json; charset=utf-8')
@@ -105,7 +105,7 @@ test('default clientError handler ignores ECONNRESET', t => {
     })
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     t.error(err)
     fastify.server.unref()
 
@@ -132,10 +132,7 @@ test('default clientError handler ignores sockets in destroyed state', t => {
 
   const fastify = Fastify({
     bodyLimit: 1,
-    keepAliveTimeout: 100,
-    logger: {
-      level: 'trace'
-    }
+    keepAliveTimeout: 100
   })
   fastify.server.on('clientError', () => {
     // this handler is called after default handler, so we can make sure end was not called

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