fastify 5.0.0 → 5.2.0

package/test/encapsulated-error-handler.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 
 // Because of how error handlers wrap things, following the control flow can be tricky
@@ -13,7 +13,7 @@ test('encapsulates an asynchronous error handler', async t => {
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(async function a (err) {
       // 3. the inner error handler catches the error, and throws a new error
-      t.equal(err.message, 'from_endpoint')
+      t.assert.strictEqual(err.message, 'from_endpoint')
       throw new Error('from_inner')
     })
     fastify.get('/encapsulated', async () => {
@@ -24,7 +24,7 @@ test('encapsulates an asynchronous error handler', async t => {
 
   fastify.setErrorHandler(async function b (err) {
     // 4. the outer error handler catches the error thrown by the inner error handler
-    t.equal(err.message, 'from_inner')
+    t.assert.strictEqual(err.message, 'from_inner')
     // 5. the outer error handler throws a new error
     throw new Error('from_outer')
   })
@@ -32,7 +32,7 @@ test('encapsulates an asynchronous error handler', async t => {
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // 6. the default error handler returns the error from the outer error handler
-  t.equal(res.json().message, 'from_outer')
+  t.assert.strictEqual(res.json().message, 'from_outer')
 })
 
 // See discussion in https://github.com/fastify/fastify/pull/5222#discussion_r1432573655
@@ -43,7 +43,7 @@ test('encapsulates a synchronous error handler', async t => {
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(function a (err) {
       // 3. the inner error handler catches the error, and throws a new error
-      t.equal(err.message, 'from_endpoint')
+      t.assert.strictEqual(err.message, 'from_endpoint')
       throw new Error('from_inner')
     })
     fastify.get('/encapsulated', async () => {
@@ -54,7 +54,7 @@ test('encapsulates a synchronous error handler', async t => {
 
   fastify.setErrorHandler(async function b (err) {
     // 4. the outer error handler catches the error thrown by the inner error handler
-    t.equal(err.message, 'from_inner')
+    t.assert.strictEqual(err.message, 'from_inner')
     // 5. the outer error handler throws a new error
     throw new Error('from_outer')
   })
@@ -62,7 +62,7 @@ test('encapsulates a synchronous error handler', async t => {
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // 6. the default error handler returns the error from the outer error handler
-  t.equal(res.json().message, 'from_outer')
+  t.assert.strictEqual(res.json().message, 'from_outer')
 })
 
 test('onError hook nested', async t => {
@@ -72,7 +72,7 @@ test('onError hook nested', async t => {
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(async function a (err) {
       // 4. the inner error handler catches the error, and throws a new error
-      t.equal(err.message, 'from_endpoint')
+      t.assert.strictEqual(err.message, 'from_endpoint')
       throw new Error('from_inner')
     })
     fastify.get('/encapsulated', async () => {
@@ -83,20 +83,20 @@ test('onError hook nested', async t => {
 
   fastify.setErrorHandler(async function b (err) {
     // 5. the outer error handler catches the error thrown by the inner error handler
-    t.equal(err.message, 'from_inner')
+    t.assert.strictEqual(err.message, 'from_inner')
     // 6. the outer error handler throws a new error
     throw new Error('from_outer')
   })
 
   fastify.addHook('onError', async function (request, reply, err) {
     // 3. the hook receives the error
-    t.equal(err.message, 'from_endpoint')
+    t.assert.strictEqual(err.message, 'from_endpoint')
   })
 
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // 7. the default error handler returns the error from the outer error handler
-  t.equal(res.json().message, 'from_outer')
+  t.assert.strictEqual(res.json().message, 'from_outer')
 })
 
 // See https://github.com/fastify/fastify/issues/5220
@@ -107,7 +107,7 @@ test('encapuslates an error handler, for errors thrown in hooks', async t => {
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(function a (err) {
       // 3. the inner error handler catches the error, and throws a new error
-      t.equal(err.message, 'from_hook')
+      t.assert.strictEqual(err.message, 'from_hook')
       throw new Error('from_inner')
     })
     fastify.addHook('onRequest', async () => {
@@ -119,7 +119,7 @@ test('encapuslates an error handler, for errors thrown in hooks', async t => {
 
   fastify.setErrorHandler(function b (err) {
     // 4. the outer error handler catches the error thrown by the inner error handler
-    t.equal(err.message, 'from_inner')
+    t.assert.strictEqual(err.message, 'from_inner')
     // 5. the outer error handler throws a new error
     throw new Error('from_outer')
   })
@@ -127,7 +127,7 @@ test('encapuslates an error handler, for errors thrown in hooks', async t => {
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // 6. the default error handler returns the error from the outer error handler
-  t.equal(res.json().message, 'from_outer')
+  t.assert.strictEqual(res.json().message, 'from_outer')
 })
 
 // See https://github.com/fastify/fastify/issues/5220
@@ -153,7 +153,7 @@ test('encapuslates many synchronous error handlers that rethrow errors', async t
     } else if (depth === 0) {
       fastify.setErrorHandler(function a (err) {
         // 3. innermost error handler catches the error, and throws a new error
-        t.equal(err.message, 'from_route')
+        t.assert.strictEqual(err.message, 'from_route')
         throw new Error(`from_handler_${depth}`)
       })
       fastify.get('/encapsulated', async () => {
@@ -163,7 +163,7 @@ test('encapuslates many synchronous error handlers that rethrow errors', async t
     } else {
       fastify.setErrorHandler(function d (err) {
         // 4 to {DEPTH+4}. error handlers each catch errors, and then throws a new error
-        t.equal(err.message, `from_handler_${depth - 1}`)
+        t.assert.strictEqual(err.message, `from_handler_${depth - 1}`)
         throw new Error(`from_handler_${depth}`)
       })
 
@@ -179,7 +179,7 @@ test('encapuslates many synchronous error handlers that rethrow errors', async t
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // {DEPTH+5}. the default error handler returns the error from the outermost error handler
-  t.equal(res.json().message, `from_handler_${DEPTH}`)
+  t.assert.strictEqual(res.json().message, `from_handler_${DEPTH}`)
 })
 
 // See https://github.com/fastify/fastify/issues/5220
@@ -207,7 +207,7 @@ test('encapuslates many asynchronous error handlers that rethrow errors', async
     } else if (depth === 0) {
       fastify.setErrorHandler(async function a (err) {
         // 3. innermost error handler catches the error, and throws a new error
-        t.equal(err.message, 'from_route')
+        t.assert.strictEqual(err.message, 'from_route')
         throw new Error(`from_handler_${depth}`)
       })
       fastify.get('/encapsulated', async () => {
@@ -217,7 +217,7 @@ test('encapuslates many asynchronous error handlers that rethrow errors', async
     } else {
       fastify.setErrorHandler(async function m (err) {
         // 4 to {DEPTH+4}. error handlers each catch errors, and then throws a new error
-        t.equal(err.message, `from_handler_${depth - 1}`)
+        t.assert.strictEqual(err.message, `from_handler_${depth - 1}`)
         throw new Error(`from_handler_${depth}`)
       })
 
@@ -233,5 +233,5 @@ test('encapuslates many asynchronous error handlers that rethrow errors', async
   // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
   // {DEPTH+5}. the default error handler returns the error from the outermost error handler
-  t.equal(res.json().message, `from_handler_${DEPTH}`)
+  t.assert.strictEqual(res.json().message, `from_handler_${DEPTH}`)
 })

package/test/esm/errorCodes.test.mjs

@@ -1,10 +1,10 @@
 import { errorCodes } from '../../fastify.js'
-import t from 'tap'
+import { test } from 'node:test'
 
-t.test('errorCodes in ESM', async t => {
+test('errorCodes in ESM', async t => {
   // test a custom fastify error using errorCodes with ESM
   const customError = errorCodes.FST_ERR_VALIDATION('custom error message')
-  t.ok(typeof customError !== 'undefined')
-  t.ok(customError instanceof errorCodes.FST_ERR_VALIDATION)
-  t.equal(customError.message, 'custom error message')
+  t.assert.ok(typeof customError !== 'undefined')
+  t.assert.ok(customError instanceof errorCodes.FST_ERR_VALIDATION)
+  t.assert.strictEqual(customError.message, 'custom error message')
 })

package/test/esm/esm.test.mjs

@@ -1,7 +1,7 @@
-import t from 'tap'
+import { test } from 'node:test'
 import Fastify from '../../fastify.js'
 
-t.test('esm support', async t => {
+test('esm support', async t => {
   const fastify = Fastify()
 
   fastify.register(import('./plugin.mjs'), { foo: 'bar' })
@@ -9,5 +9,5 @@ t.test('esm support', async t => {
 
   await fastify.ready()
 
-  t.equal(fastify.foo, 'bar')
+  t.assert.strictEqual(fastify.foo, 'bar')
 })

package/test/esm/named-exports.mjs

@@ -1,8 +1,8 @@
-import t from 'tap'
+import { test } from 'node:test'
 import { fastify } from '../../fastify.js'
 
 // This test is executed in index.test.js
-t.test('named exports support', async t => {
+test('named exports support', async t => {
   const app = fastify()
 
   app.register(import('./plugin.mjs'), { foo: 'bar' })
@@ -10,5 +10,5 @@ t.test('named exports support', async t => {
 
   await app.ready()
 
-  t.equal(app.foo, 'bar')
+  t.assert.strictEqual(app.foo, 'bar')
 })

package/test/esm/other.mjs

@@ -1,8 +1,8 @@
 // Imported in both index.test.js & esm.test.mjs
-import t from 'tap'
+import { strictEqual } from 'node:assert'
 
 async function other (fastify, opts) {
-  t.equal(fastify.foo, 'bar')
+  strictEqual(fastify.foo, 'bar')
 }
 
 export default other

package/test/fastify-instance.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const os = require('node:os')
 
@@ -13,7 +12,7 @@ const {
 
 test('root fastify instance is an object', t => {
   t.plan(1)
-  t.type(Fastify(), 'object')
+  t.assert.strictEqual(typeof Fastify(), 'object')
 })
 
 test('fastify instance should contains ajv options', t => {
@@ -25,7 +24,7 @@ test('fastify instance should contains ajv options', t => {
       }
     }
   })
-  t.same(fastify[kOptions].ajv, {
+  t.assert.deepStrictEqual(fastify[kOptions].ajv, {
     customOptions: {
       nullable: false
     },
@@ -43,7 +42,7 @@ test('fastify instance should contains ajv options.plugins nested arrays', t =>
       plugins: [[]]
     }
   })
-  t.same(fastify[kOptions].ajv, {
+  t.assert.deepStrictEqual(fastify[kOptions].ajv, {
     customOptions: {
       nullable: false
     },
@@ -53,7 +52,7 @@ test('fastify instance should contains ajv options.plugins nested arrays', t =>
 
 test('fastify instance get invalid ajv options', t => {
   t.plan(1)
-  t.throws(() => Fastify({
+  t.assert.throws(() => Fastify({
     ajv: {
       customOptions: 8
     }
@@ -62,7 +61,7 @@ test('fastify instance get invalid ajv options', t => {
 
 test('fastify instance get invalid ajv options.plugins', t => {
   t.plan(1)
-  t.throws(() => Fastify({
+  t.assert.throws(() => Fastify({
     ajv: {
       customOptions: {},
       plugins: 8
@@ -73,9 +72,9 @@ test('fastify instance get invalid ajv options.plugins', t => {
 test('fastify instance should contain default errorHandler', t => {
   t.plan(3)
   const fastify = Fastify()
-  t.ok(fastify[kErrorHandler].func instanceof Function)
-  t.same(fastify.errorHandler, fastify[kErrorHandler].func)
-  t.same(Object.getOwnPropertyDescriptor(fastify, 'errorHandler').set, undefined)
+  t.assert.ok(fastify[kErrorHandler].func instanceof Function)
+  t.assert.deepStrictEqual(fastify.errorHandler, fastify[kErrorHandler].func)
+  t.assert.deepStrictEqual(Object.getOwnPropertyDescriptor(fastify, 'errorHandler').set, undefined)
 })
 
 test('errorHandler in plugin should be separate from the external one', async t => {
@@ -89,24 +88,24 @@ test('errorHandler in plugin should be separate from the external one', async t
 
     instance.setErrorHandler(inPluginErrHandler)
 
-    t.notSame(instance.errorHandler, fastify.errorHandler)
-    t.equal(instance.errorHandler.name, 'bound inPluginErrHandler')
+    t.assert.notDeepStrictEqual(instance.errorHandler, fastify.errorHandler)
+    t.assert.strictEqual(instance.errorHandler.name, 'bound inPluginErrHandler')
 
     done()
   })
 
   await fastify.ready()
 
-  t.ok(fastify[kErrorHandler].func instanceof Function)
-  t.same(fastify.errorHandler, fastify[kErrorHandler].func)
+  t.assert.ok(fastify[kErrorHandler].func instanceof Function)
+  t.assert.deepStrictEqual(fastify.errorHandler, fastify[kErrorHandler].func)
 })
 
 test('fastify instance should contain default childLoggerFactory', t => {
   t.plan(3)
   const fastify = Fastify()
-  t.ok(fastify[kChildLoggerFactory] instanceof Function)
-  t.same(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
-  t.same(Object.getOwnPropertyDescriptor(fastify, 'childLoggerFactory').set, undefined)
+  t.assert.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.assert.deepStrictEqual(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+  t.assert.deepStrictEqual(Object.getOwnPropertyDescriptor(fastify, 'childLoggerFactory').set, undefined)
 })
 
 test('childLoggerFactory in plugin should be separate from the external one', async t => {
@@ -120,16 +119,16 @@ test('childLoggerFactory in plugin should be separate from the external one', as
 
     instance.setChildLoggerFactory(inPluginLoggerFactory)
 
-    t.notSame(instance.childLoggerFactory, fastify.childLoggerFactory)
-    t.equal(instance.childLoggerFactory.name, 'inPluginLoggerFactory')
+    t.assert.notDeepStrictEqual(instance.childLoggerFactory, fastify.childLoggerFactory)
+    t.assert.strictEqual(instance.childLoggerFactory.name, 'inPluginLoggerFactory')
 
     done()
   })
 
   await fastify.ready()
 
-  t.ok(fastify[kChildLoggerFactory] instanceof Function)
-  t.same(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+  t.assert.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.assert.deepStrictEqual(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
 })
 
 test('ready should resolve in order when called multiply times (promises only)', async (t) => {
@@ -142,7 +141,7 @@ test('ready should resolve in order when called multiply times (promises only)',
 
   await Promise.all(promises)
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should reject in order when called multiply times (promises only)', async (t) => {
@@ -159,7 +158,7 @@ test('ready should reject in order when called multiply times (promises only)',
 
   await Promise.all(promises)
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should reject in order when called multiply times (callbacks only)', async (t) => {
@@ -174,10 +173,10 @@ test('ready should reject in order when called multiply times (callbacks only)',
   expectedOrder.map((id) => app.ready(() => result.push(id)))
 
   await app.ready().catch(err => {
-    t.equal(err.message, 'test')
+    t.assert.strictEqual(err.message, 'test')
   })
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should resolve in order when called multiply times (callbacks only)', async (t) => {
@@ -189,7 +188,7 @@ test('ready should resolve in order when called multiply times (callbacks only)'
 
   await app.ready()
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should resolve in order when called multiply times (mixed)', async (t) => {
@@ -207,7 +206,7 @@ test('ready should resolve in order when called multiply times (mixed)', async (
 
   await app.ready()
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should reject in order when called multiply times (mixed)', async (t) => {
@@ -228,10 +227,10 @@ test('ready should reject in order when called multiply times (mixed)', async (t
   }
 
   await app.ready().catch(err => {
-    t.equal(err.message, 'test')
+    t.assert.strictEqual(err.message, 'test')
   })
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('ready should resolve in order when called multiply times (mixed)', async (t) => {
@@ -249,7 +248,7 @@ test('ready should resolve in order when called multiply times (mixed)', async (
 
   await app.ready()
 
-  t.strictSame(result, expectedOrder, 'Should resolve in order')
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
 })
 
 test('fastify instance should contains listeningOrigin property (with port and host)', async t => {
@@ -258,7 +257,7 @@ test('fastify instance should contains listeningOrigin property (with port and h
   const host = '127.0.0.1'
   const fastify = Fastify()
   await fastify.listen({ port, host })
-  t.same(fastify.listeningOrigin, `http://${host}:${port}`)
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `http://${host}:${port}`)
   await fastify.close()
 })
 
@@ -268,7 +267,7 @@ test('fastify instance should contains listeningOrigin property (with port and h
   const host = '127.0.0.1'
   const fastify = Fastify({ https: {} })
   await fastify.listen({ port, host })
-  t.same(fastify.listeningOrigin, `https://${host}:${port}`)
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `https://${host}:${port}`)
   await fastify.close()
 })
 
@@ -276,7 +275,7 @@ test('fastify instance should contains listeningOrigin property (unix socket)',
   const fastify = Fastify()
   const path = `fastify.${Date.now()}.sock`
   await fastify.listen({ path })
-  t.same(fastify.listeningOrigin, path)
+  t.assert.deepStrictEqual(fastify.listeningOrigin, path)
   await fastify.close()
 })
 
@@ -286,6 +285,6 @@ test('fastify instance should contains listeningOrigin property (IPv6)', async t
   const host = '::1'
   const fastify = Fastify()
   await fastify.listen({ port, host })
-  t.same(fastify.listeningOrigin, `http://[::1]:${port}`)
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `http://[::1]:${port}`)
   await fastify.close()
 })

package/test/{findRoute.test.js → find-route.test.js}

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const fastifyPlugin = require('fastify-plugin')
 
@@ -15,7 +15,7 @@ test('findRoute should return null when route cannot be found due to a different
     handler: (req, reply) => reply.send(typeof req.params.artistId)
   })
 
-  t.equal(fastify.findRoute({
+  t.assert.strictEqual(fastify.findRoute({
     method: 'POST',
     url: '/artists/:artistId'
   }), null)
@@ -46,7 +46,8 @@ test('findRoute should return an immutable route to avoid leaking and runtime ro
     method: 'GET',
     url: '/artists/:artistId'
   })
-  t.same(route.params, { artistId: ':artistId' })
+
+  t.assert.strictEqual(route.params.artistId, ':artistId')
 })
 
 test('findRoute should return null when when url is not passed', t => {
@@ -60,7 +61,7 @@ test('findRoute should return null when when url is not passed', t => {
     handler: (req, reply) => reply.send(typeof req.params.artistId)
   })
 
-  t.equal(fastify.findRoute({
+  t.assert.strictEqual(fastify.findRoute({
     method: 'POST'
   }), null)
 })
@@ -76,7 +77,7 @@ test('findRoute should return null when route cannot be found due to a different
     handler: (req, reply) => reply.send(typeof req.params.artistId)
   })
 
-  t.equal(fastify.findRoute({
+  t.assert.strictEqual(fastify.findRoute({
     method: 'GET',
     url: '/books/:bookId'
   }), null)
@@ -99,11 +100,10 @@ test('findRoute should return the route when found', t => {
     method: 'GET',
     url: '/artists/:artistId'
   })
-
-  t.same(route.params, { artistId: ':artistId' })
+  t.assert.strictEqual(route.params.artistId, ':artistId')
 })
 
-test('findRoute should work correctly when used within plugins', t => {
+test('findRoute should work correctly when used within plugins', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = (req, reply) => reply.send(typeof req.params.artistId)
@@ -128,7 +128,8 @@ test('findRoute should work correctly when used within plugins', t => {
   fastify.register(fastifyPlugin(validateRoutePlugin))
 
   fastify.ready(() => {
-    t.equal(fastify.validateRoutes.validateParams(), true)
+    t.assert.strictEqual(fastify.validateRoutes.validateParams(), true)
+    done()
   })
 })
 
@@ -147,5 +148,5 @@ test('findRoute should not expose store', t => {
     method: 'GET',
     url: '/artists/:artistId'
   })
-  t.equal(route.store, undefined)
+  t.assert.strictEqual(route.store, undefined)
 })

package/test/fluent-schema.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const S = require('fluent-json-schema')
 
-test('use fluent-json-schema object', t => {
-  t.plan(15)
+test('use fluent-json-schema object', async (t) => {
+  t.plan(10)
   const fastify = Fastify()
 
   fastify.post('/:id', {
@@ -24,73 +23,62 @@ test('use fluent-json-schema object', t => {
     }
   })
 
-  // check params
-  fastify.inject({
+  const res1 = await fastify.inject({
     method: 'POST',
     url: '/1',
     headers: { 'x-custom': 'me@me.me' },
     query: { surname: 'bar' },
     payload: { name: 'foo' }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'params/id must be >= 42' })
   })
+  t.assert.strictEqual(res1.statusCode, 400)
+  t.assert.deepStrictEqual(res1.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'params/id must be >= 42' })
 
   // check header
-  fastify.inject({
+  const res2 = await fastify.inject({
     method: 'POST',
     url: '/42',
     headers: { 'x-custom': 'invalid' },
     query: { surname: 'bar' },
     payload: { name: 'foo' }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'headers/x-custom must match format "email"' })
   })
+  t.assert.strictEqual(res2.statusCode, 400)
+  t.assert.deepStrictEqual(res2.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'headers/x-custom must match format "email"' })
 
   // check query
-  fastify.inject({
+  const res3 = await fastify.inject({
     method: 'POST',
     url: '/42',
     headers: { 'x-custom': 'me@me.me' },
     query: { },
     payload: { name: 'foo' }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'querystring must have required property \'surname\'' })
   })
+  t.assert.strictEqual(res3.statusCode, 400)
+  t.assert.deepStrictEqual(res3.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'querystring must have required property \'surname\'' })
 
   // check body
-  fastify.inject({
+  const res4 = await fastify.inject({
     method: 'POST',
     url: '/42',
     headers: { 'x-custom': 'me@me.me' },
     query: { surname: 'bar' },
     payload: { name: [1, 2, 3] }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'body/name must be string' })
   })
+  t.assert.strictEqual(res4.statusCode, 400)
+  t.assert.deepStrictEqual(res4.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'body/name must be string' })
 
   // check response
-  fastify.inject({
+  const res5 = await fastify.inject({
     method: 'POST',
     url: '/42',
     headers: { 'x-custom': 'me@me.me' },
     query: { surname: 'bar' },
     payload: { name: 'foo' }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { name: 'a', surname: 'b' })
   })
+  t.assert.strictEqual(res5.statusCode, 200)
+  t.assert.deepStrictEqual(res5.json(), { name: 'a', surname: 'b' })
 })
 
-test('use complex fluent-json-schema object', t => {
+test('use complex fluent-json-schema object', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -113,10 +101,13 @@ test('use complex fluent-json-schema object', t => {
     .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
 
   fastify.post('/the/url', { schema: { body: bodyJsonSchema } }, () => { })
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('use fluent schema and plain JSON schema', t => {
+test('use fluent schema and plain JSON schema', (t, done) => {
   t.plan(1)
 
   const fastify = Fastify()
@@ -154,10 +145,13 @@ test('use fluent schema and plain JSON schema', t => {
     .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
 
   fastify.post('/the/url', { schema: { body: bodyJsonSchema } }, () => { })
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Should call valueOf internally', t => {
+test('Should call valueOf internally', (t, done) => {
   t.plan(1)
 
   const fastify = new Fastify()
@@ -208,5 +202,8 @@ test('Should call valueOf internally', t => {
     }
   })
 
-  fastify.ready(t.error)
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })