node-fastify 5.8.3

package/test/hooks-async.test.js

@@ -0,0 +1,1099 @@
+'use strict'
+
+const { Readable } = require('node:stream')
+const { test, describe } = require('node:test')
+const Fastify = require('../fastify')
+const fs = require('node:fs')
+const { sleep } = require('./helper')
+const { waitForCb } = require('./toolkit')
+
+process.removeAllListeners('warning')
+
+test('async hooks', async t => {
+  t.plan(20)
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.addHook('onRequest', async function (request, reply) {
+    await sleep(1)
+    request.test = 'the request is coming'
+    reply.test = 'the reply has come'
+    if (request.raw.method === 'DELETE') {
+      throw new Error('some error')
+    }
+  })
+
+  fastify.addHook('preHandler', async function (request, reply) {
+    await sleep(1)
+    t.assert.strictEqual(request.test, 'the request is coming')
+    t.assert.strictEqual(reply.test, 'the reply has come')
+    if (request.raw.method === 'HEAD') {
+      throw new Error('some error')
+    }
+  })
+
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    await sleep(1)
+    t.assert.ok('onSend called')
+  })
+
+  const completion = waitForCb({
+    steps: 6
+  })
+  fastify.addHook('onResponse', async function (request, reply) {
+    await sleep(1)
+    t.assert.ok('onResponse called')
+    completion.stepIn()
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.strictEqual(request.test, 'the request is coming')
+    t.assert.strictEqual(reply.test, 'the reply has come')
+    reply.code(200).send({ hello: 'world' })
+  })
+
+  fastify.head('/', function (req, reply) {
+    reply.code(200).send({ hello: 'world' })
+  })
+
+  fastify.delete('/', function (req, reply) {
+    reply.code(200).send({ hello: 'world' })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response1 = await fetch(fastifyServer, {
+    method: 'GET'
+  })
+  t.assert.ok(response1.ok)
+  t.assert.strictEqual(response1.status, 200)
+  const body1 = await response1.text()
+  t.assert.strictEqual(response1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world' })
+  completion.stepIn()
+
+  const response2 = await fetch(fastifyServer, {
+    method: 'HEAD'
+  })
+  t.assert.ok(!response2.ok)
+  t.assert.strictEqual(response2.status, 500)
+  completion.stepIn()
+
+  const response3 = await fetch(fastifyServer, {
+    method: 'DELETE'
+  })
+  t.assert.ok(!response3.ok)
+  t.assert.strictEqual(response3.status, 500)
+  completion.stepIn()
+
+  return completion.patience
+})
+
+test('modify payload', (t, testDone) => {
+  t.plan(10)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+  const modifiedPayload = { hello: 'modified' }
+  const anotherPayload = '"winter is coming"'
+
+  fastify.addHook('onSend', async function (request, reply, thePayload) {
+    t.assert.ok('onSend called')
+    t.assert.deepStrictEqual(JSON.parse(thePayload), payload)
+    return thePayload.replace('world', 'modified')
+  })
+
+  fastify.addHook('onSend', async function (request, reply, thePayload) {
+    t.assert.ok('onSend called')
+    t.assert.deepStrictEqual(JSON.parse(thePayload), modifiedPayload)
+    return anotherPayload
+  })
+
+  fastify.addHook('onSend', async function (request, reply, thePayload) {
+    t.assert.ok('onSend called')
+    t.assert.deepStrictEqual(thePayload, anotherPayload)
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, anotherPayload)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '18')
+    testDone()
+  })
+})
+
+test('onRequest hooks should be able to block a request', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.addHook('onRequest', async (req, reply) => {
+    await reply.send('hello')
+  })
+
+  fastify.addHook('onRequest', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.ok('called')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('preParsing hooks should be able to modify the payload', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const stream = new Readable()
+
+    stream.receivedEncodedLength = parseInt(req.headers['content-length'], 10)
+    stream.push(JSON.stringify({ hello: 'another world' }))
+    stream.push(null)
+
+    return stream
+  })
+
+  fastify.post('/', function (request, reply) {
+    reply.send(request.body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'another world' })
+    testDone()
+  })
+})
+
+test('preParsing hooks should be able to supply statusCode', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const stream = new Readable({
+      read () {
+        const error = new Error('kaboom')
+        error.statusCode = 408
+        this.destroy(error)
+      }
+    })
+    stream.receivedEncodedLength = 20
+    return stream
+  })
+
+  fastify.addHook('onError', async (req, res, err) => {
+    t.assert.strictEqual(err.statusCode, 408)
+  })
+
+  fastify.post('/', function (request, reply) {
+    t.assert.fail('should not be called')
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 408)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
+      statusCode: 408,
+      error: 'Request Timeout',
+      message: 'kaboom'
+    })
+
+    testDone()
+  })
+})
+
+test('preParsing hooks should ignore statusCode 200 in stream error', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const stream = new Readable({
+      read () {
+        const error = new Error('kaboom')
+        error.statusCode = 200
+        this.destroy(error)
+      }
+    })
+    stream.receivedEncodedLength = 20
+    return stream
+  })
+
+  fastify.addHook('onError', async (req, res, err) => {
+    t.assert.strictEqual(err.statusCode, 400)
+  })
+
+  fastify.post('/', function (request, reply) {
+    t.assert.fail('should not be called')
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'kaboom'
+    })
+    testDone()
+  })
+})
+
+test('preParsing hooks should ignore non-number statusCode in stream error', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const stream = new Readable({
+      read () {
+        const error = new Error('kaboom')
+        error.statusCode = '418'
+        this.destroy(error)
+      }
+    })
+    stream.receivedEncodedLength = 20
+    return stream
+  })
+
+  fastify.addHook('onError', async (req, res, err) => {
+    t.assert.strictEqual(err.statusCode, 400)
+  })
+
+  fastify.post('/', function (request, reply) {
+    t.assert.fail('should not be called')
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'kaboom'
+    })
+    testDone()
+  })
+})
+
+test('preParsing hooks should default to statusCode 400 if stream error', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const stream = new Readable({
+      read () {
+        this.destroy(new Error('kaboom'))
+      }
+    })
+    stream.receivedEncodedLength = 20
+    return stream
+  })
+
+  fastify.addHook('onError', async (req, res, err) => {
+    t.assert.strictEqual(err.statusCode, 400)
+  })
+
+  fastify.post('/', function (request, reply) {
+    t.assert.fail('should not be called')
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'kaboom'
+    })
+    testDone()
+  })
+})
+
+test('preParsing hooks should handle errors', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    const e = new Error('kaboom')
+    e.statusCode = 501
+    throw e
+  })
+
+  fastify.post('/', function (request, reply) {
+    reply.send(request.body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 501)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { error: 'Not Implemented', message: 'kaboom', statusCode: 501 })
+    testDone()
+  })
+})
+
+test('preHandler hooks should be able to block a request', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    await reply.send('hello')
+  })
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.strictEqual(payload, 'hello')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('preValidation hooks should be able to block a request', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.addHook('preValidation', async (req, reply) => {
+    await reply.send('hello')
+  })
+
+  fastify.addHook('preValidation', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.strictEqual(payload, 'hello')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('preValidation hooks should be able to change request body before validation', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('preValidation', async (req, _reply) => {
+    const buff = Buffer.from(req.body.message, 'base64')
+    req.body = JSON.parse(buff.toString('utf-8'))
+    t.assert.ok('has been called')
+  })
+
+  fastify.post(
+    '/',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            foo: {
+              type: 'string'
+            },
+            bar: {
+              type: 'number'
+            }
+          },
+          required: ['foo', 'bar']
+        }
+      }
+    },
+    (req, reply) => {
+      reply.status(200).send('hello')
+    }
+  )
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    payload: {
+      message: Buffer.from(JSON.stringify({ foo: 'example', bar: 1 })).toString('base64')
+    }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('preSerialization hooks should be able to modify the payload', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('preSerialization', async (req, reply, payload) => {
+    return { hello: 'another world' }
+  })
+
+  fastify.get('/', function (request, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'another world' })
+    testDone()
+  })
+})
+
+test('preSerialization hooks should handle errors', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('preSerialization', async (req, reply, payload) => {
+    throw new Error('kaboom')
+  })
+
+  fastify.get('/', function (request, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { error: 'Internal Server Error', message: 'kaboom', statusCode: 500 })
+    testDone()
+  })
+})
+
+test('preValidation hooks should handle throwing null', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    t.assert.ok(error instanceof Error)
+    await reply.send(error)
+  })
+
+  fastify.addHook('preValidation', async () => {
+    // eslint-disable-next-line no-throw-literal
+    throw null
+  })
+
+  fastify.get('/', function (request, reply) { t.assert.fail('the handler must not be called') })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
+      error: 'Internal Server Error',
+      code: 'FST_ERR_SEND_UNDEFINED_ERR',
+      message: 'Undefined error has occurred',
+      statusCode: 500
+    })
+    testDone()
+  })
+})
+
+test('preValidation hooks should handle throwing a string', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('preValidation', async () => {
+    // eslint-disable-next-line no-throw-literal
+    throw 'this is an error'
+  })
+
+  fastify.get('/', function (request, reply) { t.assert.fail('the handler must not be called') })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, 'this is an error')
+    testDone()
+  })
+})
+
+test('onRequest hooks should be able to block a request (last hook)', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.addHook('onRequest', async (req, reply) => {
+    await reply.send('hello')
+  })
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.ok('called')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('preHandler hooks should be able to block a request (last hook)', (t, testDone) => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    await reply.send('hello')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.strictEqual(payload, 'hello')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
+  })
+})
+
+test('onRequest respond with a stream', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('onRequest', async (req, reply) => {
+    return new Promise((resolve, reject) => {
+      const stream = fs.createReadStream(__filename, 'utf8')
+      // stream.pipe(res)
+      // res.once('finish', resolve)
+      reply.send(stream).then(() => {
+        reply.raw.once('finish', () => resolve())
+      })
+    })
+  })
+
+  fastify.addHook('onRequest', async (req, res) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.ok('called')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
+  })
+})
+
+test('preHandler respond with a stream', (t, testDone) => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.addHook('onRequest', async (req, res) => {
+    t.assert.ok('called')
+  })
+
+  // we are calling `reply.send` inside the `preHandler` hook with a stream,
+  // this triggers the `onSend` hook event if `preHandler` has not yet finished
+  const order = [1, 2]
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    const stream = fs.createReadStream(__filename, 'utf8')
+    reply.raw.once('finish', () => {
+      t.assert.strictEqual(order.shift(), 2)
+    })
+    return reply.send(stream)
+  })
+
+  fastify.addHook('preHandler', async (req, reply) => {
+    t.assert.fail('this should not be called')
+  })
+
+  fastify.addHook('onSend', async (req, reply, payload) => {
+    t.assert.strictEqual(order.shift(), 1)
+    t.assert.strictEqual(typeof payload.pipe, 'function')
+  })
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    t.assert.ok('called')
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.fail('we should not be here')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
+  })
+})
+
+describe('Should log a warning if is an async function with `done`', () => {
+  test('2 arguments', t => {
+    const fastify = Fastify()
+
+    try {
+      fastify.addHook('onRequestAbort', async (req, done) => {
+        t.assert.fail('should have not be called')
+      })
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+  })
+
+  test('3 arguments', t => {
+    const fastify = Fastify()
+
+    try {
+      fastify.addHook('onRequest', async (req, reply, done) => {
+        t.assert.fail('should have not be called')
+      })
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+  })
+
+  test('4 arguments', t => {
+    const fastify = Fastify()
+
+    try {
+      fastify.addHook('onSend', async (req, reply, payload, done) => {
+        t.assert.fail('should have not be called')
+      })
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+    try {
+      fastify.addHook('preSerialization', async (req, reply, payload, done) => {
+        t.assert.fail('should have not be called')
+      })
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+    try {
+      fastify.addHook('onError', async (req, reply, payload, done) => {
+        t.assert.fail('should have not be called')
+      })
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+  })
+})
+
+test('early termination, onRequest async', async t => {
+  const app = Fastify()
+
+  app.addHook('onRequest', async (req, reply) => {
+    setImmediate(() => reply.send('hello world'))
+    return reply
+  })
+
+  app.get('/', (req, reply) => {
+    t.assert.fail('should not happen')
+  })
+
+  const res = await app.inject('/')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body.toString(), 'hello world')
+})
+
+test('The this should be the same of the encapsulation level', async t => {
+  const fastify = Fastify()
+
+  fastify.addHook('onRequest', async function (req, reply) {
+    if (req.raw.url === '/nested') {
+      t.assert.strictEqual(this.foo, 'bar')
+    } else {
+      t.assert.strictEqual(this.foo, undefined)
+    }
+  })
+
+  fastify.register(plugin)
+  fastify.get('/', (req, reply) => reply.send('ok'))
+
+  async function plugin (fastify, opts) {
+    fastify.decorate('foo', 'bar')
+    fastify.get('/nested', (req, reply) => reply.send('ok'))
+  }
+
+  await fastify.inject({ method: 'GET', path: '/' })
+  await fastify.inject({ method: 'GET', path: '/nested' })
+  await fastify.inject({ method: 'GET', path: '/' })
+  await fastify.inject({ method: 'GET', path: '/nested' })
+})
+
+describe('preSerializationEnd should handle errors if the serialize method throws', () => {
+  test('works with sync preSerialization', (t, testDone) => {
+    t.plan(3)
+    const fastify = Fastify()
+
+    fastify.addHook('preSerialization', (request, reply, payload, done) => {
+      t.assert.ok('called')
+      done(null, payload)
+    })
+
+    fastify.post('/', {
+      handler (req, reply) { reply.send({ notOk: true }) },
+      schema: { response: { 200: { required: ['ok'], properties: { ok: { type: 'boolean' } } } } }
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/'
+    }, (err, res) => {
+      t.assert.ifError(err)
+      t.assert.notEqual(res.statusCode, 200)
+      testDone()
+    })
+  })
+
+  test('works with async preSerialization', (t, testDone) => {
+    t.plan(3)
+    const fastify = Fastify()
+
+    fastify.addHook('preSerialization', async (request, reply, payload) => {
+      t.assert.ok('called')
+      return payload
+    })
+
+    fastify.post('/', {
+      handler (req, reply) { reply.send({ notOk: true }) },
+      schema: { response: { 200: { required: ['ok'], properties: { ok: { type: 'boolean' } } } } }
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/'
+    }, (err, res) => {
+      t.assert.ifError(err)
+      t.assert.notEqual(res.statusCode, 200)
+      testDone()
+    })
+  })
+})
+
+test('nested hooks to do not crash on 404', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/hello', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.register(async function (fastify) {
+    fastify.get('/something', (req, reply) => {
+      reply.callNotFound()
+    })
+
+    fastify.setNotFoundHandler(async (request, reply) => {
+      t.assert.ok('called')
+      reply.statusCode = 404
+      return { status: 'nested-not-found' }
+    })
+
+    fastify.setErrorHandler(async (error, request, reply) => {
+      t.assert.fail('should have not be called')
+      reply.statusCode = 500
+      return { status: 'nested-error', error }
+    })
+  }, { prefix: '/nested' })
+
+  fastify.setNotFoundHandler(async (request, reply) => {
+    t.assert.fail('should have not be called')
+    reply.statusCode = 404
+    return { status: 'not-found' }
+  })
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    t.assert.fail('should have not be called')
+    reply.statusCode = 500
+    return { status: 'error', error }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/nested/something'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    testDone()
+  })
+})
+
+test('Register an hook (preHandler) as route option should fail if mixing async and callback style', t => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preHandler: [
+          async (request, reply, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('preHandler mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onSend) as route option should fail if mixing async and callback style', t => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onSend: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('onSend mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (preSerialization) as route option should fail if mixing async and callback style', t => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preSerialization: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('preSerialization mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onError) as route option should fail if mixing async and callback style', t => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onError: [
+          async (request, reply, error, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('onError mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (preParsing) as route option should fail if mixing async and callback style', t => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        preParsing: [
+          async (request, reply, payload, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('preParsing mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})
+
+test('Register an hook (onRequestAbort) as route option should fail if mixing async and callback style', (t) => {
+  const fastify = Fastify()
+
+  try {
+    fastify.get(
+      '/',
+      {
+        onRequestAbort: [
+          async (request, done) => {
+            done()
+          }
+        ]
+      },
+      async (request, reply) => {
+        return { hello: 'world' }
+      }
+    )
+    t.assert.fail('onRequestAbort mixing async and callback style')
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+    t.assert.strictEqual(e.message, 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+  }
+})