fastify 5.3.3 → 5.5.0

package/test/hooks.test.js

@@ -1,8 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
-const sget = require('simple-get').concat
+const { test } = require('node:test')
 const stream = require('node:stream')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
@@ -12,89 +10,90 @@ const symbols = require('../lib/symbols.js')
 const payload = { hello: 'world' }
 const proxyquire = require('proxyquire')
 const { connect } = require('node:net')
-const { sleep, getServerUrl } = require('./helper')
+const { sleep } = require('./helper')
+const { waitForCb } = require('./toolkit.js')
 
 process.removeAllListeners('warning')
 
-test('hooks', t => {
-  t.plan(49)
+test('hooks', async t => {
+  t.plan(48)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   try {
     fastify.addHook('preHandler', function (request, reply, done) {
-      t.equal(request.test, 'the request is coming')
-      t.equal(reply.test, 'the reply has come')
+      t.assert.strictEqual(request.test, 'the request is coming')
+      t.assert.strictEqual(reply.test, 'the reply has come')
       if (request.raw.method === 'HEAD') {
         done(new Error('some error'))
       } else {
         done()
       }
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   try {
     fastify.addHook('preHandler', null)
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
-    t.equal(e.message, 'preHandler hook should be a function, instead got null')
-    t.pass()
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
+    t.assert.strictEqual(e.message, 'preHandler hook should be a function, instead got null')
+    t.assert.ok('should pass')
   }
 
   try {
     fastify.addHook('preParsing')
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
-    t.equal(e.message, 'preParsing hook should be a function, instead got undefined')
-    t.pass()
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
+    t.assert.strictEqual(e.message, 'preParsing hook should be a function, instead got undefined')
+    t.assert.ok('should pass')
   }
 
   try {
     fastify.addHook('preParsing', function (request, reply, payload, done) {
       request.preParsing = true
-      t.equal(request.test, 'the request is coming')
-      t.equal(reply.test, 'the reply has come')
+      t.assert.strictEqual(request.test, 'the request is coming')
+      t.assert.strictEqual(reply.test, 'the reply has come')
       done()
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   try {
     fastify.addHook('preParsing', function (request, reply, payload, done) {
       request.preParsing = true
-      t.equal(request.test, 'the request is coming')
-      t.equal(reply.test, 'the reply has come')
+      t.assert.strictEqual(request.test, 'the request is coming')
+      t.assert.strictEqual(reply.test, 'the reply has come')
       done()
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   try {
     fastify.addHook('preValidation', function (request, reply, done) {
-      t.equal(request.preParsing, true)
-      t.equal(request.test, 'the request is coming')
-      t.equal(reply.test, 'the reply has come')
+      t.assert.strictEqual(request.preParsing, true)
+      t.assert.strictEqual(request.test, 'the request is coming')
+      t.assert.strictEqual(reply.test, 'the reply has come')
       done()
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   try {
     fastify.addHook('preSerialization', function (request, reply, payload, done) {
-      t.ok('preSerialization called')
+      t.assert.ok('preSerialization called')
       done()
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   try {
@@ -107,18 +106,18 @@ test('hooks', t => {
         done()
       }
     })
-    t.pass()
+    t.assert.ok('should pass')
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   fastify.addHook('onResponse', function (request, reply, done) {
-    t.ok('onResponse called')
+    t.assert.ok('onResponse called')
     done()
   })
 
   fastify.addHook('onSend', function (req, reply, thePayload, done) {
-    t.ok('onSend called')
+    t.assert.ok('onSend called')
     done()
   })
 
@@ -126,12 +125,12 @@ test('hooks', t => {
     method: 'GET',
     url: '/',
     handler: function (req, reply) {
-      t.equal(req.test, 'the request is coming')
-      t.equal(reply.test, 'the reply has come')
+      t.assert.strictEqual(req.test, 'the request is coming')
+      t.assert.strictEqual(reply.test, 'the reply has come')
       reply.code(200).send(payload)
     },
     onResponse: function (req, reply, done) {
-      t.ok('onResponse inside hook')
+      t.assert.ok('onResponse inside hook')
     },
     response: {
       200: {
@@ -148,45 +147,32 @@ test('hooks', t => {
     reply.code(200).send(payload)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const getResult = await fetch(fastifyServer)
+  t.assert.ok(getResult.ok)
+  t.assert.strictEqual(getResult.status, 200)
+  const getBody = await getResult.text()
+  t.assert.strictEqual(getResult.headers.get('content-length'), '' + getBody.length)
+  t.assert.deepStrictEqual(JSON.parse(getBody), { hello: 'world' })
 
-    sget({
-      method: 'HEAD',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
+  const headResult = await fetch(fastifyServer, { method: 'HEAD' })
+  t.assert.ok(!headResult.ok)
+  t.assert.strictEqual(headResult.status, 500)
 
-    sget({
-      method: 'DELETE',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
-  })
+  const deleteResult = await fetch(fastifyServer, { method: 'DELETE' })
+  t.assert.ok(!deleteResult.ok)
+  t.assert.strictEqual(deleteResult.status, 500)
 })
 
-test('onRequest hook should support encapsulation / 1', t => {
+test('onRequest hook should support encapsulation / 1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRequest', (req, reply, done) => {
-      t.equal(req.raw.url, '/plugin')
+      t.assert.strictEqual(req.raw.url, '/plugin')
       done()
     })
 
@@ -202,17 +188,18 @@ test('onRequest hook should support encapsulation / 1', t => {
   })
 
   fastify.inject('/root', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-  })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
 
-  fastify.inject('/plugin', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    fastify.inject('/plugin', (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.statusCode, 200)
+      testDone()
+    })
   })
 })
 
-test('onRequest hook should support encapsulation / 2', (t) => {
+test('onRequest hook should support encapsulation / 2', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
   let pluginInstance
@@ -226,20 +213,21 @@ test('onRequest hook should support encapsulation / 2', (t) => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(fastify[symbols.kHooks].onRequest.length, 1)
-    t.equal(pluginInstance[symbols.kHooks].onRequest.length, 2)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify[symbols.kHooks].onRequest.length, 1)
+    t.assert.strictEqual(pluginInstance[symbols.kHooks].onRequest.length, 2)
+    testDone()
   })
 })
 
-test('onRequest hook should support encapsulation / 3', t => {
-  t.plan(20)
+test('onRequest hook should support encapsulation / 3', async t => {
+  t.plan(19)
   const fastify = Fastify()
   fastify.decorate('hello', 'world')
 
   fastify.addHook('onRequest', function (req, reply, done) {
-    t.ok(this.hello)
-    t.ok(this.hello2)
+    t.assert.ok(this.hello)
+    t.assert.ok(this.hello2)
     req.first = true
     done()
   })
@@ -247,124 +235,108 @@ test('onRequest hook should support encapsulation / 3', t => {
   fastify.decorate('hello2', 'world')
 
   fastify.get('/first', (req, reply) => {
-    t.ok(req.first)
-    t.notOk(req.second)
+    t.assert.ok(req.first)
+    t.assert.ok(!req.second)
     reply.send({ hello: 'world' })
   })
 
   fastify.register((instance, opts, done) => {
     instance.decorate('hello3', 'world')
     instance.addHook('onRequest', function (req, reply, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
-      t.ok(this.hello3)
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
+      t.assert.ok(this.hello3)
       req.second = true
       done()
     })
 
     instance.get('/second', (req, reply) => {
-      t.ok(req.first)
-      t.ok(req.second)
+      t.assert.ok(req.first)
+      t.assert.ok(req.second)
       reply.send({ hello: 'world' })
     })
 
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const firstResult = await fetch(fastifyServer + '/first', { method: 'GET' })
+  t.assert.ok(firstResult.ok)
+  t.assert.strictEqual(firstResult.status, 200)
+  const firstBody = await firstResult.text()
+  t.assert.strictEqual(firstResult.headers.get('content-length'), '' + firstBody.length)
+  t.assert.deepStrictEqual(JSON.parse(firstBody), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const secondResult = await fetch(fastifyServer + '/second', { method: 'GET' })
+  t.assert.ok(secondResult.ok)
+  t.assert.strictEqual(secondResult.status, 200)
+  const secondBody = await secondResult.text()
+  t.assert.strictEqual(secondResult.headers.get('content-length'), '' + secondBody.length)
+  t.assert.deepStrictEqual(JSON.parse(secondBody), { hello: 'world' })
 })
 
-test('preHandler hook should support encapsulation / 5', t => {
-  t.plan(17)
+test('preHandler hook should support encapsulation / 5', async t => {
+  t.plan(16)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.decorate('hello', 'world')
 
   fastify.addHook('preHandler', function (req, res, done) {
-    t.ok(this.hello)
+    t.assert.ok(this.hello)
     req.first = true
     done()
   })
 
   fastify.get('/first', (req, reply) => {
-    t.ok(req.first)
-    t.notOk(req.second)
+    t.assert.ok(req.first)
+    t.assert.ok(!req.second)
     reply.send({ hello: 'world' })
   })
 
   fastify.register((instance, opts, done) => {
     instance.decorate('hello2', 'world')
     instance.addHook('preHandler', function (req, res, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
       req.second = true
       done()
     })
 
     instance.get('/second', (req, reply) => {
-      t.ok(req.first)
-      t.ok(req.second)
+      t.assert.ok(req.first)
+      t.assert.ok(req.second)
       reply.send({ hello: 'world' })
     })
 
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const firstResult = await fetch(fastifyServer + '/first')
+  t.assert.ok(firstResult.ok)
+  t.assert.strictEqual(firstResult.status, 200)
+  const firstBody = await firstResult.text()
+  t.assert.strictEqual(firstResult.headers.get('content-length'), '' + firstBody.length)
+  t.assert.deepStrictEqual(JSON.parse(firstBody), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const secondResult = await fetch(fastifyServer + '/second')
+  t.assert.ok(secondResult.ok)
+  t.assert.strictEqual(secondResult.status, 200)
+  const secondBody = await secondResult.text()
+  t.assert.strictEqual(secondResult.headers.get('content-length'), '' + secondBody.length)
+  t.assert.deepStrictEqual(JSON.parse(secondBody), { hello: 'world' })
 })
 
-test('onRoute hook should be called / 1', t => {
+test('onRoute hook should be called / 1', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
-      t.pass()
+      t.assert.ok('should pass')
     })
     instance.get('/', opts, function (req, reply) {
       reply.send()
@@ -373,23 +345,24 @@ test('onRoute hook should be called / 1', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should be called / 2', t => {
+test('onRoute hook should be called / 2', (t, testDone) => {
   t.plan(5)
   let firstHandler = 0
   let secondHandler = 0
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.addHook('onRoute', (route) => {
-    t.pass()
+    t.assert.ok('should pass')
     firstHandler++
   })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
-      t.pass()
+      t.assert.ok('should pass')
       secondHandler++
     })
     instance.get('/', opts, function (req, reply) {
@@ -398,16 +371,17 @@ test('onRoute hook should be called / 2', t => {
     done()
   })
     .after(() => {
-      t.equal(firstHandler, 1)
-      t.equal(secondHandler, 1)
+      t.assert.strictEqual(firstHandler, 1)
+      t.assert.strictEqual(secondHandler, 1)
     })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should be called / 3', t => {
+test('onRoute hook should be called / 3', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
@@ -416,18 +390,18 @@ test('onRoute hook should be called / 3', t => {
   }
 
   fastify.addHook('onRoute', (route) => {
-    t.pass()
+    t.assert.ok('should pass')
   })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
-      t.pass()
+      t.assert.ok('should pass')
     })
     instance.get('/a', handler)
     done()
   })
     .after((err, done) => {
-      t.error(err)
+      t.assert.ifError(err)
       setTimeout(() => {
         fastify.get('/b', handler)
         done()
@@ -435,21 +409,22 @@ test('onRoute hook should be called / 3', t => {
     })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should be called (encapsulation support) / 4', t => {
+test('onRoute hook should be called (encapsulation support) / 4', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.addHook('onRoute', () => {
-    t.pass()
+    t.assert.ok('should pass')
   })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
-      t.pass()
+      t.assert.ok('should pass')
     })
     instance.get('/nested', opts, function (req, reply) {
       reply.send()
@@ -462,11 +437,12 @@ test('onRoute hook should be called (encapsulation support) / 4', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should be called (encapsulation support) / 5', t => {
+test('onRoute hook should be called (encapsulation support) / 5', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
@@ -476,7 +452,7 @@ test('onRoute hook should be called (encapsulation support) / 5', t => {
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', () => {
-      t.pass()
+      t.assert.ok('should pass')
     })
     instance.get('/nested', opts, function (req, reply) {
       reply.send()
@@ -489,11 +465,12 @@ test('onRoute hook should be called (encapsulation support) / 5', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should be called (encapsulation support) / 6', t => {
+test('onRoute hook should be called (encapsulation support) / 6', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
@@ -502,25 +479,26 @@ test('onRoute hook should be called (encapsulation support) / 6', t => {
   })
 
   fastify.addHook('onRoute', () => {
-    t.fail('This should not be called')
+    t.assert.fail('This should not be called')
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute should keep the context', t => {
+test('onRoute should keep the context', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register((instance, opts, done) => {
     instance.decorate('test', true)
     instance.addHook('onRoute', onRoute)
-    t.ok(instance.prototype === fastify.prototype)
+    t.assert.ok(instance.prototype === fastify.prototype)
 
     function onRoute (route) {
-      t.ok(this.test)
-      t.equal(this, instance)
+      t.assert.ok(this.test)
+      t.assert.strictEqual(this, instance)
     }
 
     instance.get('/', opts, function (req, reply) {
@@ -531,26 +509,27 @@ test('onRoute should keep the context', t => {
   })
 
   fastify.close((err) => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should pass correct route', t => {
+test('onRoute hook should pass correct route', (t, testDone) => {
   t.plan(9)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.addHook('onRoute', (route) => {
-    t.equal(route.method, 'GET')
-    t.equal(route.url, '/')
-    t.equal(route.path, '/')
-    t.equal(route.routePath, '/')
+    t.assert.strictEqual(route.method, 'GET')
+    t.assert.strictEqual(route.url, '/')
+    t.assert.strictEqual(route.path, '/')
+    t.assert.strictEqual(route.routePath, '/')
   })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
-      t.equal(route.method, 'GET')
-      t.equal(route.url, '/')
-      t.equal(route.path, '/')
-      t.equal(route.routePath, '/')
+      t.assert.strictEqual(route.method, 'GET')
+      t.assert.strictEqual(route.url, '/')
+      t.assert.strictEqual(route.path, '/')
+      t.assert.strictEqual(route.routePath, '/')
     })
     instance.get('/', opts, function (req, reply) {
       reply.send()
@@ -559,28 +538,29 @@ test('onRoute hook should pass correct route', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should pass correct route with custom prefix', t => {
+test('onRoute hook should pass correct route with custom prefix', (t, testDone) => {
   t.plan(11)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.addHook('onRoute', function (route) {
-    t.equal(route.method, 'GET')
-    t.equal(route.url, '/v1/foo')
-    t.equal(route.path, '/v1/foo')
-    t.equal(route.routePath, '/foo')
-    t.equal(route.prefix, '/v1')
+    t.assert.strictEqual(route.method, 'GET')
+    t.assert.strictEqual(route.url, '/v1/foo')
+    t.assert.strictEqual(route.path, '/v1/foo')
+    t.assert.strictEqual(route.routePath, '/foo')
+    t.assert.strictEqual(route.prefix, '/v1')
   })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', function (route) {
-      t.equal(route.method, 'GET')
-      t.equal(route.url, '/v1/foo')
-      t.equal(route.path, '/v1/foo')
-      t.equal(route.routePath, '/foo')
-      t.equal(route.prefix, '/v1')
+      t.assert.strictEqual(route.method, 'GET')
+      t.assert.strictEqual(route.url, '/v1/foo')
+      t.assert.strictEqual(route.path, '/v1/foo')
+      t.assert.strictEqual(route.routePath, '/foo')
+      t.assert.strictEqual(route.prefix, '/v1')
     })
     instance.get('/foo', opts, function (req, reply) {
       reply.send()
@@ -589,20 +569,21 @@ test('onRoute hook should pass correct route with custom prefix', t => {
   }, { prefix: '/v1' })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should pass correct route with custom options', t => {
+test('onRoute hook should pass correct route with custom options', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', function (route) {
-      t.equal(route.method, 'GET')
-      t.equal(route.url, '/foo')
-      t.equal(route.logLevel, 'info')
-      t.equal(route.bodyLimit, 100)
-      t.type(route.logSerializers.test, 'function')
+      t.assert.strictEqual(route.method, 'GET')
+      t.assert.strictEqual(route.url, '/foo')
+      t.assert.strictEqual(route.logLevel, 'info')
+      t.assert.strictEqual(route.bodyLimit, 100)
+      t.assert.ok(typeof route.logSerializers.test === 'function')
     })
     instance.get('/foo', {
       logLevel: 'info',
@@ -617,19 +598,20 @@ test('onRoute hook should pass correct route with custom options', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should receive any route option', t => {
+test('onRoute hook should receive any route option', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', function (route) {
-      t.equal(route.method, 'GET')
-      t.equal(route.url, '/foo')
-      t.equal(route.routePath, '/foo')
-      t.equal(route.auth, 'basic')
+      t.assert.strictEqual(route.method, 'GET')
+      t.assert.strictEqual(route.url, '/foo')
+      t.assert.strictEqual(route.routePath, '/foo')
+      t.assert.strictEqual(route.auth, 'basic')
     })
     instance.get('/foo', { auth: 'basic' }, function (req, reply) {
       reply.send()
@@ -638,19 +620,20 @@ test('onRoute hook should receive any route option', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should preserve system route configuration', t => {
+test('onRoute hook should preserve system route configuration', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', function (route) {
-      t.equal(route.method, 'GET')
-      t.equal(route.url, '/foo')
-      t.equal(route.routePath, '/foo')
-      t.equal(route.handler.length, 2)
+      t.assert.strictEqual(route.method, 'GET')
+      t.assert.strictEqual(route.url, '/foo')
+      t.assert.strictEqual(route.routePath, '/foo')
+      t.assert.strictEqual(route.handler.length, 2)
     })
     instance.get('/foo', { url: '/bar', method: 'POST' }, function (req, reply) {
       reply.send()
@@ -659,11 +642,12 @@ test('onRoute hook should preserve system route configuration', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRoute hook should preserve handler function in options of shorthand route system configuration', t => {
+test('onRoute hook should preserve handler function in options of shorthand route system configuration', (t, testDone) => {
   t.plan(2)
 
   const handler = (req, reply) => {}
@@ -671,19 +655,20 @@ test('onRoute hook should preserve handler function in options of shorthand rout
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', function (route) {
-      t.equal(route.handler, handler)
+      t.assert.strictEqual(route.handler, handler)
     })
     instance.get('/foo', { handler })
     done()
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
 // issue ref https://github.com/fastify/fastify-compress/issues/140
-test('onRoute hook should be called once when prefixTrailingSlash', t => {
+test('onRoute hook should be called once when prefixTrailingSlash', (t, testDone) => {
   t.plan(3)
 
   let onRouteCalled = 0
@@ -719,21 +704,22 @@ test('onRoute hook should be called once when prefixTrailingSlash', t => {
   }, { prefix: '/prefix' })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(onRouteCalled, 1) // onRoute hook was called once
-    t.equal(routePatched, 1) // and plugin acted once and avoided redundant route patching
+    t.assert.ifError(err)
+    t.assert.strictEqual(onRouteCalled, 1) // onRoute hook was called once
+    t.assert.strictEqual(routePatched, 1) // and plugin acted once and avoided redundant route patching
+    testDone()
   })
 })
 
-test('onRoute hook should able to change the route url', t => {
-  t.plan(5)
+test('onRoute hook should able to change the route url', async t => {
+  t.plan(4)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onRoute', (route) => {
-      t.equal(route.url, '/foo')
+      t.assert.strictEqual(route.url, '/foo')
       route.url = encodeURI(route.url)
     })
 
@@ -744,21 +730,15 @@ test('onRoute hook should able to change the route url', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + encodeURI('/foo')
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), 'here /foo')
-    })
-  })
+  const result = await fetch(fastifyServer + encodeURI('/foo'))
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(await result.text(), 'here /foo')
 })
 
-test('onRoute hook that throws should be caught', t => {
+test('onRoute hook that throws should be caught', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
@@ -772,30 +752,30 @@ test('onRoute hook that throws should be caught', t => {
         reply.send()
       })
 
-      t.fail('onRoute should throw sync if error')
+      t.assert.fail('onRoute should throw sync if error')
     } catch (error) {
-      t.ok(error)
+      t.assert.ok(error)
     }
 
     done()
   })
 
-  fastify.ready()
+  fastify.ready(testDone)
 })
 
-test('onRoute hook with many prefix', t => {
+test('onRoute hook with many prefix', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify({ exposeHeadRoutes: false })
   const handler = (req, reply) => { reply.send({}) }
 
   const onRouteChecks = [
-    { routePath: '/anotherPath', prefix: '/two', url: '/one/two/anotherPath' },
+    { routePath: '/anotherPath', prefix: '/one/two', url: '/one/two/anotherPath' },
     { routePath: '/aPath', prefix: '/one', url: '/one/aPath' }
   ]
 
   fastify.register((instance, opts, done) => {
-    instance.addHook('onRoute', (route) => {
-      t.match(route, onRouteChecks.pop())
+    instance.addHook('onRoute', ({ routePath, prefix, url }) => {
+      t.assert.deepStrictEqual({ routePath, prefix, url }, onRouteChecks.pop())
     })
     instance.route({ method: 'GET', url: '/aPath', handler })
 
@@ -806,15 +786,18 @@ test('onRoute hook with many prefix', t => {
     done()
   }, { prefix: '/one' })
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('onRoute hook should not be called when it registered after route', t => {
+test('onRoute hook should not be called when it registered after route', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
   fastify.addHook('onRoute', () => {
-    t.pass()
+    t.assert.ok('should pass')
   })
 
   fastify.get('/', function (req, reply) {
@@ -822,15 +805,16 @@ test('onRoute hook should not be called when it registered after route', t => {
   })
 
   fastify.addHook('onRoute', () => {
-    t.fail('should not be called')
+    t.assert.fail('should not be called')
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onResponse hook should log request error', t => {
+test('onResponse hook should log request error', (t, testDone) => {
   t.plan(4)
 
   let fastify = null
@@ -843,12 +827,12 @@ test('onResponse hook should log request error', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 
   logStream.once('data', line => {
-    t.equal(line.msg, 'request errored')
-    t.equal(line.level, 50)
+    t.assert.strictEqual(line.msg, 'request errored')
+    t.assert.strictEqual(line.level, 50)
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
@@ -860,18 +844,19 @@ test('onResponse hook should log request error', t => {
   })
 
   fastify.inject('/root', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('onResponse hook should support encapsulation / 1', t => {
+test('onResponse hook should support encapsulation / 1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onResponse', (request, reply, done) => {
-      t.equal(reply.plugin, true)
+      t.assert.strictEqual(reply.plugin, true)
       done()
     })
 
@@ -888,17 +873,18 @@ test('onResponse hook should support encapsulation / 1', t => {
   })
 
   fastify.inject('/root', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject('/plugin', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('onResponse hook should support encapsulation / 2', t => {
+test('onResponse hook should support encapsulation / 2', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
   let pluginInstance
@@ -912,21 +898,22 @@ test('onResponse hook should support encapsulation / 2', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(fastify[symbols.kHooks].onResponse.length, 1)
-    t.equal(pluginInstance[symbols.kHooks].onResponse.length, 2)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify[symbols.kHooks].onResponse.length, 1)
+    t.assert.strictEqual(pluginInstance[symbols.kHooks].onResponse.length, 2)
+    testDone()
   })
 })
 
-test('onResponse hook should support encapsulation / 3', t => {
-  t.plan(16)
+test('onResponse hook should support encapsulation / 3', async t => {
+  t.plan(15)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.decorate('hello', 'world')
 
   fastify.addHook('onResponse', function (request, reply, done) {
-    t.ok(this.hello)
-    t.ok('onResponse called')
+    t.assert.ok(this.hello)
+    t.assert.ok('onResponse called')
     done()
   })
 
@@ -937,9 +924,9 @@ test('onResponse hook should support encapsulation / 3', t => {
   fastify.register((instance, opts, done) => {
     instance.decorate('hello2', 'world')
     instance.addHook('onResponse', function (request, reply, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
-      t.ok('onResponse called')
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
+      t.assert.ok('onResponse called')
       done()
     })
 
@@ -950,32 +937,24 @@ test('onResponse hook should support encapsulation / 3', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const firstResult = await fetch(fastifyServer + '/first', { method: 'GET' })
+  t.assert.ok(firstResult.ok)
+  t.assert.strictEqual(firstResult.status, 200)
+  const firstBody = await firstResult.text()
+  t.assert.strictEqual(firstResult.headers.get('content-length'), '' + firstBody.length)
+  t.assert.deepStrictEqual(JSON.parse(firstBody), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const secondResult = await fetch(fastifyServer + '/second')
+  t.assert.ok(secondResult.ok)
+  t.assert.strictEqual(secondResult.status, 200)
+  const secondBody = await secondResult.text()
+  t.assert.strictEqual(secondResult.headers.get('content-length'), '' + secondBody.length)
+  t.assert.deepStrictEqual(JSON.parse(secondBody), { hello: 'world' })
 })
 
-test('onSend hook should support encapsulation / 1', t => {
+test('onSend hook should support encapsulation / 1', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
   let pluginInstance
@@ -989,21 +968,22 @@ test('onSend hook should support encapsulation / 1', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(fastify[symbols.kHooks].onSend.length, 1)
-    t.equal(pluginInstance[symbols.kHooks].onSend.length, 2)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify[symbols.kHooks].onSend.length, 1)
+    t.assert.strictEqual(pluginInstance[symbols.kHooks].onSend.length, 2)
+    testDone()
   })
 })
 
-test('onSend hook should support encapsulation / 2', t => {
-  t.plan(16)
+test('onSend hook should support encapsulation / 2', async t => {
+  t.plan(15)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.decorate('hello', 'world')
 
   fastify.addHook('onSend', function (request, reply, thePayload, done) {
-    t.ok(this.hello)
-    t.ok('onSend called')
+    t.assert.ok(this.hello)
+    t.assert.ok('onSend called')
     done()
   })
 
@@ -1014,9 +994,9 @@ test('onSend hook should support encapsulation / 2', t => {
   fastify.register((instance, opts, done) => {
     instance.decorate('hello2', 'world')
     instance.addHook('onSend', function (request, reply, thePayload, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
-      t.ok('onSend called')
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
+      t.assert.ok('onSend called')
       done()
     })
 
@@ -1027,32 +1007,24 @@ test('onSend hook should support encapsulation / 2', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const firstResult = await fetch(fastifyServer + '/first')
+  t.assert.ok(firstResult.ok)
+  t.assert.strictEqual(firstResult.status, 200)
+  const firstBody = await firstResult.text()
+  t.assert.strictEqual(firstResult.headers.get('content-length'), '' + firstBody.length)
+  t.assert.deepStrictEqual(JSON.parse(firstBody), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const secondResult = await fetch(fastifyServer + '/second')
+  t.assert.ok(secondResult.ok)
+  t.assert.strictEqual(secondResult.status, 200)
+  const secondBody = await secondResult.text()
+  t.assert.strictEqual(secondResult.headers.get('content-length'), '' + secondBody.length)
+  t.assert.deepStrictEqual(JSON.parse(secondBody), { hello: 'world' })
 })
 
-test('onSend hook is called after payload is serialized and headers are set', t => {
+test('onSend hook is called after payload is serialized and headers are set', (t, testDone) => {
   t.plan(30)
   const fastify = Fastify()
 
@@ -1060,8 +1032,8 @@ test('onSend hook is called after payload is serialized and headers are set', t
     const thePayload = { hello: 'world' }
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.same(JSON.parse(payload), thePayload)
-      t.equal(reply[symbols.kReplyHeaders]['content-type'], 'application/json; charset=utf-8')
+      t.assert.deepStrictEqual(JSON.parse(payload), thePayload)
+      t.assert.strictEqual(reply[symbols.kReplyHeaders]['content-type'], 'application/json; charset=utf-8')
       done()
     })
 
@@ -1074,8 +1046,8 @@ test('onSend hook is called after payload is serialized and headers are set', t
 
   fastify.register((instance, opts, done) => {
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(payload, 'some text')
-      t.equal(reply[symbols.kReplyHeaders]['content-type'], 'text/plain; charset=utf-8')
+      t.assert.strictEqual(payload, 'some text')
+      t.assert.strictEqual(reply[symbols.kReplyHeaders]['content-type'], 'text/plain; charset=utf-8')
       done()
     })
 
@@ -1090,8 +1062,8 @@ test('onSend hook is called after payload is serialized and headers are set', t
     const thePayload = Buffer.from('buffer payload')
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(payload, thePayload)
-      t.equal(reply[symbols.kReplyHeaders]['content-type'], 'application/octet-stream')
+      t.assert.strictEqual(payload, thePayload)
+      t.assert.strictEqual(reply[symbols.kReplyHeaders]['content-type'], 'application/octet-stream')
       done()
     })
 
@@ -1112,8 +1084,8 @@ test('onSend hook is called after payload is serialized and headers are set', t
     })
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(payload, thePayload)
-      t.equal(reply[symbols.kReplyHeaders]['content-type'], 'application/octet-stream')
+      t.assert.strictEqual(payload, thePayload)
+      t.assert.strictEqual(reply[symbols.kReplyHeaders]['content-type'], 'application/octet-stream')
       done()
     })
 
@@ -1129,8 +1101,8 @@ test('onSend hook is called after payload is serialized and headers are set', t
     const serializedPayload = 'serialized'
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(payload, serializedPayload)
-      t.equal(reply[symbols.kReplyHeaders]['content-type'], 'text/custom')
+      t.assert.strictEqual(payload, serializedPayload)
+      t.assert.strictEqual(reply[symbols.kReplyHeaders]['content-type'], 'text/custom')
       done()
     })
 
@@ -1144,58 +1116,65 @@ test('onSend hook is called after payload is serialized and headers are set', t
     done()
   })
 
+  const completion = waitForCb({ steps: 5 })
   fastify.inject({
     method: 'GET',
     url: '/json'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.headers['content-length'], '17')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    completion.stepIn()
   })
 
   fastify.inject({
     method: 'GET',
     url: '/text'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.payload, 'some text')
-    t.equal(res.headers['content-length'], '9')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.payload, 'some text')
+    t.assert.strictEqual(res.headers['content-length'], '9')
+    completion.stepIn()
   })
 
   fastify.inject({
     method: 'GET',
     url: '/buffer'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.payload, 'buffer payload')
-    t.equal(res.headers['content-length'], '14')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.payload, 'buffer payload')
+    t.assert.strictEqual(res.headers['content-length'], '14')
+    completion.stepIn()
   })
 
   fastify.inject({
     method: 'GET',
     url: '/stream'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.payload, 'stream payload')
-    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.payload, 'stream payload')
+    t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+    completion.stepIn()
   })
 
   fastify.inject({
     method: 'GET',
     url: '/custom-serializer'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.payload, 'serialized')
-    t.equal(res.headers['content-type'], 'text/custom')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.payload, 'serialized')
+    t.assert.strictEqual(res.headers['content-type'], 'text/custom')
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('modify payload', t => {
+test('modify payload', (t, testDone) => {
   t.plan(10)
   const fastify = Fastify()
   const payload = { hello: 'world' }
@@ -1203,21 +1182,21 @@ test('modify payload', t => {
   const anotherPayload = '"winter is coming"'
 
   fastify.addHook('onSend', function (request, reply, thePayload, done) {
-    t.ok('onSend called')
-    t.same(JSON.parse(thePayload), payload)
+    t.assert.ok('onSend called')
+    t.assert.deepStrictEqual(JSON.parse(thePayload), payload)
     thePayload = thePayload.replace('world', 'modified')
     done(null, thePayload)
   })
 
   fastify.addHook('onSend', function (request, reply, thePayload, done) {
-    t.ok('onSend called')
-    t.same(JSON.parse(thePayload), modifiedPayload)
+    t.assert.ok('onSend called')
+    t.assert.deepStrictEqual(JSON.parse(thePayload), modifiedPayload)
     done(null, anotherPayload)
   })
 
   fastify.addHook('onSend', function (request, reply, thePayload, done) {
-    t.ok('onSend called')
-    t.equal(thePayload, anotherPayload)
+    t.assert.ok('onSend called')
+    t.assert.strictEqual(thePayload, anotherPayload)
     done()
   })
 
@@ -1229,19 +1208,20 @@ test('modify payload', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, anotherPayload)
-    t.equal(res.statusCode, 200)
-    t.equal(res.headers['content-length'], '18')
+    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('clear payload', t => {
+test('clear payload', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
   fastify.addHook('onSend', function (request, reply, payload, done) {
-    t.ok('onSend called')
+    t.assert.ok('onSend called')
     reply.code(304)
     done(null, null)
   })
@@ -1254,25 +1234,26 @@ test('clear payload', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 304)
-    t.equal(res.payload, '')
-    t.equal(res.headers['content-length'], undefined)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 304)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    testDone()
   })
 })
 
-test('onSend hook throws', t => {
-  t.plan(11)
+test('onSend hook throws', async t => {
+  t.plan(10)
   const Fastify = proxyquire('..', {
     './lib/schemas.js': {
       getSchemaSerializer: (param1, param2, param3) => {
-        t.equal(param3, 'application/json; charset=utf-8', 'param3 should be "application/json; charset=utf-8"')
+        t.assert.strictEqual(param3, 'application/json; charset=utf-8', 'param3 should be "application/json; charset=utf-8"')
       }
     }
   })
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.addHook('onSend', function (request, reply, payload, done) {
     if (request.raw.method === 'DELETE') {
       done(new Error('some error'))
@@ -1322,43 +1303,29 @@ test('onSend hook throws', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-    sget({
-      method: 'POST',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
-    sget({
-      method: 'DELETE',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
-    sget({
-      method: 'PUT',
-      url: 'http://127.0.0.1:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
-  })
-})
-
-test('onSend hook should receive valid request and reply objects if onRequest hook fails', t => {
+  const getResult = await fetch(fastifyServer)
+  t.assert.ok(getResult.ok)
+  t.assert.strictEqual(getResult.status, 200)
+  const getBody = await getResult.text()
+  t.assert.strictEqual(getResult.headers.get('content-length'), '' + getBody.length)
+  t.assert.deepStrictEqual(JSON.parse(getBody), { hello: 'world' })
+
+  const postResult = await fetch(fastifyServer, { method: 'POST' })
+  t.assert.ok(!postResult.ok)
+  t.assert.strictEqual(postResult.status, 500)
+
+  const deleteResult = await fetch(fastifyServer, { method: 'DELETE' })
+  t.assert.ok(!deleteResult.ok)
+  t.assert.strictEqual(deleteResult.status, 500)
+
+  const putResult = await fetch(fastifyServer, { method: 'PUT' })
+  t.assert.ok(!putResult.ok)
+  t.assert.strictEqual(putResult.status, 500)
+})
+
+test('onSend hook should receive valid request and reply objects if onRequest hook fails', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1370,8 +1337,8 @@ test('onSend hook should receive valid request and reply objects if onRequest ho
   })
 
   fastify.addHook('onSend', function (request, reply, payload, done) {
-    t.equal(request.testDecorator, 'testDecoratorVal')
-    t.equal(reply.testDecorator, 'testDecoratorVal')
+    t.assert.strictEqual(request.testDecorator, 'testDecoratorVal')
+    t.assert.strictEqual(reply.testDecorator, 'testDecoratorVal')
     done()
   })
 
@@ -1383,12 +1350,13 @@ test('onSend hook should receive valid request and reply objects if onRequest ho
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    testDone()
   })
 })
 
-test('onSend hook should receive valid request and reply objects if a custom content type parser fails', t => {
+test('onSend hook should receive valid request and reply objects if a custom content type parser fails', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1400,8 +1368,8 @@ test('onSend hook should receive valid request and reply objects if a custom con
   })
 
   fastify.addHook('onSend', function (request, reply, payload, done) {
-    t.equal(request.testDecorator, 'testDecoratorVal')
-    t.equal(reply.testDecorator, 'testDecoratorVal')
+    t.assert.strictEqual(request.testDecorator, 'testDecoratorVal')
+    t.assert.strictEqual(reply.testDecorator, 'testDecoratorVal')
     done()
   })
 
@@ -1414,12 +1382,13 @@ test('onSend hook should receive valid request and reply objects if a custom con
     url: '/',
     payload: 'body'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    testDone()
   })
 })
 
-test('Content-Length header should be updated if onSend hook modifies the payload', t => {
+test('Content-Length header should be updated if onSend hook modifies the payload', (t, testDone) => {
   t.plan(2)
 
   const instance = Fastify()
@@ -1435,36 +1404,37 @@ test('Content-Length header should be updated if onSend hook modifies the payloa
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
+    t.assert.ifError(err)
     const payloadLength = Buffer.byteLength(res.body)
     const contentLength = Number(res.headers['content-length'])
 
-    t.equal(payloadLength, contentLength)
+    t.assert.strictEqual(payloadLength, contentLength)
+    testDone()
   })
 })
 
-test('cannot add hook after binding', t => {
-  t.plan(2)
+test('cannot add hook after binding', (t, testDone) => {
+  t.plan(1)
   const instance = Fastify()
-  t.teardown(() => instance.close())
+  t.after(() => instance.close())
 
   instance.get('/', function (request, reply) {
     reply.send({ hello: 'world' })
   })
 
   instance.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     try {
       instance.addHook('onRequest', () => {})
-      t.fail()
+      t.assert.fail()
     } catch (e) {
-      t.pass()
+      testDone()
     }
   })
 })
 
-test('onRequest hooks should be able to block a request', t => {
+test('onRequest hooks should be able to block a request', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1474,38 +1444,39 @@ test('onRequest hooks should be able to block a request', t => {
   })
 
   fastify.addHook('onRequest', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    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 => {
+test('preValidation hooks should be able to block a request', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1515,38 +1486,39 @@ test('preValidation hooks should be able to block a request', t => {
   })
 
   fastify.addHook('preValidation', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    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 => {
+test('preValidation hooks should be able to change request body before validation', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1575,7 +1547,7 @@ test('preValidation hooks should be able to change request body before validatio
       }
     },
     (req, reply) => {
-      t.pass()
+      t.assert.ok('should pass')
       reply.status(200).send('hello')
     }
   )
@@ -1587,13 +1559,14 @@ test('preValidation hooks should be able to change request body before validatio
       message: Buffer.from(JSON.stringify({ foo: 'example', bar: 1 })).toString('base64')
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('preParsing hooks should be able to block a request', t => {
+test('preParsing hooks should be able to block a request', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1603,38 +1576,39 @@ test('preParsing hooks should be able to block a request', t => {
   })
 
   fastify.addHook('preParsing', (req, reply, payload, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    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', t => {
+test('preHandler hooks should be able to block a request', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1644,34 +1618,35 @@ test('preHandler hooks should be able to block a request', t => {
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.equal(payload, 'hello')
+    t.assert.strictEqual(payload, 'hello')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('onRequest hooks should be able to block a request (last hook)', t => {
+test('onRequest hooks should be able to block a request (last hook)', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1681,34 +1656,35 @@ test('onRequest hooks should be able to block a request (last hook)', t => {
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    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 => {
+test('preHandler hooks should be able to block a request (last hook)', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -1718,30 +1694,31 @@ test('preHandler hooks should be able to block a request (last hook)', t => {
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.equal(payload, 'hello')
+    t.assert.strictEqual(payload, 'hello')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('preParsing hooks should handle errors', t => {
+test('preParsing hooks should handle errors', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -1760,13 +1737,14 @@ test('preParsing hooks should handle errors', t => {
     url: '/',
     payload: { hello: 'world' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 501)
-    t.same(JSON.parse(res.payload), { error: 'Not Implemented', message: 'kaboom', statusCode: 501 })
+    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('onRequest respond with a stream', t => {
+test('onRequest respond with a stream', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1778,42 +1756,43 @@ test('onRequest respond with a stream', t => {
   })
 
   fastify.addHook('onRequest', (req, res, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('preHandler respond with a stream', t => {
+test('preHandler respond with a stream', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
 
   fastify.addHook('onRequest', (req, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
@@ -1825,46 +1804,47 @@ test('preHandler respond with a stream', t => {
     const stream = fs.createReadStream(__filename, 'utf8')
     reply.send(stream)
     reply.raw.once('finish', () => {
-      t.equal(order.shift(), 2)
+      t.assert.strictEqual(order.shift(), 2)
       done()
     })
   })
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.equal(order.shift(), 1)
-    t.equal(typeof payload.pipe, 'function')
+    t.assert.strictEqual(order.shift(), 1)
+    t.assert.strictEqual(typeof payload.pipe, 'function')
     done()
   })
 
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called')
+    t.assert.ok('called')
     done()
   })
 
   fastify.get('/', function (request, reply) {
-    t.fail('we should not be here')
+    t.assert.fail('we should not be here')
   })
 
   fastify.inject({
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Register an hook after a plugin inside a plugin', t => {
+test('Register an hook after a plugin inside a plugin', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -1877,12 +1857,12 @@ test('Register an hook after a plugin inside a plugin', t => {
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -1893,25 +1873,26 @@ test('Register an hook after a plugin inside a plugin', t => {
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('Register an hook after a plugin inside a plugin (with preHandler option)', t => {
+test('Register an hook after a plugin inside a plugin (with preHandler option)', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.get('/', {
       preHandler: (req, reply, done) => {
-        t.ok('called')
+        t.assert.ok('called')
         done()
       }
     }, function (request, reply) {
@@ -1923,12 +1904,12 @@ test('Register an hook after a plugin inside a plugin (with preHandler option)',
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('preHandler', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -1939,13 +1920,14 @@ test('Register an hook after a plugin inside a plugin (with preHandler option)',
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('Register hooks inside a plugin after an encapsulated plugin', t => {
+test('Register hooks inside a plugin after an encapsulated plugin', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
 
@@ -1959,22 +1941,22 @@ test('Register hooks inside a plugin after an encapsulated plugin', t => {
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onRequest', function (req, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('preHandler', function (request, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onResponse', function (request, reply, done) {
-      t.ok('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -1982,31 +1964,32 @@ test('Register hooks inside a plugin after an encapsulated plugin', t => {
   }))
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('onRequest hooks should run in the order in which they are defined', t => {
+test('onRequest hooks should run in the order in which they are defined', (t, testDone) => {
   t.plan(9)
   const fastify = Fastify()
 
   fastify.register(function (instance, opts, done) {
     instance.addHook('onRequest', function (req, reply, done) {
-      t.equal(req.previous, undefined)
+      t.assert.strictEqual(req.previous, undefined)
       req.previous = 1
       done()
     })
 
     instance.get('/', function (request, reply) {
-      t.equal(request.previous, 5)
+      t.assert.strictEqual(request.previous, 5)
       reply.send({ hello: 'world' })
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onRequest', function (req, reply, done) {
-        t.equal(req.previous, 1)
+        t.assert.strictEqual(req.previous, 1)
         req.previous = 2
         done()
       })
@@ -2018,14 +2001,14 @@ test('onRequest hooks should run in the order in which they are defined', t => {
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onRequest', function (req, reply, done) {
-      t.equal(req.previous, 2)
+      t.assert.strictEqual(req.previous, 2)
       req.previous = 3
       done()
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onRequest', function (req, reply, done) {
-        t.equal(req.previous, 3)
+        t.assert.strictEqual(req.previous, 3)
         req.previous = 4
         done()
       })
@@ -2033,7 +2016,7 @@ test('onRequest hooks should run in the order in which they are defined', t => {
     }))
 
     instance.addHook('onRequest', function (req, reply, done) {
-      t.equal(req.previous, 4)
+      t.assert.strictEqual(req.previous, 4)
       req.previous = 5
       done()
     })
@@ -2042,31 +2025,32 @@ test('onRequest hooks should run in the order in which they are defined', t => {
   }))
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('preHandler hooks should run in the order in which they are defined', t => {
+test('preHandler hooks should run in the order in which they are defined', (t, testDone) => {
   t.plan(9)
   const fastify = Fastify()
 
   fastify.register(function (instance, opts, done) {
     instance.addHook('preHandler', function (request, reply, done) {
-      t.equal(request.previous, undefined)
+      t.assert.strictEqual(request.previous, undefined)
       request.previous = 1
       done()
     })
 
     instance.get('/', function (request, reply) {
-      t.equal(request.previous, 5)
+      t.assert.strictEqual(request.previous, 5)
       reply.send({ hello: 'world' })
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('preHandler', function (request, reply, done) {
-        t.equal(request.previous, 1)
+        t.assert.strictEqual(request.previous, 1)
         request.previous = 2
         done()
       })
@@ -2078,14 +2062,14 @@ test('preHandler hooks should run in the order in which they are defined', t =>
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('preHandler', function (request, reply, done) {
-      t.equal(request.previous, 2)
+      t.assert.strictEqual(request.previous, 2)
       request.previous = 3
       done()
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('preHandler', function (request, reply, done) {
-        t.equal(request.previous, 3)
+        t.assert.strictEqual(request.previous, 3)
         request.previous = 4
         done()
       })
@@ -2093,7 +2077,7 @@ test('preHandler hooks should run in the order in which they are defined', t =>
     }))
 
     instance.addHook('preHandler', function (request, reply, done) {
-      t.equal(request.previous, 4)
+      t.assert.strictEqual(request.previous, 4)
       request.previous = 5
       done()
     })
@@ -2102,19 +2086,20 @@ test('preHandler hooks should run in the order in which they are defined', t =>
   }))
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('onSend hooks should run in the order in which they are defined', t => {
+test('onSend hooks should run in the order in which they are defined', (t, testDone) => {
   t.plan(8)
   const fastify = Fastify()
 
   fastify.register(function (instance, opts, done) {
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(request.previous, undefined)
+      t.assert.strictEqual(request.previous, undefined)
       request.previous = 1
       done()
     })
@@ -2125,7 +2110,7 @@ test('onSend hooks should run in the order in which they are defined', t => {
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onSend', function (request, reply, payload, done) {
-        t.equal(request.previous, 1)
+        t.assert.strictEqual(request.previous, 1)
         request.previous = 2
         done()
       })
@@ -2137,14 +2122,14 @@ test('onSend hooks should run in the order in which they are defined', t => {
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(request.previous, 2)
+      t.assert.strictEqual(request.previous, 2)
       request.previous = 3
       done()
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onSend', function (request, reply, payload, done) {
-        t.equal(request.previous, 3)
+        t.assert.strictEqual(request.previous, 3)
         request.previous = 4
         done()
       })
@@ -2152,7 +2137,7 @@ test('onSend hooks should run in the order in which they are defined', t => {
     }))
 
     instance.addHook('onSend', function (request, reply, payload, done) {
-      t.equal(request.previous, 4)
+      t.assert.strictEqual(request.previous, 4)
       done(null, '5')
     })
 
@@ -2160,19 +2145,20 @@ test('onSend hooks should run in the order in which they are defined', t => {
   }))
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), 5)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), 5)
+    testDone()
   })
 })
 
-test('onResponse hooks should run in the order in which they are defined', t => {
+test('onResponse hooks should run in the order in which they are defined', (t, testDone) => {
   t.plan(8)
   const fastify = Fastify()
 
   fastify.register(function (instance, opts, done) {
     instance.addHook('onResponse', function (request, reply, done) {
-      t.equal(reply.previous, undefined)
+      t.assert.strictEqual(reply.previous, undefined)
       reply.previous = 1
       done()
     })
@@ -2183,7 +2169,7 @@ test('onResponse hooks should run in the order in which they are defined', t =>
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onResponse', function (request, reply, done) {
-        t.equal(reply.previous, 1)
+        t.assert.strictEqual(reply.previous, 1)
         reply.previous = 2
         done()
       })
@@ -2195,14 +2181,14 @@ test('onResponse hooks should run in the order in which they are defined', t =>
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onResponse', function (request, reply, done) {
-      t.equal(reply.previous, 2)
+      t.assert.strictEqual(reply.previous, 2)
       reply.previous = 3
       done()
     })
 
     instance.register(fp(function (i, opts, done) {
       i.addHook('onResponse', function (request, reply, done) {
-        t.equal(reply.previous, 3)
+        t.assert.strictEqual(reply.previous, 3)
         reply.previous = 4
         done()
       })
@@ -2210,7 +2196,7 @@ test('onResponse hooks should run in the order in which they are defined', t =>
     }))
 
     instance.addHook('onResponse', function (request, reply, done) {
-      t.equal(reply.previous, 4)
+      t.assert.strictEqual(reply.previous, 4)
       done()
     })
 
@@ -2218,13 +2204,14 @@ test('onResponse hooks should run in the order in which they are defined', t =>
   }))
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    testDone()
   })
 })
 
-test('onRequest, preHandler, and onResponse hooks that resolve to a value do not cause an error', t => {
+test('onRequest, preHandler, and onResponse hooks that resolve to a value do not cause an error', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -2243,13 +2230,14 @@ test('onRequest, preHandler, and onResponse hooks that resolve to a value do not
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('If a response header has been set inside an hook it should not be overwritten by the final response handler', t => {
+test('If a response header has been set inside an hook it should not be overwritten by the final response handler', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -2263,15 +2251,16 @@ test('If a response header has been set inside an hook it should not be overwrit
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['x-custom-header'], 'hello')
-    t.equal(res.headers['content-type'], 'text/plain; charset=utf-8')
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['x-custom-header'], 'hello')
+    t.assert.strictEqual(res.headers['content-type'], 'text/plain; charset=utf-8')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('If the content type has been set inside an hook it should not be changed', t => {
+test('If the content type has been set inside an hook it should not be changed', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -2281,27 +2270,28 @@ test('If the content type has been set inside an hook it should not be changed',
   })
 
   fastify.get('/', (request, reply) => {
-    t.ok(reply[symbols.kReplyHeaders]['content-type'])
+    t.assert.ok(reply[symbols.kReplyHeaders]['content-type'])
     reply.send('hello')
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'text/html')
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-type'], 'text/html')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 })
 
-test('request in onRequest, preParsing, preValidation and onResponse', t => {
+test('request in onRequest, preParsing, preValidation and onResponse', (t, testDone) => {
   t.plan(18)
   const fastify = Fastify()
 
   fastify.addHook('onRequest', function (request, reply, done) {
-    t.same(request.body, undefined)
-    t.same(request.query, { key: 'value' })
-    t.same(request.params, { greeting: 'hello' })
-    t.same(request.headers, {
+    t.assert.deepStrictEqual(request.body, undefined)
+    t.assert.deepStrictEqual(request.query.key, 'value')
+    t.assert.deepStrictEqual(request.params.greeting, 'hello')
+    t.assert.deepStrictEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
       host: 'localhost:80',
@@ -2312,10 +2302,10 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
   })
 
   fastify.addHook('preParsing', function (request, reply, payload, done) {
-    t.same(request.body, undefined)
-    t.same(request.query, { key: 'value' })
-    t.same(request.params, { greeting: 'hello' })
-    t.same(request.headers, {
+    t.assert.deepStrictEqual(request.body, undefined)
+    t.assert.deepStrictEqual(request.query.key, 'value')
+    t.assert.deepStrictEqual(request.params.greeting, 'hello')
+    t.assert.deepStrictEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
       host: 'localhost:80',
@@ -2326,10 +2316,10 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
   })
 
   fastify.addHook('preValidation', function (request, reply, done) {
-    t.same(request.body, { hello: 'world' })
-    t.same(request.query, { key: 'value' })
-    t.same(request.params, { greeting: 'hello' })
-    t.same(request.headers, {
+    t.assert.deepStrictEqual(request.body, { hello: 'world' })
+    t.assert.deepStrictEqual(request.query.key, 'value')
+    t.assert.deepStrictEqual(request.params.greeting, 'hello')
+    t.assert.deepStrictEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
       host: 'localhost:80',
@@ -2340,10 +2330,10 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
   })
 
   fastify.addHook('onResponse', function (request, reply, done) {
-    t.same(request.body, { hello: 'world' })
-    t.same(request.query, { key: 'value' })
-    t.same(request.params, { greeting: 'hello' })
-    t.same(request.headers, {
+    t.assert.deepStrictEqual(request.body, { hello: 'world' })
+    t.assert.deepStrictEqual(request.query.key, 'value')
+    t.assert.deepStrictEqual(request.params.greeting, 'hello')
+    t.assert.deepStrictEqual(request.headers, {
       'content-length': '17',
       'content-type': 'application/json',
       host: 'localhost:80',
@@ -2363,18 +2353,19 @@ test('request in onRequest, preParsing, preValidation and onResponse', t => {
     headers: { 'x-custom': 'hello' },
     payload: { hello: 'world' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('preValidation hook should support encapsulation / 1', t => {
+test('preValidation hook should support encapsulation / 1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.addHook('preValidation', (req, reply, done) => {
-      t.equal(req.raw.url, '/plugin')
+      t.assert.strictEqual(req.raw.url, '/plugin')
       done()
     })
 
@@ -2390,17 +2381,17 @@ test('preValidation hook should support encapsulation / 1', t => {
   })
 
   fastify.inject('/root', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-  })
-
-  fastify.inject('/plugin', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    fastify.inject('/plugin', (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.statusCode, 200)
+      testDone()
+    })
   })
 })
 
-test('preValidation hook should support encapsulation / 2', t => {
+test('preValidation hook should support encapsulation / 2', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
   let pluginInstance
@@ -2414,21 +2405,22 @@ test('preValidation hook should support encapsulation / 2', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(fastify[symbols.kHooks].preValidation.length, 1)
-    t.equal(pluginInstance[symbols.kHooks].preValidation.length, 2)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify[symbols.kHooks].preValidation.length, 1)
+    t.assert.strictEqual(pluginInstance[symbols.kHooks].preValidation.length, 2)
+    testDone()
   })
 })
 
-test('preValidation hook should support encapsulation / 3', t => {
-  t.plan(20)
+test('preValidation hook should support encapsulation / 3', async t => {
+  t.plan(19)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.decorate('hello', 'world')
 
   fastify.addHook('preValidation', function (req, reply, done) {
-    t.ok(this.hello)
-    t.ok(this.hello2)
+    t.assert.ok(this.hello)
+    t.assert.ok(this.hello2)
     req.first = true
     done()
   })
@@ -2436,56 +2428,48 @@ test('preValidation hook should support encapsulation / 3', t => {
   fastify.decorate('hello2', 'world')
 
   fastify.get('/first', (req, reply) => {
-    t.ok(req.first)
-    t.notOk(req.second)
+    t.assert.ok(req.first)
+    t.assert.ok(!req.second)
     reply.send({ hello: 'world' })
   })
 
   fastify.register((instance, opts, done) => {
     instance.decorate('hello3', 'world')
     instance.addHook('preValidation', function (req, reply, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
-      t.ok(this.hello3)
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
+      t.assert.ok(this.hello3)
       req.second = true
       done()
     })
 
     instance.get('/second', (req, reply) => {
-      t.ok(req.first)
-      t.ok(req.second)
+      t.assert.ok(req.first)
+      t.assert.ok(req.second)
       reply.send({ hello: 'world' })
     })
 
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const result1 = await fetch(fastifyServer + '/first')
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.text()
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const result2 = await fetch(fastifyServer + '/second')
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  const body2 = await result2.text()
+  t.assert.strictEqual(result2.headers.get('content-length'), '' + body2.length)
+  t.assert.deepStrictEqual(JSON.parse(body2), { hello: 'world' })
 })
 
-test('onError hook', t => {
+test('onError hook', (t, testDone) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -2493,7 +2477,7 @@ test('onError hook', t => {
   const err = new Error('kaboom')
 
   fastify.addHook('onError', (request, reply, error, done) => {
-    t.match(error, err)
+    t.assert.deepStrictEqual(error, err)
     done()
   })
 
@@ -2505,16 +2489,17 @@ test('onError hook', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       message: 'kaboom',
       statusCode: 500
     })
+    testDone()
   })
 })
 
-test('reply.send should throw if called inside the onError hook', t => {
+test('reply.send should throw if called inside the onError hook', (t, testDone) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -2524,9 +2509,9 @@ test('reply.send should throw if called inside the onError hook', t => {
   fastify.addHook('onError', (request, reply, error, done) => {
     try {
       reply.send()
-      t.fail('Should throw')
+      t.assert.fail('Should throw')
     } catch (err) {
-      t.equal(err.code, 'FST_ERR_SEND_INSIDE_ONERR')
+      t.assert.strictEqual(err.code, 'FST_ERR_SEND_INSIDE_ONERR')
     }
     done()
   })
@@ -2539,57 +2524,55 @@ test('reply.send should throw if called inside the onError hook', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       message: 'kaboom',
       statusCode: 500
     })
+    testDone()
   })
 })
 
-test('onError hook with setErrorHandler', t => {
-  t.test('Send error', t => {
-    t.plan(3)
+test('onError hook with setErrorHandler', (t, testDone) => {
+  t.plan(3)
 
-    const fastify = Fastify()
+  const fastify = Fastify()
 
-    const external = new Error('ouch')
-    const internal = new Error('kaboom')
+  const external = new Error('ouch')
+  const internal = new Error('kaboom')
 
-    fastify.setErrorHandler((_, req, reply) => {
-      reply.send(external)
-    })
+  fastify.setErrorHandler((_, req, reply) => {
+    reply.send(external)
+  })
 
-    fastify.addHook('onError', (request, reply, error, done) => {
-      t.match(error, internal)
-      done()
-    })
+  fastify.addHook('onError', (request, reply, error, done) => {
+    t.assert.deepStrictEqual(error, internal)
+    done()
+  })
 
-    fastify.get('/', (req, reply) => {
-      reply.send(internal)
-    })
+  fastify.get('/', (req, reply) => {
+    reply.send(internal)
+  })
 
-    fastify.inject({
-      method: 'GET',
-      url: '/'
-    }, (err, res) => {
-      t.error(err)
-      t.same(JSON.parse(res.payload), {
-        error: 'Internal Server Error',
-        message: 'ouch',
-        statusCode: 500
-      })
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
+      error: 'Internal Server Error',
+      message: 'ouch',
+      statusCode: 500
     })
+    testDone()
   })
-
-  t.end()
 })
 
-test('preParsing hook should run before parsing and be able to modify the payload', t => {
-  t.plan(5)
+test('preParsing hook should run before parsing and be able to modify the payload', async t => {
+  t.plan(4)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preParsing', function (req, reply, payload, done) {
     const modified = new stream.Readable()
@@ -2607,27 +2590,24 @@ test('preParsing hook should run before parsing and be able to modify the payloa
     }
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'POST',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first',
-      body: { hello: 'world' },
-      json: true
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + JSON.stringify(body).length)
-      t.same(body, { hello: 'another world' })
-    })
+  const result = await fetch(fastifyServer + '/first', {
+    method: 'POST',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: { 'Content-Type': 'application/json' }
   })
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'another world' })
 })
 
-test('preParsing hooks should run in the order in which they are defined', t => {
-  t.plan(5)
+test('preParsing hooks should run in the order in which they are defined', async t => {
+  t.plan(4)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preParsing', function (req, reply, payload, done) {
     const modified = new stream.Readable()
@@ -2650,27 +2630,24 @@ test('preParsing hooks should run in the order in which they are defined', t =>
     }
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'POST',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first',
-      body: { hello: 'world' },
-      json: true
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + JSON.stringify(body).length)
-      t.same(body, { hello: 'another world' })
-    })
+  const result = await fetch(fastifyServer + '/first', {
+    method: 'POST',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: { 'Content-Type': 'application/json' }
   })
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'another world' })
 })
 
-test('preParsing hooks should support encapsulation', t => {
-  t.plan(9)
+test('preParsing hooks should support encapsulation', async t => {
+  t.plan(8)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preParsing', function (req, reply, payload, done) {
     const modified = new stream.Readable()
@@ -2700,42 +2677,38 @@ test('preParsing hooks should support encapsulation', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'POST',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first',
-      body: { hello: 'world' },
-      json: true
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + JSON.stringify(body).length)
-      t.same(body, { hello: 'another world' })
-    })
+  const result1 = await fetch(fastifyServer + '/first', {
+    method: 'POST',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: { 'Content-Type': 'application/json' }
+  })
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.text()
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'another world' })
 
-    sget({
-      method: 'POST',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second',
-      body: { hello: 'world' },
-      json: true
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + JSON.stringify(body).length)
-      t.same(body, { hello: 'encapsulated world' })
-    })
+  const result2 = await fetch(fastifyServer + '/second', {
+    method: 'POST',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: { 'Content-Type': 'application/json' }
   })
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  const body2 = await result2.text()
+  t.assert.strictEqual(result2.headers.get('content-length'), '' + body2.length)
+  t.assert.deepStrictEqual(JSON.parse(body2), { hello: 'encapsulated world' })
 })
 
-test('preParsing hook should support encapsulation / 1', t => {
+test('preParsing hook should support encapsulation / 1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.addHook('preParsing', (req, reply, payload, done) => {
-      t.equal(req.raw.url, '/plugin')
+      t.assert.strictEqual(req.raw.url, '/plugin')
       done()
     })
 
@@ -2751,17 +2724,17 @@ test('preParsing hook should support encapsulation / 1', t => {
   })
 
   fastify.inject('/root', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-  })
-
-  fastify.inject('/plugin', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    fastify.inject('/plugin', (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.statusCode, 200)
+      testDone()
+    })
   })
 })
 
-test('preParsing hook should support encapsulation / 2', t => {
+test('preParsing hook should support encapsulation / 2', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
   let pluginInstance
@@ -2775,21 +2748,22 @@ test('preParsing hook should support encapsulation / 2', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(fastify[symbols.kHooks].preParsing.length, 1)
-    t.equal(pluginInstance[symbols.kHooks].preParsing.length, 2)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify[symbols.kHooks].preParsing.length, 1)
+    t.assert.strictEqual(pluginInstance[symbols.kHooks].preParsing.length, 2)
+    testDone()
   })
 })
 
-test('preParsing hook should support encapsulation / 3', t => {
-  t.plan(20)
+test('preParsing hook should support encapsulation / 3', async t => {
+  t.plan(19)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
   fastify.decorate('hello', 'world')
 
   fastify.addHook('preParsing', function (req, reply, payload, done) {
-    t.ok(this.hello)
-    t.ok(this.hello2)
+    t.assert.ok(this.hello)
+    t.assert.ok(this.hello2)
     req.first = true
     done()
   })
@@ -2797,59 +2771,51 @@ test('preParsing hook should support encapsulation / 3', t => {
   fastify.decorate('hello2', 'world')
 
   fastify.get('/first', (req, reply) => {
-    t.ok(req.first)
-    t.notOk(req.second)
+    t.assert.ok(req.first)
+    t.assert.ok(!req.second)
     reply.send({ hello: 'world' })
   })
 
   fastify.register((instance, opts, done) => {
     instance.decorate('hello3', 'world')
     instance.addHook('preParsing', function (req, reply, payload, done) {
-      t.ok(this.hello)
-      t.ok(this.hello2)
-      t.ok(this.hello3)
+      t.assert.ok(this.hello)
+      t.assert.ok(this.hello2)
+      t.assert.ok(this.hello3)
       req.second = true
       done()
     })
 
     instance.get('/second', (req, reply) => {
-      t.ok(req.first)
-      t.ok(req.second)
+      t.assert.ok(req.first)
+      t.assert.ok(req.second)
       reply.send({ hello: 'world' })
     })
 
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
+  const result1 = await fetch(fastifyServer + '/first')
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.text()
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-  })
+  const result2 = await fetch(fastifyServer + '/second')
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  const body2 = await result2.text()
+  t.assert.strictEqual(result2.headers.get('content-length'), '' + body2.length)
+  t.assert.deepStrictEqual(JSON.parse(body2), { hello: 'world' })
 })
 
-test('preSerialization hook should run before serialization and be able to modify the payload', t => {
-  t.plan(5)
+test('preSerialization hook should run before serialization and be able to modify the payload', async t => {
+  t.plan(4)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preSerialization', function (req, reply, payload, done) {
     payload.hello += '1'
@@ -2883,31 +2849,27 @@ test('preSerialization hook should run before serialization and be able to modif
     }
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world1', world: 'ok' })
-    })
-  })
+  const result = await fetch(fastifyServer + '/first')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world1', world: 'ok' })
 })
 
-test('preSerialization hook should be able to throw errors which are validated against schema response', t => {
+test('preSerialization hook should be able to throw errors which are validated against schema response', async t => {
+  t.plan(5)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preSerialization', function (req, reply, payload, done) {
     done(new Error('preSerialization aborted'))
   })
 
   fastify.setErrorHandler((err, request, reply) => {
-    t.equal(err.message, 'preSerialization aborted')
+    t.assert.strictEqual(err.message, 'preSerialization aborted')
     err.world = 'error'
     reply.send(err)
   })
@@ -2934,33 +2896,27 @@ test('preSerialization hook should be able to throw errors which are validated a
     }
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { world: 'error' })
-      t.end()
-    })
-  })
+  const result = await fetch(fastifyServer + '/first')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 500)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { world: 'error' })
 })
 
-test('preSerialization hook which returned error should still run onError hooks', t => {
-  t.plan(4)
+test('preSerialization hook which returned error should still run onError hooks', async t => {
+  t.plan(3)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preSerialization', function (req, reply, payload, done) {
     done(new Error('preSerialization aborted'))
   })
 
   fastify.addHook('onError', function (req, reply, payload, done) {
-    t.pass()
+    t.assert.ok('should pass')
     done()
   })
 
@@ -2968,23 +2924,17 @@ test('preSerialization hook which returned error should still run onError hooks'
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-    })
-  })
+  const result = await fetch(fastifyServer + '/first')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 500)
 })
 
-test('preSerialization hooks should run in the order in which they are defined', t => {
-  t.plan(5)
+test('preSerialization hooks should run in the order in which they are defined', async t => {
+  t.plan(4)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preSerialization', function (req, reply, payload, done) {
     payload.hello += '2'
@@ -2999,28 +2949,23 @@ test('preSerialization hooks should run in the order in which they are defined',
   })
 
   fastify.get('/first', (req, reply) => {
-    reply.send(payload)
+    reply.send({ hello: 'world' })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world21' })
-    })
-  })
+  const result = await fetch(fastifyServer + '/first')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.text()
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world21' })
 })
 
-test('preSerialization hooks should support encapsulation', t => {
-  t.plan(9)
+test('preSerialization hooks should support encapsulation', async t => {
+  t.plan(8)
   const fastify = Fastify()
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('preSerialization', function (req, reply, payload, done) {
     payload.hello += '1'
@@ -3046,40 +2991,32 @@ test('preSerialization hooks should support encapsulation', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/first'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world1' })
-    })
+  const result1 = await fetch(fastifyServer + '/first')
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.text()
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world1' })
 
-    sget({
-      method: 'GET',
-      url: 'http://127.0.0.1:' + fastify.server.address().port + '/second'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world12' })
-    })
-  })
+  const result2 = await fetch(fastifyServer + '/second')
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  const body2 = await result2.text()
+  t.assert.strictEqual(result2.headers.get('content-length'), '' + body2.length)
+  t.assert.deepStrictEqual(JSON.parse(body2), { hello: 'world12' })
 })
 
-test('onRegister hook should be called / 1', t => {
+test('onRegister hook should be called / 1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
   fastify.addHook('onRegister', function (instance, opts, done) {
-    t.ok(this.addHook)
-    t.ok(instance.addHook)
-    t.same(opts, pluginOpts)
-    t.notOk(done)
+    t.assert.ok(this.addHook)
+    t.assert.ok(instance.addHook)
+    t.assert.deepStrictEqual(opts, pluginOpts)
+    t.assert.ok(!done)
   })
 
   const pluginOpts = { prefix: 'hello', custom: 'world' }
@@ -3087,16 +3024,19 @@ test('onRegister hook should be called / 1', t => {
     done()
   }, pluginOpts)
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('onRegister hook should be called / 2', t => {
+test('onRegister hook should be called / 2', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
 
   fastify.addHook('onRegister', function (instance) {
-    t.ok(this.addHook)
-    t.ok(instance.addHook)
+    t.assert.ok(this.addHook)
+    t.assert.ok(instance.addHook)
   })
 
   fastify.register((instance, opts, done) => {
@@ -3111,11 +3051,12 @@ test('onRegister hook should be called / 2', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRegister hook should be called / 3', t => {
+test('onRegister hook should be called / 3', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -3129,24 +3070,25 @@ test('onRegister hook should be called / 3', t => {
     instance.data.push(1)
     instance.register((instance, opts, done) => {
       instance.data.push(2)
-      t.same(instance.data, [1, 2])
+      t.assert.deepStrictEqual(instance.data, [1, 2])
       done()
     })
-    t.same(instance.data, [1])
+    t.assert.deepStrictEqual(instance.data, [1])
     done()
   })
 
   fastify.register((instance, opts, done) => {
-    t.same(instance.data, [])
+    t.assert.deepStrictEqual(instance.data, [])
     done()
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onRegister hook should be called (encapsulation)', t => {
+test('onRegister hook should be called (encapsulation)', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -3156,17 +3098,18 @@ test('onRegister hook should be called (encapsulation)', t => {
   plugin[Symbol.for('skip-override')] = true
 
   fastify.addHook('onRegister', (instance, opts) => {
-    t.fail('This should not be called')
+    t.assert.fail('This should not be called')
   })
 
   fastify.register(plugin)
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('early termination, onRequest', t => {
+test('early termination, onRequest', (t, testDone) => {
   t.plan(3)
 
   const app = Fastify()
@@ -3177,17 +3120,18 @@ test('early termination, onRequest', t => {
   })
 
   app.get('/', (req, reply) => {
-    t.fail('should not happen')
+    t.assert.fail('should not happen')
   })
 
   app.inject('/', function (err, res) {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.body.toString(), 'hello world')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body.toString(), 'hello world')
+    testDone()
   })
 })
 
-test('reply.send should throw if undefined error is thrown', t => {
+test('reply.send should throw if undefined error is thrown', (t, testDone) => {
   /* eslint prefer-promise-reject-errors: ["error", {"allowEmptyReject": true}] */
 
   t.plan(3)
@@ -3205,18 +3149,19 @@ test('reply.send should throw if undefined error is thrown', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       code: 'FST_ERR_SEND_UNDEFINED_ERR',
       message: 'Undefined error has occurred',
       statusCode: 500
     })
+    testDone()
   })
 })
 
-test('reply.send should throw if undefined error is thrown at preParsing hook', t => {
+test('reply.send should throw if undefined error is thrown at preParsing hook', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -3232,18 +3177,19 @@ test('reply.send should throw if undefined error is thrown at preParsing hook',
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       code: 'FST_ERR_SEND_UNDEFINED_ERR',
       message: 'Undefined error has occurred',
       statusCode: 500
     })
+    testDone()
   })
 })
 
-test('reply.send should throw if undefined error is thrown at onSend hook', t => {
+test('reply.send should throw if undefined error is thrown at onSend hook', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -3259,24 +3205,25 @@ test('reply.send should throw if undefined error is thrown at onSend hook', t =>
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       code: 'FST_ERR_SEND_UNDEFINED_ERR',
       message: 'Undefined error has occurred',
       statusCode: 500
     })
+    testDone()
   })
 })
 
-test('onTimeout should be triggered', t => {
-  t.plan(6)
+test('onTimeout should be triggered', async t => {
+  t.plan(4)
   const fastify = Fastify({ connectionTimeout: 500 })
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('onTimeout', function (req, res, done) {
-    t.ok('called', 'onTimeout')
+    t.assert.ok('called', 'onTimeout')
     done()
   })
 
@@ -3288,33 +3235,22 @@ test('onTimeout should be triggered', t => {
     return reply
   })
 
-  fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: address
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-    })
-    sget({
-      method: 'GET',
-      url: `${address}/timeout`
-    }, (err, response, body) => {
-      t.type(err, Error)
-      t.equal(err.message, 'socket hang up')
-    })
-  })
+  const result1 = await fetch(fastifyServer)
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+
+  await t.assert.rejects(() => fetch(fastifyServer + '/timeout'))
 })
 
-test('onTimeout should be triggered and socket _meta is set', t => {
-  t.plan(6)
+test('onTimeout should be triggered and socket _meta is set', async t => {
+  t.plan(4)
   const fastify = Fastify({ connectionTimeout: 500 })
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
   fastify.addHook('onTimeout', function (req, res, done) {
-    t.ok('called', 'onTimeout')
+    t.assert.ok('called', 'onTimeout')
     done()
   })
 
@@ -3327,24 +3263,18 @@ test('onTimeout should be triggered and socket _meta is set', t => {
     return reply
   })
 
-  fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: address
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-    })
-    sget({
-      method: 'GET',
-      url: `${address}/timeout`
-    }, (err, response, body) => {
-      t.type(err, Error)
-      t.equal(err.message, 'socket hang up')
-    })
-  })
+  const result1 = await fetch(fastifyServer)
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+
+  try {
+    await fetch(fastifyServer + '/timeout')
+    t.fail('Should have thrown an error')
+  } catch (err) {
+    t.assert.ok(err instanceof Error)
+  }
 })
 
 test('registering invalid hooks should throw an error', async t => {
@@ -3352,7 +3282,7 @@ test('registering invalid hooks should throw an error', async t => {
 
   const fastify = Fastify()
 
-  t.throws(() => {
+  t.assert.throws(() => {
     fastify.route({
       method: 'GET',
       path: '/invalidHook',
@@ -3361,9 +3291,11 @@ test('registering invalid hooks should throw an error', async t => {
         return 'hello world'
       }
     })
-  }, new Error('onRequest hook should be a function, instead got [object Undefined]'))
+  }, {
+    message: 'onRequest hook should be a function, instead got [object Undefined]'
+  })
 
-  t.throws(() => {
+  t.assert.throws(() => {
     fastify.route({
       method: 'GET',
       path: '/invalidHook',
@@ -3372,7 +3304,7 @@ test('registering invalid hooks should throw an error', async t => {
         return 'hello world'
       }
     })
-  }, new Error('onRequest hook should be a function, instead got [object Null]'))
+  }, { message: 'onRequest hook should be a function, instead got [object Null]' })
 
   // undefined is ok
   fastify.route({
@@ -3384,7 +3316,7 @@ test('registering invalid hooks should throw an error', async t => {
     }
   })
 
-  t.throws(() => {
+  t.assert.throws(() => {
     fastify.addHook('onRoute', (routeOptions) => {
       routeOptions.onSend = [undefined]
     })
@@ -3392,35 +3324,39 @@ test('registering invalid hooks should throw an error', async t => {
     fastify.get('/', function (request, reply) {
       reply.send('hello world')
     })
-  }, new Error('onSend hook should be a function, instead got [object Undefined]'))
+  }, { message: 'onSend hook should be a function, instead got [object Undefined]' })
 })
 
-test('onRequestAbort should be triggered', t => {
+test('onRequestAbort should be triggered', (t, testDone) => {
   const fastify = Fastify()
   let order = 0
 
   t.plan(7)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
+
+  const completion = waitForCb({ steps: 2 })
+  completion.patience.then(testDone)
 
   fastify.addHook('onRequestAbort', function (req, done) {
-    t.equal(++order, 1, 'called in hook')
-    t.ok(req.pendingResolve, 'request has pendingResolve')
+    t.assert.strictEqual(++order, 1, 'called in hook')
+    t.assert.ok(req.pendingResolve, 'request has pendingResolve')
     req.pendingResolve()
+    completion.stepIn()
     done()
   })
 
   fastify.addHook('onError', function hook (request, reply, error, done) {
-    t.fail('onError should not be called')
+    t.assert.fail('onError should not be called')
     done()
   })
 
   fastify.addHook('onSend', function hook (request, reply, payload, done) {
-    t.equal(payload, '{"hello":"world"}', 'onSend should be called')
+    t.assert.strictEqual(payload, '{"hello":"world"}', 'onSend should be called')
     done(null, payload)
   })
 
   fastify.addHook('onResponse', function hook (request, reply, done) {
-    t.fail('onResponse should not be called')
+    t.assert.fail('onResponse should not be called')
     done()
   })
 
@@ -3428,21 +3364,22 @@ test('onRequestAbort should be triggered', t => {
     method: 'GET',
     path: '/',
     async handler (request, reply) {
-      t.pass('handler called')
+      t.assert.ok('handler called')
       let resolvePromise
       const promise = new Promise(resolve => { resolvePromise = resolve })
       request.pendingResolve = resolvePromise
       await promise
-      t.pass('handler promise resolved')
+      t.assert.ok('handler promise resolved')
       return { hello: 'world' }
     },
     async onRequestAbort (req) {
-      t.equal(++order, 2, 'called in route')
+      t.assert.strictEqual(++order, 2, 'called in route')
+      completion.stepIn()
     }
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)
 
@@ -3452,17 +3389,21 @@ test('onRequestAbort should be triggered', t => {
   })
 })
 
-test('onRequestAbort should support encapsulation', t => {
+test('onRequestAbort should support encapsulation', (t, testDone) => {
   const fastify = Fastify()
   let order = 0
   let child
 
   t.plan(6)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
+
+  const completion = waitForCb({ steps: 2 })
+  completion.patience.then(testDone)
 
   fastify.addHook('onRequestAbort', function (req, done) {
-    t.equal(++order, 1, 'called in root')
-    t.strictSame(this.pluginName, child.pluginName)
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.deepStrictEqual(this.pluginName, child.pluginName)
+    completion.stepIn()
     done()
   })
 
@@ -3470,8 +3411,9 @@ test('onRequestAbort should support encapsulation', t => {
     child = _child
 
     fastify.addHook('onRequestAbort', async function (req) {
-      t.equal(++order, 2, 'called in child')
-      t.strictSame(this.pluginName, child.pluginName)
+      t.assert.strictEqual(++order, 2, 'called in child')
+      t.assert.deepStrictEqual(this.pluginName, child.pluginName)
+      completion.stepIn()
     })
 
     child.route({
@@ -3482,13 +3424,13 @@ test('onRequestAbort should support encapsulation', t => {
         return { hello: 'world' }
       },
       async onRequestAbort (_req) {
-        t.equal(++order, 3, 'called in route')
+        t.assert.strictEqual(++order, 3, 'called in route')
       }
     })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)
 
@@ -3498,14 +3440,17 @@ test('onRequestAbort should support encapsulation', t => {
   })
 })
 
-test('onRequestAbort should handle errors / 1', t => {
+test('onRequestAbort should handle errors / 1', (t, testDone) => {
   const fastify = Fastify()
 
   t.plan(2)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.addHook('onRequestAbort', function (req, done) {
-    process.nextTick(() => t.pass())
+    process.nextTick(() => {
+      t.assert.ok('should pass')
+      testDone()
+    })
     done(new Error('KABOOM!'))
   })
 
@@ -3519,7 +3464,7 @@ test('onRequestAbort should handle errors / 1', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)
 
@@ -3529,14 +3474,17 @@ test('onRequestAbort should handle errors / 1', t => {
   })
 })
 
-test('onRequestAbort should handle errors / 2', t => {
+test('onRequestAbort should handle errors / 2', (t, testDone) => {
   const fastify = Fastify()
 
   t.plan(2)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.addHook('onRequestAbort', function (req, done) {
-    process.nextTick(() => t.pass())
+    process.nextTick(() => {
+      t.assert.ok('should pass')
+      testDone()
+    })
     throw new Error('KABOOM!')
   })
 
@@ -3550,7 +3498,7 @@ test('onRequestAbort should handle errors / 2', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)
 
@@ -3560,14 +3508,17 @@ test('onRequestAbort should handle errors / 2', t => {
   })
 })
 
-test('onRequestAbort should handle async errors / 1', t => {
+test('onRequestAbort should handle async errors / 1', (t, testDone) => {
   const fastify = Fastify()
 
   t.plan(2)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.addHook('onRequestAbort', async function (req) {
-    process.nextTick(() => t.pass())
+    process.nextTick(() => {
+      t.assert.ok('should pass')
+      testDone()
+    })
     throw new Error('KABOOM!')
   })
 
@@ -3581,7 +3532,7 @@ test('onRequestAbort should handle async errors / 1', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)
 
@@ -3591,14 +3542,18 @@ test('onRequestAbort should handle async errors / 1', t => {
   })
 })
 
-test('onRequestAbort should handle async errors / 2', t => {
+test('onRequestAbort should handle async errors / 2', (t, testDone) => {
   const fastify = Fastify()
 
   t.plan(2)
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.addHook('onRequestAbort', async function (req) {
-    process.nextTick(() => t.pass())
+    process.nextTick(() => {
+      t.assert.ok('should pass')
+      testDone()
+    })
+
     return Promise.reject()
   })
 
@@ -3612,7 +3567,7 @@ test('onRequestAbort should handle async errors / 2', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const socket = connect(fastify.server.address().port)