fastify 5.0.0 → 5.2.0

package/test/internals/reply.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const http = require('node:http')
 const NotFound = require('http-errors').NotFound
@@ -40,22 +39,22 @@ test('Once called, Reply should return an object with methods', t => {
   const context = { config: { onSend: [] }, schema: {}, _parserOptions: {}, server: { hasConstraintStrategy: () => false, initialConfig: {} } }
   const request = new Request(null, null, null, null, null, context)
   const reply = new Reply(response, request)
-  t.equal(typeof reply, 'object')
-  t.equal(typeof reply[kReplyIsError], 'boolean')
-  t.equal(typeof reply[kReplyErrorHandlerCalled], 'boolean')
-  t.equal(typeof reply.send, 'function')
-  t.equal(typeof reply.code, 'function')
-  t.equal(typeof reply.status, 'function')
-  t.equal(typeof reply.header, 'function')
-  t.equal(typeof reply.serialize, 'function')
-  t.equal(typeof reply[kReplyHeaders], 'object')
-  t.same(reply.raw, response)
-  t.equal(reply[kRouteContext], context)
-  t.equal(reply.routeOptions.config, context.config)
-  t.equal(reply.routeOptions.schema, context.schema)
-  t.equal(reply.request, request)
+  t.assert.strictEqual(typeof reply, 'object')
+  t.assert.strictEqual(typeof reply[kReplyIsError], 'boolean')
+  t.assert.strictEqual(typeof reply[kReplyErrorHandlerCalled], 'boolean')
+  t.assert.strictEqual(typeof reply.send, 'function')
+  t.assert.strictEqual(typeof reply.code, 'function')
+  t.assert.strictEqual(typeof reply.status, 'function')
+  t.assert.strictEqual(typeof reply.header, 'function')
+  t.assert.strictEqual(typeof reply.serialize, 'function')
+  t.assert.strictEqual(typeof reply[kReplyHeaders], 'object')
+  t.assert.deepStrictEqual(reply.raw, response)
+  t.assert.strictEqual(reply[kRouteContext], context)
+  t.assert.strictEqual(reply.routeOptions.config, context.config)
+  t.assert.strictEqual(reply.routeOptions.schema, context.schema)
+  t.assert.strictEqual(reply.request, request)
   // Aim to not bad property keys (including Symbols)
-  t.notOk('undefined' in reply)
+  t.assert.ok(!('undefined' in reply))
 })
 
 test('reply.send will logStream error and destroy the stream', t => {
@@ -87,7 +86,7 @@ test('reply.send will logStream error and destroy the stream', t => {
   reply.send(payload)
   payload.destroy(new Error('stream error'))
 
-  t.equal(destroyCalled, true, 'Error not logged and not streamed')
+  t.assert.strictEqual(destroyCalled, true, 'Error not logged and not streamed')
 })
 
 test('reply.send throw with circular JSON', t => {
@@ -101,7 +100,7 @@ test('reply.send throw with circular JSON', t => {
     end: () => { }
   }
   const reply = new Reply(response, { [kRouteContext]: { onSend: [] } })
-  t.throws(() => {
+  t.assert.throws(() => {
     const obj = {}
     obj.obj = obj
     reply.send(JSON.stringify(obj))
@@ -119,23 +118,23 @@ test('reply.send returns itself', t => {
     end: () => { }
   }
   const reply = new Reply(response, { [kRouteContext]: { onSend: [] } })
-  t.equal(reply.send('hello'), reply)
+  t.assert.strictEqual(reply.send('hello'), reply)
 })
 
 test('reply.serializer should set a custom serializer', t => {
   t.plan(2)
   const reply = new Reply(null, null, null)
-  t.equal(reply[kReplySerializer], null)
+  t.assert.strictEqual(reply[kReplySerializer], null)
   reply.serializer('serializer')
-  t.equal(reply[kReplySerializer], 'serializer')
+  t.assert.strictEqual(reply[kReplySerializer], 'serializer')
 })
 
-test('reply.serializer should support running preSerialization hooks', t => {
+test('reply.serializer should support running preSerialization hooks', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
-  fastify.addHook('preSerialization', async (request, reply, payload) => { t.ok('called', 'preSerialization') })
+  fastify.addHook('preSerialization', async (request, reply, payload) => { t.assert.ok('called', 'preSerialization') })
   fastify.route({
     method: 'GET',
     url: '/',
@@ -151,8 +150,9 @@ test('reply.serializer should support running preSerialization hooks', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"foo":"bar"}')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, '{"foo":"bar"}')
+    done()
   })
 })
 
@@ -161,7 +161,7 @@ test('reply.serialize should serialize payload', t => {
   const response = { statusCode: 200 }
   const context = {}
   const reply = new Reply(response, { [kRouteContext]: context })
-  t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
+  t.assert.strictEqual(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
 })
 
 test('reply.serialize should serialize payload with a custom serializer', t => {
@@ -171,8 +171,8 @@ test('reply.serialize should serialize payload with a custom serializer', t => {
   const context = {}
   const reply = new Reply(response, { [kRouteContext]: context })
   reply.serializer((x) => (customSerializerCalled = true) && JSON.stringify(x))
-  t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
-  t.equal(customSerializerCalled, true, 'custom serializer not called')
+  t.assert.strictEqual(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
+  t.assert.strictEqual(customSerializerCalled, true, 'custom serializer not called')
 })
 
 test('reply.serialize should serialize payload with a context default serializer', t => {
@@ -181,14 +181,14 @@ test('reply.serialize should serialize payload with a context default serializer
   const response = { statusCode: 200 }
   const context = { [kReplySerializerDefault]: (x) => (customSerializerCalled = true) && JSON.stringify(x) }
   const reply = new Reply(response, { [kRouteContext]: context })
-  t.equal(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
-  t.equal(customSerializerCalled, true, 'custom serializer not called')
+  t.assert.strictEqual(reply.serialize({ foo: 'bar' }), '{"foo":"bar"}')
+  t.assert.strictEqual(customSerializerCalled, true, 'custom serializer not called')
 })
 
-test('reply.serialize should serialize payload with Fastify instance', t => {
+test('reply.serialize should serialize payload with Fastify instance', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.route({
     method: 'GET',
     url: '/',
@@ -213,15 +213,15 @@ test('reply.serialize should serialize payload with Fastify instance', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"foo":"bar"}')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, '{"foo":"bar"}')
+    done()
   })
 })
 
-test('within an instance', t => {
+test('within an instance', async t => {
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  const test = t.test
+  t.after(() => fastify.close())
 
   fastify.get('/', function (req, reply) {
     reply.code(200)
@@ -279,166 +279,175 @@ test('within an instance', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
-    test('custom serializer should be used', t => {
-      t.plan(3)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/custom-serializer'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello=world!')
-      })
+  await t.test('custom serializer should be used', (t, done) => {
+    t.plan(3)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/custom-serializer'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello=world!')
+      done()
     })
+  })
 
-    test('status code and content-type should be correct', t => {
-      t.plan(4)
-      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-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('status code and content-type should be correct', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('auto status code should be 200', t => {
-      t.plan(3)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/auto-status-code'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('auto status code should be 200', (t, done) => {
+    t.plan(3)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/auto-status-code'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('auto type should be text/plain', t => {
-      t.plan(3)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/auto-type'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('auto type should be text/plain', (t, done) => {
+    t.plan(3)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/auto-type'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('redirect to `/` - 1', t => {
-      t.plan(1)
+  await t.test('redirect to `/` - 1', (t, done) => {
+    t.plan(1)
 
-      http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect', function (response) {
-        t.equal(response.statusCode, 302)
-      })
+    http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect', function (response) {
+      t.assert.strictEqual(response.statusCode, 302)
+      done()
     })
+  })
 
-    test('redirect to `/` - 2', t => {
-      t.plan(1)
+  await t.test('redirect to `/` - 2', (t, done) => {
+    t.plan(1)
 
-      http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code', function (response) {
-        t.equal(response.statusCode, 301)
-      })
+    http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code', function (response) {
+      t.assert.strictEqual(response.statusCode, 301)
+      done()
     })
+  })
 
-    test('redirect to `/` - 3', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('redirect to `/` - 3', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('redirect to `/` - 4', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('redirect to `/` - 4', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('redirect to `/` - 5', t => {
-      t.plan(3)
-      const url = 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-onsend'
-      http.get(url, (response) => {
-        t.equal(response.headers['x-onsend'], 'yes')
-        t.equal(response.headers['content-length'], '0')
-        t.equal(response.headers.location, '/')
-      })
+  await t.test('redirect to `/` - 5', (t, done) => {
+    t.plan(3)
+    const url = 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-onsend'
+    http.get(url, (response) => {
+      t.assert.strictEqual(response.headers['x-onsend'], 'yes')
+      t.assert.strictEqual(response.headers['content-length'], '0')
+      t.assert.strictEqual(response.headers.location, '/')
+      done()
     })
+  })
 
-    test('redirect to `/` - 6', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('redirect to `/` - 6', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('redirect to `/` - 7', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call-overwrite'
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.same(body.toString(), 'hello world!')
-      })
+  await t.test('redirect to `/` - 7', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call-overwrite'
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
+  })
 
-    test('redirect to `/` - 8', t => {
-      t.plan(1)
+  await t.test('redirect to `/` - 8', (t, done) => {
+    t.plan(1)
 
-      http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call', function (response) {
-        t.equal(response.statusCode, 307)
-      })
+    http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call', function (response) {
+      t.assert.strictEqual(response.statusCode, 307)
+      done()
     })
+  })
 
-    test('redirect to `/` - 9', t => {
-      t.plan(1)
+  await t.test('redirect to `/` - 9', (t, done) => {
+    t.plan(1)
 
-      http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call-overwrite', function (response) {
-        t.equal(response.statusCode, 302)
-      })
+    http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-code-before-call-overwrite', function (response) {
+      t.assert.strictEqual(response.statusCode, 302)
+      done()
     })
+  })
 
-    test('redirect with async function to `/` - 10', t => {
-      t.plan(1)
+  await t.test('redirect with async function to `/` - 10', (t, done) => {
+    t.plan(1)
 
-      http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-async', function (response) {
-        t.equal(response.statusCode, 302)
-      })
+    http.get('http://127.0.0.1:' + fastify.server.address().port + '/redirect-async', function (response) {
+      t.assert.strictEqual(response.statusCode, 302)
+      done()
     })
-
-    t.end()
   })
 })
 
-test('buffer without content type should send a application/octet-stream and raw buffer', t => {
+test('buffer without content type should send a application/octet-stream and raw buffer', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -448,20 +457,22 @@ test('buffer without content type should send a application/octet-stream and raw
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'application/octet-stream')
-      t.same(body, Buffer.alloc(1024))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/octet-stream')
+      t.assert.deepStrictEqual(body, Buffer.alloc(1024))
+      done()
     })
   })
 })
-test('Uint8Array without content type should send a application/octet-stream and raw buffer', t => {
+
+test('Uint8Array without content type should send a application/octet-stream and raw buffer', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -471,20 +482,21 @@ test('Uint8Array without content type should send a application/octet-stream and
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     fastify.inject({
       method: 'GET',
       url: '/'
     }, (err, response) => {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/octet-stream')
-      t.same(new Uint8Array(response.rawPayload), new Uint8Array(1024).fill(0xff))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/octet-stream')
+      t.assert.deepStrictEqual(new Uint8Array(response.rawPayload), new Uint8Array(1024).fill(0xff))
+      done()
     })
   })
 })
-test('Uint16Array without content type should send a application/octet-stream and raw buffer', t => {
+test('Uint16Array without content type should send a application/octet-stream and raw buffer', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -494,20 +506,21 @@ test('Uint16Array without content type should send a application/octet-stream an
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     fastify.inject({
       method: 'GET',
       url: '/'
     }, (err, res) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'application/octet-stream')
-      t.same(new Uint16Array(res.rawPayload.buffer, res.rawPayload.byteOffset, res.rawPayload.byteLength / Uint16Array.BYTES_PER_ELEMENT), new Uint16Array(50).fill(0xffffffff))
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.headers['content-type'], 'application/octet-stream')
+      t.assert.deepStrictEqual(new Uint16Array(res.rawPayload.buffer, res.rawPayload.byteOffset, res.rawPayload.byteLength / Uint16Array.BYTES_PER_ELEMENT), new Uint16Array(50).fill(0xffffffff))
+      done()
     })
   })
 })
-test('TypedArray with content type should not send application/octet-stream', t => {
+test('TypedArray with content type should not send application/octet-stream', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -518,20 +531,21 @@ test('TypedArray with content type should not send application/octet-stream', t
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     fastify.inject({
       method: 'GET',
       url: '/'
     }, (err, res) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.same(new Uint16Array(res.rawPayload.buffer, res.rawPayload.byteOffset, res.rawPayload.byteLength / Uint16Array.BYTES_PER_ELEMENT), new Uint16Array(1024).fill(0xffffffff))
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(new Uint16Array(res.rawPayload.buffer, res.rawPayload.byteOffset, res.rawPayload.byteLength / Uint16Array.BYTES_PER_ELEMENT), new Uint16Array(1024).fill(0xffffffff))
+      done()
     })
   })
 })
-test('buffer with content type should not send application/octet-stream', t => {
+test('buffer with content type should not send application/octet-stream', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -542,21 +556,22 @@ test('buffer with content type should not send application/octet-stream', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'text/plain')
-      t.same(body, Buffer.alloc(1024))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body, Buffer.alloc(1024))
+      done()
     })
   })
 })
 
-test('stream with content type should not send application/octet-stream', t => {
+test('stream with content type should not send application/octet-stream', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -570,20 +585,21 @@ test('stream with content type should not send application/octet-stream', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'text/plain')
-      t.same(body, buf)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+      t.assert.deepStrictEqual(body, buf)
+      done()
     })
   })
 })
 
-test('stream without content type should not send application/octet-stream', t => {
+test('stream without content type should not send application/octet-stream', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -596,20 +612,21 @@ test('stream without content type should not send application/octet-stream', t =
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], undefined)
-      t.same(body, buf)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], undefined)
+      t.assert.deepStrictEqual(body, buf)
+      done()
     })
   })
 })
 
-test('stream using reply.raw.writeHead should return customize headers', t => {
+test('stream using reply.raw.writeHead should return customize headers', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify()
@@ -622,7 +639,7 @@ test('stream using reply.raw.writeHead should return customize headers', t => {
 
   fastify.get('/', function (req, reply) {
     reply.log.warn = function mockWarn (message) {
-      t.equal(message, 'response will send, but you shouldn\'t use res.writeHead in stream mode')
+      t.assert.strictEqual(message, 'response will send, but you shouldn\'t use res.writeHead in stream mode')
     }
     reply.raw.writeHead(200, {
       location: '/'
@@ -631,21 +648,22 @@ test('stream using reply.raw.writeHead should return customize headers', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers.location, '/')
-      t.equal(response.headers['Content-Type'], undefined)
-      t.same(body, buf)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers.location, '/')
+      t.assert.strictEqual(response.headers['Content-Type'], undefined)
+      t.assert.deepStrictEqual(body, buf)
+      done()
     })
   })
 })
 
-test('plain string without content type should send a text/plain', t => {
+test('plain string without content type should send a text/plain', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -655,21 +673,22 @@ test('plain string without content type should send a text/plain', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'text/plain; charset=utf-8')
-      t.same(body.toString(), 'hello world!')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/plain; charset=utf-8')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
   })
 })
 
-test('plain string with content type should be sent unmodified', t => {
+test('plain string with content type should be sent unmodified', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -679,21 +698,22 @@ test('plain string with content type should be sent unmodified', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'text/css')
-      t.same(body.toString(), 'hello world!')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/css')
+      t.assert.deepStrictEqual(body.toString(), 'hello world!')
+      done()
     })
   })
 })
 
-test('plain string with content type and custom serializer should be serialized', t => {
+test('plain string with content type and custom serializer should be serialized', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -706,21 +726,22 @@ test('plain string with content type and custom serializer should be serialized'
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'text/css')
-      t.same(body.toString(), 'serialized')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'text/css')
+      t.assert.deepStrictEqual(body.toString(), 'serialized')
+      done()
     })
   })
 })
 
-test('plain string with content type application/json should NOT be serialized as json', t => {
+test('plain string with content type application/json should NOT be serialized as json', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -730,25 +751,28 @@ test('plain string with content type application/json should NOT be serialized a
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'application/json; charset=utf-8')
-      t.same(body.toString(), '{"key": "hello world!"}')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.deepStrictEqual(body.toString(), '{"key": "hello world!"}')
+      done()
     })
   })
 })
 
-test('plain string with custom json content type should NOT be serialized as json', t => {
-  t.plan(19)
+test('plain string with custom json content type should NOT be serialized as json', async t => {
+  t.plan(12)
 
   const fastify = Fastify()
 
+  t.after(() => fastify.close())
+
   const customSamples = {
     collectionjson: {
       mimeType: 'application/vnd.collection+json',
@@ -782,24 +806,26 @@ test('plain string with custom json content type should NOT be serialized as jso
     })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
-    Object.keys(customSamples).forEach((path) => {
+  await Promise.all(Object.keys(customSamples).map(path => {
+    return new Promise((resolve, reject) => {
       sget({
         method: 'GET',
         url: 'http://127.0.0.1:' + fastify.server.address().port + '/' + path
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
-        t.same(body.toString(), customSamples[path].sample)
+        if (err) {
+          reject(err)
+        }
+        t.assert.strictEqual(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
+        t.assert.deepStrictEqual(body.toString(), customSamples[path].sample)
+        resolve()
       })
     })
-  })
+  }))
 })
 
-test('non-string with content type application/json SHOULD be serialized as json', t => {
+test('non-string with content type application/json SHOULD be serialized as json', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -809,21 +835,22 @@ test('non-string with content type application/json SHOULD be serialized as json
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'application/json; charset=utf-8')
-      t.same(body.toString(), JSON.stringify({ key: 'hello world!' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ key: 'hello world!' }))
+      done()
     })
   })
 })
 
-test('non-string with custom json\'s content-type SHOULD be serialized as json', t => {
+test('non-string with custom json\'s content-type SHOULD be serialized as json', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -833,24 +860,26 @@ test('non-string with custom json\'s content-type SHOULD be serialized as json',
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], 'application/json; version=2; charset=utf-8')
-      t.same(body.toString(), JSON.stringify({ key: 'hello world!' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; version=2; charset=utf-8')
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ key: 'hello world!' }))
+      done()
     })
   })
 })
 
-test('non-string with custom json content type SHOULD be serialized as json', t => {
-  t.plan(16)
+test('non-string with custom json content type SHOULD be serialized as json', async t => {
+  t.plan(10)
 
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   const customSamples = {
     collectionjson: {
@@ -881,25 +910,27 @@ test('non-string with custom json content type SHOULD be serialized as json', t
     })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
-    Object.keys(customSamples).forEach((path) => {
+  await Promise.all(Object.keys(customSamples).map(path => {
+    return new Promise((resolve, reject) => {
       sget({
         method: 'GET',
         url: 'http://127.0.0.1:' + fastify.server.address().port + '/' + path
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
-        t.same(body.toString(), JSON.stringify(customSamples[path].sample))
+        if (err) {
+          reject(err)
+        }
+        t.assert.strictEqual(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
+        t.assert.deepStrictEqual(body.toString(), JSON.stringify(customSamples[path].sample))
+        resolve()
       })
     })
-  })
+  }))
 })
 
-test('error object with a content type that is not application/json should work', t => {
-  t.plan(6)
+test('error object with a content type that is not application/json should work', async t => {
+  t.plan(4)
 
   const fastify = Fastify()
 
@@ -913,32 +944,32 @@ test('error object with a content type that is not application/json should work'
     reply.send(new Error('some application error'))
   })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/text'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(JSON.parse(res.payload).message, 'some application error')
-  })
+  {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/text'
+    })
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(JSON.parse(res.payload).message, 'some application error')
+  }
 
-  fastify.inject({
-    method: 'GET',
-    url: '/html'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(JSON.parse(res.payload).message, 'some application error')
-  })
+  {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/html'
+    })
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(JSON.parse(res.payload).message, 'some application error')
+  }
 })
 
-test('undefined payload should be sent as-is', t => {
+test('undefined payload should be sent as-is', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify()
 
   fastify.addHook('onSend', function (request, reply, payload, done) {
-    t.equal(payload, undefined)
+    t.assert.strictEqual(payload, undefined)
     done()
   })
 
@@ -947,31 +978,33 @@ test('undefined payload should be sent as-is', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    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.headers['content-type'], undefined)
-      t.equal(response.headers['content-length'], undefined)
-      t.equal(body.length, 0)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], undefined)
+      t.assert.strictEqual(response.headers['content-length'], undefined)
+      t.assert.strictEqual(body.length, 0)
+      done()
     })
   })
 })
 
-test('for HEAD method, no body should be sent but content-length should be', t => {
-  t.plan(11)
+test('for HEAD method, no body should be sent but content-length should be', async t => {
+  t.plan(8)
 
   const fastify = Fastify()
+  t.after(() => fastify.close())
   const contentType = 'application/json; charset=utf-8'
   const bodySize = JSON.stringify({ foo: 'bar' }).length
 
   fastify.head('/', {
     onSend: function (request, reply, payload, done) {
-      t.equal(payload, undefined)
+      t.assert.strictEqual(payload, undefined)
       done()
     }
   }, function (req, reply) {
@@ -982,7 +1015,7 @@ test('for HEAD method, no body should be sent but content-length should be', t =
 
   fastify.head('/with/null', {
     onSend: function (request, reply, payload, done) {
-      t.equal(payload, 'null')
+      t.assert.strictEqual(payload, 'null')
       done()
     }
   }, function (req, reply) {
@@ -991,36 +1024,46 @@ test('for HEAD method, no body should be sent but content-length should be', t =
     reply.code(200).send(null)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
+  const promise1 = new Promise((resolve, reject) => {
     sget({
       method: 'HEAD',
       url: `http://127.0.0.1:${fastify.server.address().port}`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.headers['content-type'], contentType)
-      t.equal(response.headers['content-length'], bodySize.toString())
-      t.equal(body.length, 0)
+      if (err) {
+        reject(err)
+      }
+      t.assert.strictEqual(response.headers['content-type'], contentType)
+      t.assert.strictEqual(response.headers['content-length'], bodySize.toString())
+      t.assert.strictEqual(body.length, 0)
+      resolve()
     })
+  })
 
+  const promise2 = new Promise((resolve, reject) => {
     sget({
       method: 'HEAD',
       url: `http://127.0.0.1:${fastify.server.address().port}/with/null`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.headers['content-type'], contentType)
-      t.equal(response.headers['content-length'], bodySize.toString())
-      t.equal(body.length, 0)
+      if (err) {
+        reject(err)
+      }
+      t.assert.strictEqual(response.headers['content-type'], contentType)
+      t.assert.strictEqual(response.headers['content-length'], bodySize.toString())
+      t.assert.strictEqual(body.length, 0)
+      resolve()
     })
   })
+
+  await Promise.all([promise1, promise2])
 })
 
-test('reply.send(new NotFound()) should not invoke the 404 handler', t => {
-  t.plan(9)
+test('reply.send(new NotFound()) should not invoke the 404 handler', async t => {
+  t.plan(6)
 
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.setNotFoundHandler((req, reply) => {
     t.fail('Should not be called')
@@ -1038,42 +1081,50 @@ test('reply.send(new NotFound()) should not invoke the 404 handler', t => {
     done()
   }, { prefix: '/prefixed' })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
+  const promise1 = new Promise((resolve, reject) => {
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/not-found'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-      t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-      t.same(JSON.parse(body.toString()), {
+      if (err) {
+        reject(err)
+      }
+      t.assert.strictEqual(response.statusCode, 404)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.deepStrictEqual(JSON.parse(body.toString()), {
         statusCode: 404,
         error: 'Not Found',
         message: 'Not Found'
       })
+      resolve()
     })
+  })
 
+  const promise2 = new Promise((resolve, reject) => {
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/prefixed/not-found'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-      t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-      t.same(JSON.parse(body), {
+      if (err) {
+        reject(err)
+      }
+      t.assert.strictEqual(response.statusCode, 404)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.deepStrictEqual(JSON.parse(body.toString()), {
+        statusCode: 404,
         error: 'Not Found',
-        message: 'Not Found',
-        statusCode: 404
+        message: 'Not Found'
       })
+      resolve()
     })
   })
+
+  await Promise.all([promise1, promise2])
 })
 
-test('reply can set multiple instances of same header', t => {
+test('reply can set multiple instances of same header', (t, done) => {
   t.plan(4)
 
   const fastify = require('../../')()
@@ -1086,75 +1137,80 @@ test('reply can set multiple instances of same header', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
     }, (err, response, body) => {
-      t.error(err)
-      t.ok(response.headers['set-cookie'])
-      t.strictSame(response.headers['set-cookie'], ['one', 'two'])
+      t.assert.ifError(err)
+      t.assert.ok(response.headers['set-cookie'])
+      t.assert.deepStrictEqual(response.headers['set-cookie'], ['one', 'two'])
+      done()
     })
   })
 })
 
-test('reply.hasHeader returns correct values', t => {
+test('reply.hasHeader returns correct values', (t, done) => {
   t.plan(3)
 
   const fastify = require('../../')()
 
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
-    t.equal(reply.hasHeader('x-foo'), true)
-    t.equal(reply.hasHeader('x-bar'), false)
+    t.assert.strictEqual(reply.hasHeader('x-foo'), true)
+    t.assert.strictEqual(reply.hasHeader('x-bar'), false)
     reply.send()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
-    }, () => { })
+    }, () => {
+      done()
+    })
   })
 })
 
-test('reply.getHeader returns correct values', t => {
+test('reply.getHeader returns correct values', (t, done) => {
   t.plan(5)
 
   const fastify = require('../../')()
 
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
-    t.equal(reply.getHeader('x-foo'), 'foo')
+    t.assert.strictEqual(reply.getHeader('x-foo'), 'foo')
 
     reply.header('x-foo', 'bar')
-    t.strictSame(reply.getHeader('x-foo'), 'bar')
+    t.assert.deepStrictEqual(reply.getHeader('x-foo'), 'bar')
 
     reply.header('x-foo', 42)
-    t.strictSame(reply.getHeader('x-foo'), 42)
+    t.assert.deepStrictEqual(reply.getHeader('x-foo'), 42)
 
     reply.header('set-cookie', 'one')
     reply.header('set-cookie', 'two')
-    t.strictSame(reply.getHeader('set-cookie'), ['one', 'two'])
+    t.assert.deepStrictEqual(reply.getHeader('set-cookie'), ['one', 'two'])
 
     reply.send()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
-    }, () => { })
+    }, () => {
+      done()
+    })
   })
 })
 
-test('reply.getHeader returns raw header if there is not in the reply headers', t => {
+test('reply.getHeader returns raw header if there is not in the reply headers', (t) => {
   t.plan(1)
   const response = {
     setHeader: () => { },
@@ -1164,10 +1220,10 @@ test('reply.getHeader returns raw header if there is not in the reply headers',
     end: () => { }
   }
   const reply = new Reply(response, { onSend: [] }, null)
-  t.equal(reply.getHeader('foo'), 'bar')
+  t.assert.strictEqual(reply.getHeader('foo'), 'bar')
 })
 
-test('reply.getHeaders returns correct values', t => {
+test('reply.getHeaders returns correct values', (t, done) => {
   t.plan(3)
 
   const fastify = require('../../')()
@@ -1175,7 +1231,7 @@ test('reply.getHeaders returns correct values', t => {
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
 
-    t.strictSame(reply.getHeaders(), {
+    t.assert.deepStrictEqual(reply.getHeaders(), {
       'x-foo': 'foo'
     })
 
@@ -1183,7 +1239,7 @@ test('reply.getHeaders returns correct values', t => {
     reply.raw.setHeader('x-foo', 'foo2')
     reply.raw.setHeader('x-baz', 'baz')
 
-    t.strictSame(reply.getHeaders(), {
+    t.assert.deepStrictEqual(reply.getHeaders(), {
       'x-foo': 'foo',
       'x-bar': 'bar',
       'x-baz': 'baz'
@@ -1193,97 +1249,98 @@ test('reply.getHeaders returns correct values', t => {
   })
 
   fastify.inject('/headers', (err) => {
-    t.error(err)
+    t.assert.ifError(err)
+    done()
   })
 })
 
-test('reply.removeHeader can remove the value', t => {
-  t.plan(5)
+test('reply.removeHeader can remove the value', (t, done) => {
+  t.plan(4)
 
   const fastify = require('../../')()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
-    t.equal(reply.getHeader('x-foo'), 'foo')
+    t.assert.strictEqual(reply.getHeader('x-foo'), 'foo')
 
-    t.equal(reply.removeHeader('x-foo'), reply)
-    t.strictSame(reply.getHeader('x-foo'), undefined)
+    t.assert.strictEqual(reply.removeHeader('x-foo'), reply)
+    t.assert.deepStrictEqual(reply.getHeader('x-foo'), undefined)
 
     reply.send()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
     }, () => {
-      t.pass()
+      done()
     })
   })
 })
 
-test('reply.header can reset the value', t => {
-  t.plan(3)
+test('reply.header can reset the value', (t, done) => {
+  t.plan(2)
 
   const fastify = require('../../')()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
     reply.header('x-foo', undefined)
-    t.strictSame(reply.getHeader('x-foo'), '')
+    t.assert.deepStrictEqual(reply.getHeader('x-foo'), '')
 
     reply.send()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
     }, () => {
-      t.pass()
+      done()
     })
   })
 })
 
 // https://github.com/fastify/fastify/issues/3030
-test('reply.hasHeader computes raw and fastify headers', t => {
-  t.plan(4)
+test('reply.hasHeader computes raw and fastify headers', (t, done) => {
+  t.plan(3)
 
   const fastify = require('../../')()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/headers', function (req, reply) {
     reply.header('x-foo', 'foo')
     reply.raw.setHeader('x-bar', 'bar')
-    t.ok(reply.hasHeader('x-foo'))
-    t.ok(reply.hasHeader('x-bar'))
+    t.assert.ok(reply.hasHeader('x-foo'))
+    t.assert.ok(reply.hasHeader('x-bar'))
 
     reply.send()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
     }, () => {
-      t.pass()
+      done()
     })
   })
 })
 
-test('Reply should handle JSON content type with a charset', t => {
-  t.plan(16)
+test('Reply should handle JSON content type with a charset', async t => {
+  t.plan(8)
 
   const fastify = require('../../')()
 
@@ -1333,48 +1390,47 @@ test('Reply should handle JSON content type with a charset', t => {
       .send({ hello: 'world' })
   })
 
-  fastify.inject('/default', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
-  })
-
-  fastify.inject('/utf8', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
-  })
+  {
+    const res = await fastify.inject('/default')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+  }
 
-  fastify.inject('/utf16', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-16')
-  })
+  {
+    const res = await fastify.inject('/utf8')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+  }
 
-  fastify.inject('/utf32', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-32')
-  })
+  {
+    const res = await fastify.inject('/utf16')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-16')
+  }
 
-  fastify.inject('/type-utf8', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
-  })
+  {
+    const res = await fastify.inject('/utf32')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-32')
+  }
 
-  fastify.inject('/type-utf16', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-16')
-  })
+  {
+    const res = await fastify.inject('/type-utf8')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+  }
 
-  fastify.inject('/type-utf32', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-32')
-  })
+  {
+    const res = await fastify.inject('/type-utf16')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-16')
+  }
+  {
+    const res = await fastify.inject('/type-utf32')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-32')
+  }
 
-  fastify.inject('/no-space-type-utf32', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json;charset=utf-32')
-  })
+  {
+    const res = await fastify.inject('/no-space-type-utf32')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json;charset=utf-32')
+  }
 })
 
-test('Content type and charset set previously', t => {
+test('Content type and charset set previously', (t, done) => {
   t.plan(2)
 
   const fastify = require('../../')()
@@ -1389,12 +1445,13 @@ test('Content type and charset set previously', t => {
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-16')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-16')
+    done()
   })
 })
 
-test('.status() is an alias for .code()', t => {
+test('.status() is an alias for .code()', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -1403,32 +1460,35 @@ test('.status() is an alias for .code()', t => {
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 418)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 418)
+    done()
   })
 })
 
-test('.statusCode is getter and setter', t => {
+test('.statusCode is getter and setter', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
-    t.equal(reply.statusCode, 200, 'default status value')
+    t.assert.strictEqual(reply.statusCode, 200, 'default status value')
     reply.statusCode = 418
-    t.equal(reply.statusCode, 418)
+    t.assert.strictEqual(reply.statusCode, 418)
     reply.send()
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 418)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 418)
+    done()
   })
 })
 
-test('reply.header setting multiple cookies as multiple Set-Cookie headers', t => {
-  t.plan(7)
+test('reply.header setting multiple cookies as multiple Set-Cookie headers', async t => {
+  t.plan(4)
 
   const fastify = require('../../')()
+  t.after(() => fastify.close())
 
   fastify.get('/headers', function (req, reply) {
     reply
@@ -1439,28 +1499,28 @@ test('reply.header setting multiple cookies as multiple Set-Cookie headers', t =
       .send({})
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+  await fastify.listen({ port: 0 })
 
+  await new Promise((resolve, reject) => {
     sget({
       method: 'GET',
       url: 'http://127.0.0.1:' + fastify.server.address().port + '/headers'
     }, (err, response, body) => {
-      t.error(err)
-      t.ok(response.headers['set-cookie'])
-      t.strictSame(response.headers['set-cookie'], ['one', 'two', 'three', 'four', 'five', 'six'])
+      if (err) {
+        reject(err)
+      }
+      t.assert.ok(response.headers['set-cookie'])
+      t.assert.deepStrictEqual(response.headers['set-cookie'], ['one', 'two', 'three', 'four', 'five', 'six'])
+      resolve()
     })
   })
 
-  fastify.inject('/headers', (error, response) => {
-    t.error(error)
-    t.ok(response.headers['set-cookie'])
-    t.strictSame(response.headers['set-cookie'], ['one', 'two', 'three', 'four', 'five', 'six'])
-  })
+  const response = await fastify.inject('/headers')
+  t.assert.ok(response.headers['set-cookie'])
+  t.assert.deepStrictEqual(response.headers['set-cookie'], ['one', 'two', 'three', 'four', 'five', 'six'])
 })
 
-test('should throw when trying to modify the reply.sent property', t => {
+test('should throw when trying to modify the reply.sent property', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -1468,14 +1528,15 @@ test('should throw when trying to modify the reply.sent property', t => {
     try {
       reply.sent = true
     } catch (err) {
-      t.ok(err)
+      t.assert.ok(err)
       reply.send()
     }
   })
 
   fastify.inject('/', (err, res) => {
-    t.error(err)
-    t.pass()
+    t.assert.ifError(err)
+    t.assert.ok(true)
+    done()
   })
 })
 
@@ -1483,10 +1544,10 @@ test('reply.elapsedTime should return 0 before the timer is initialised on the r
   t.plan(1)
   const response = { statusCode: 200 }
   const reply = new Reply(response, null)
-  t.equal(reply.elapsedTime, 0)
+  t.assert.strictEqual(reply.elapsedTime, 0)
 })
 
-test('reply.elapsedTime should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {
+test('reply.elapsedTime should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', async t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1498,14 +1559,13 @@ test('reply.elapsedTime should return a number greater than 0 after the timer is
   })
 
   fastify.addHook('onResponse', (req, reply) => {
-    t.ok(reply.elapsedTime > 0)
-    t.end()
+    t.assert.ok(reply.elapsedTime > 0)
   })
 
-  fastify.inject({ method: 'GET', url: '/' })
+  await fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.elapsedTime should return the time since a request started while inflight', t => {
+test('reply.elapsedTime should return the time since a request started while inflight', async t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1525,14 +1585,13 @@ test('reply.elapsedTime should return the time since a request started while inf
   })
 
   fastify.addHook('onResponse', (req, reply) => {
-    t.ok(reply.elapsedTime > preValidationElapsedTime)
-    t.end()
+    t.assert.ok(reply.elapsedTime > preValidationElapsedTime)
   })
 
-  fastify.inject({ method: 'GET', url: '/' })
+  await fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply.elapsedTime should return the same value after a request is finished', t => {
+test('reply.elapsedTime should return the same value after a request is finished', async t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.route({
@@ -1544,19 +1603,18 @@ test('reply.elapsedTime should return the same value after a request is finished
   })
 
   fastify.addHook('onResponse', (req, reply) => {
-    t.equal(reply.elapsedTime, reply.elapsedTime)
-    t.end()
+    t.assert.strictEqual(reply.elapsedTime, reply.elapsedTime)
   })
 
-  fastify.inject({ method: 'GET', url: '/' })
+  await fastify.inject({ method: 'GET', url: '/' })
 })
 
-test('reply should use the custom serializer', t => {
+test('reply should use the custom serializer', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
   fastify.setReplySerializer((payload, statusCode) => {
-    t.same(payload, { foo: 'bar' })
-    t.equal(statusCode, 200)
+    t.assert.deepStrictEqual(payload, { foo: 'bar' })
+    t.assert.strictEqual(statusCode, 200)
     payload.foo = 'bar bar'
     return JSON.stringify(payload)
   })
@@ -1573,17 +1631,18 @@ test('reply should use the custom serializer', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"foo":"bar bar"}')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, '{"foo":"bar bar"}')
+    done()
   })
 })
 
-test('reply should use the right serializer in encapsulated context', t => {
-  t.plan(9)
+test('reply should use the right serializer in encapsulated context', async t => {
+  t.plan(6)
 
   const fastify = Fastify()
   fastify.setReplySerializer((payload) => {
-    t.same(payload, { foo: 'bar' })
+    t.assert.deepStrictEqual(payload, { foo: 'bar' })
     payload.foo = 'bar bar'
     return JSON.stringify(payload)
   })
@@ -1601,7 +1660,7 @@ test('reply should use the right serializer in encapsulated context', t => {
       handler: (req, reply) => { reply.send({ john: 'doo' }) }
     })
     instance.setReplySerializer((payload) => {
-      t.same(payload, { john: 'doo' })
+      t.assert.deepStrictEqual(payload, { john: 'doo' })
       payload.john = 'too too'
       return JSON.stringify(payload)
     })
@@ -1615,40 +1674,31 @@ test('reply should use the right serializer in encapsulated context', t => {
       handler: (req, reply) => { reply.send({ sweet: 'potato' }) }
     })
     instance.setReplySerializer((payload) => {
-      t.same(payload, { sweet: 'potato' })
+      t.assert.deepStrictEqual(payload, { sweet: 'potato' })
       payload.sweet = 'potato potato'
       return JSON.stringify(payload)
     })
     done()
   }, { prefix: 'sub' })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"foo":"bar bar"}')
-  })
+  {
+    const res = await fastify.inject('/')
+    t.assert.strictEqual(res.payload, '{"foo":"bar bar"}')
+  }
 
-  fastify.inject({
-    method: 'GET',
-    url: '/sub'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"john":"too too"}')
-  })
+  {
+    const res = await fastify.inject('/sub')
+    t.assert.strictEqual(res.payload, '{"john":"too too"}')
+  }
 
-  fastify.inject({
-    method: 'GET',
-    url: '/sub/sub'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"sweet":"potato potato"}')
-  })
+  {
+    const res = await fastify.inject('/sub/sub')
+    t.assert.strictEqual(res.payload, '{"sweet":"potato potato"}')
+  }
 })
 
-test('reply should use the right serializer in deep encapsulated context', t => {
-  t.plan(8)
+test('reply should use the right serializer in deep encapsulated context', async t => {
+  t.plan(5)
 
   const fastify = Fastify()
 
@@ -1665,7 +1715,7 @@ test('reply should use the right serializer in deep encapsulated context', t =>
       handler: (req, reply) => { reply.send({ john: 'doo' }) }
     })
     instance.setReplySerializer((payload) => {
-      t.same(payload, { john: 'doo' })
+      t.assert.deepStrictEqual(payload, { john: 'doo' })
       payload.john = 'too too'
       return JSON.stringify(payload)
     })
@@ -1677,7 +1727,7 @@ test('reply should use the right serializer in deep encapsulated context', t =>
         handler: (req, reply) => { reply.send({ john: 'deep' }) }
       })
       subInstance.setReplySerializer((payload) => {
-        t.same(payload, { john: 'deep' })
+        t.assert.deepStrictEqual(payload, { john: 'deep' })
         payload.john = 'deep deep'
         return JSON.stringify(payload)
       })
@@ -1686,32 +1736,21 @@ test('reply should use the right serializer in deep encapsulated context', t =>
     done()
   })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"foo":"bar"}')
-  })
-
-  fastify.inject({
-    method: 'GET',
-    url: '/sub'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"john":"too too"}')
-  })
-
-  fastify.inject({
-    method: 'GET',
-    url: '/deep'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"john":"deep deep"}')
-  })
+  {
+    const res = await fastify.inject('/')
+    t.assert.strictEqual(res.payload, '{"foo":"bar"}')
+  }
+  {
+    const res = await fastify.inject('/sub')
+    t.assert.strictEqual(res.payload, '{"john":"too too"}')
+  }
+  {
+    const res = await fastify.inject('/deep')
+    t.assert.strictEqual(res.payload, '{"john":"deep deep"}')
+  }
 })
 
-test('reply should use the route serializer', t => {
+test('reply should use the route serializer', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -1725,7 +1764,7 @@ test('reply should use the route serializer', t => {
     handler: (req, reply) => {
       reply
         .serializer((payload) => {
-          t.same(payload, { john: 'doo' })
+          t.assert.deepStrictEqual(payload, { john: 'doo' })
           payload.john = 'too too'
           return JSON.stringify(payload)
         })
@@ -1737,86 +1776,79 @@ test('reply should use the route serializer', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, '{"john":"too too"}')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, '{"john":"too too"}')
+    done()
   })
 })
 
-test('cannot set the replySerializer when the server is running', t => {
+test('cannot set the replySerializer when the server is running', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
     try {
       fastify.setReplySerializer(() => { })
-      t.fail('this serializer should not be setup')
+      t.assert.fail('this serializer should not be setup')
     } catch (e) {
-      t.equal(e.code, 'FST_ERR_INSTANCE_ALREADY_LISTENING')
+      t.assert.strictEqual(e.code, 'FST_ERR_INSTANCE_ALREADY_LISTENING')
+    } finally {
+      done()
     }
   })
 })
 
-test('reply should not call the custom serializer for errors and not found', t => {
-  t.plan(9)
+test('reply should not call the custom serializer for errors and not found', async t => {
+  t.plan(6)
 
   const fastify = Fastify()
   fastify.setReplySerializer((payload, statusCode) => {
-    t.same(payload, { foo: 'bar' })
-    t.equal(statusCode, 200)
+    t.assert.deepStrictEqual(payload, { foo: 'bar' })
+    t.assert.strictEqual(statusCode, 200)
     return JSON.stringify(payload)
   })
 
   fastify.get('/', (req, reply) => { reply.send({ foo: 'bar' }) })
   fastify.get('/err', (req, reply) => { reply.send(new Error('an error')) })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, '{"foo":"bar"}')
-  })
-
-  fastify.inject({
-    method: 'GET',
-    url: '/err'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-  })
-
-  fastify.inject({
-    method: 'GET',
-    url: '/not-existing'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
-  })
+  {
+    const res = await fastify.inject('/')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, '{"foo":"bar"}')
+  }
+  {
+    const res = await fastify.inject('/err')
+    t.assert.strictEqual(res.statusCode, 500)
+  }
+  {
+    const res = await fastify.inject('/not-existing')
+    t.assert.strictEqual(res.statusCode, 404)
+  }
 })
 
-test('reply.then', t => {
+test('reply.then', async t => {
   t.plan(4)
 
   function request () { }
 
-  t.test('without an error', t => {
+  await t.test('without an error', (t, done) => {
     t.plan(1)
 
     const response = new Writable()
     const reply = new Reply(response, request)
 
     reply.then(function () {
-      t.pass('fulfilled called')
+      t.assert.ok(true)
+      done()
     })
 
     response.destroy()
   })
 
-  t.test('with an error', t => {
+  await t.test('with an error', (t, done) => {
     t.plan(1)
 
     const response = new Writable()
@@ -1824,15 +1856,16 @@ test('reply.then', t => {
     const _err = new Error('kaboom')
 
     reply.then(function () {
-      t.fail('fulfilled called')
+      t.assert.fail('fulfilled called')
     }, function (err) {
-      t.equal(err, _err)
+      t.assert.strictEqual(err, _err)
+      done()
     })
 
     response.destroy(_err)
   })
 
-  t.test('with error but without reject callback', t => {
+  await t.test('with error but without reject callback', t => {
     t.plan(1)
 
     const response = new Writable()
@@ -1840,15 +1873,15 @@ test('reply.then', t => {
     const _err = new Error('kaboom')
 
     reply.then(function () {
-      t.fail('fulfilled called')
+      t.assert.fail('fulfilled called')
     })
 
-    t.pass()
+    t.assert.ok(true)
 
     response.destroy(_err)
   })
 
-  t.test('with error, without reject callback, with logger', t => {
+  await t.test('with error, without reject callback, with logger', (t, done) => {
     t.plan(1)
 
     const response = new Writable()
@@ -1856,13 +1889,14 @@ test('reply.then', t => {
     // spy logger
     reply.log = {
       warn: (message) => {
-        t.equal(message, 'unhandled rejection on reply.then')
+        t.assert.strictEqual(message, 'unhandled rejection on reply.then')
+        done()
       }
     }
     const _err = new Error('kaboom')
 
     reply.then(function () {
-      t.fail('fulfilled called')
+      t.assert.fail('fulfilled called')
     })
 
     response.destroy(_err)
@@ -1874,7 +1908,7 @@ test('reply.sent should read from response.writableEnded if it is defined', t =>
 
   const reply = new Reply({ writableEnded: true }, {}, {})
 
-  t.equal(reply.sent, true)
+  t.assert.strictEqual(reply.sent, true)
 })
 
 test('redirect to an invalid URL should not crash the server', async t => {
@@ -1884,7 +1918,7 @@ test('redirect to an invalid URL should not crash the server', async t => {
     url: '/redirect',
     handler: (req, reply) => {
       reply.log.warn = function mockWarn (obj, message) {
-        t.equal(message, 'Invalid character in header content ["location"]')
+        t.assert.strictEqual(message, 'Invalid character in header content ["location"]')
       }
 
       switch (req.query.useCase) {
@@ -1907,8 +1941,8 @@ test('redirect to an invalid URL should not crash the server', async t => {
 
   {
     const { response, body } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/redirect?useCase=1`)
-    t.equal(response.statusCode, 500)
-    t.same(JSON.parse(body), {
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(body), {
       statusCode: 500,
       code: 'ERR_INVALID_CHAR',
       error: 'Internal Server Error',
@@ -1917,14 +1951,14 @@ test('redirect to an invalid URL should not crash the server', async t => {
   }
   {
     const { response } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/redirect?useCase=2`)
-    t.equal(response.statusCode, 302)
-    t.equal(response.headers.location, '/?key=a%E2%80%99b')
+    t.assert.strictEqual(response.statusCode, 302)
+    t.assert.strictEqual(response.headers.location, '/?key=a%E2%80%99b')
   }
 
   {
     const { response } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/redirect?useCase=3`)
-    t.equal(response.statusCode, 302)
-    t.equal(response.headers.location, '/?key=ab')
+    t.assert.strictEqual(response.statusCode, 302)
+    t.assert.strictEqual(response.headers.location, '/?key=ab')
   }
 
   await fastify.close()
@@ -1937,7 +1971,7 @@ test('invalid response headers should not crash the server', async t => {
     url: '/bad-headers',
     handler: (req, reply) => {
       reply.log.warn = function mockWarn (obj, message) {
-        t.equal(message, 'Invalid character in header content ["smile-encoded"]', 'only the first invalid header is logged')
+        t.assert.strictEqual(message, 'Invalid character in header content ["smile-encoded"]', 'only the first invalid header is logged')
       }
 
       reply.header('foo', '$')
@@ -1952,8 +1986,8 @@ test('invalid response headers should not crash the server', async t => {
   await fastify.listen({ port: 0 })
 
   const { response, body } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/bad-headers`)
-  t.equal(response.statusCode, 500)
-  t.same(JSON.parse(body), {
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.deepStrictEqual(JSON.parse(body), {
     statusCode: 500,
     code: 'ERR_INVALID_CHAR',
     error: 'Internal Server Error',
@@ -1970,7 +2004,7 @@ test('invalid response headers when sending back an error', async t => {
     url: '/bad-headers',
     handler: (req, reply) => {
       reply.log.warn = function mockWarn (obj, message) {
-        t.equal(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
+        t.assert.strictEqual(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
       }
 
       reply.header('smile', '😄')
@@ -1981,8 +2015,8 @@ test('invalid response headers when sending back an error', async t => {
   await fastify.listen({ port: 0 })
 
   const { response, body } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/bad-headers`)
-  t.equal(response.statusCode, 500)
-  t.same(JSON.parse(body), {
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.deepStrictEqual(JSON.parse(body), {
     statusCode: 500,
     code: 'ERR_INVALID_CHAR',
     error: 'Internal Server Error',
@@ -1999,7 +2033,7 @@ test('invalid response headers and custom error handler', async t => {
     url: '/bad-headers',
     handler: (req, reply) => {
       reply.log.warn = function mockWarn (obj, message) {
-        t.equal(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
+        t.assert.strictEqual(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
       }
 
       reply.header('smile', '😄')
@@ -2008,15 +2042,15 @@ test('invalid response headers and custom error handler', async t => {
   })
 
   fastify.setErrorHandler(function (error, request, reply) {
-    t.equal(error.message, 'user land error', 'custom error handler receives the error')
+    t.assert.strictEqual(error.message, 'user land error', 'custom error handler receives the error')
     reply.status(500).send({ ops: true })
   })
 
   await fastify.listen({ port: 0 })
 
   const { response, body } = await doGet(`http://127.0.0.1:${fastify.server.address().port}/bad-headers`)
-  t.equal(response.statusCode, 500)
-  t.same(JSON.parse(body), {
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.deepStrictEqual(JSON.parse(body), {
     statusCode: 500,
     code: 'ERR_INVALID_CHAR',
     error: 'Internal Server Error',
@@ -2045,7 +2079,7 @@ test('reply.send will intercept ERR_HTTP_HEADERS_SENT and log an error message',
 
   const log = {
     warn: (msg) => {
-      t.equal(msg, 'Reply was already sent, did you forget to "return reply" in the "/hello" (GET) route?')
+      t.assert.strictEqual(msg, 'Reply was already sent, did you forget to "return reply" in the "/hello" (GET) route?')
     }
   }
 
@@ -2054,11 +2088,11 @@ test('reply.send will intercept ERR_HTTP_HEADERS_SENT and log an error message',
   try {
     reply.send('')
   } catch (err) {
-    t.equal(err.code, 'ERR_HTTP_HEADERS_SENT')
+    t.assert.strictEqual(err.code, 'ERR_HTTP_HEADERS_SENT')
   }
 })
 
-test('Uint8Array view of ArrayBuffer returns correct byteLength', t => {
+test('Uint8Array view of ArrayBuffer returns correct byteLength', (t, done) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -2069,17 +2103,18 @@ test('Uint8Array view of ArrayBuffer returns correct byteLength', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(fastify.close.bind(fastify))
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     fastify.inject({
       method: 'GET',
       url: '/'
     }, (err, response) => {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/octet-stream')
-      t.equal(response.headers['content-length'], '10')
-      t.same(response.rawPayload.byteLength, arrView.byteLength)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/octet-stream')
+      t.assert.strictEqual(response.headers['content-length'], '10')
+      t.assert.deepStrictEqual(response.rawPayload.byteLength, arrView.byteLength)
+      done()
     })
   })
 })