fastify 5.3.2 → 5.3.3

package/test/schema-feature.test.js

@@ -1,12 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
 const { FSTWRN001 } = require('../lib/warnings')
+const { waitForCb } = require('./toolkit')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -15,22 +16,23 @@ const echoBody = (req, reply) => { reply.send(req.body) }
   test(`Should expose ${f} function`, t => {
     t.plan(1)
     const fastify = Fastify()
-    t.equal(typeof fastify[f], 'function')
+    t.assert.strictEqual(typeof fastify[f], 'function')
   })
 })
 
 ;['setValidatorCompiler', 'setSerializerCompiler'].forEach(f => {
-  test(`cannot call ${f} after binding`, t => {
+  test(`cannot call ${f} after binding`, (t, testDone) => {
     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[f](() => { })
-        t.fail()
+        t.assert.fail()
       } catch (e) {
-        t.pass()
+        t.assert.ok(true)
+        testDone()
       }
     })
   })
@@ -41,7 +43,7 @@ test('The schemas should be added to an internal storage', t => {
   const fastify = Fastify()
   const schema = { $id: 'id', my: 'schema' }
   fastify.addSchema(schema)
-  t.same(fastify[kSchemaController].schemaBucket.store, { id: schema })
+  t.assert.deepStrictEqual(fastify[kSchemaController].schemaBucket.store, { id: schema })
 })
 
 test('The schemas should be accessible via getSchemas', t => {
@@ -55,10 +57,10 @@ test('The schemas should be accessible via getSchemas', t => {
   }
 
   Object.values(schemas).forEach(schema => { fastify.addSchema(schema) })
-  t.same(fastify.getSchemas(), schemas)
+  t.assert.deepStrictEqual(fastify.getSchemas(), schemas)
 })
 
-test('The schema should be accessible by id via getSchema', t => {
+test('The schema should be accessible by id via getSchema', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -68,41 +70,50 @@ test('The schema should be accessible by id via getSchema', t => {
     { $id: 'bcd', my: 'schema', properties: { a: 'a', b: 1 } }
   ]
   schemas.forEach(schema => { fastify.addSchema(schema) })
-  t.same(fastify.getSchema('abc'), schemas[1])
-  t.same(fastify.getSchema('id'), schemas[0])
-  t.same(fastify.getSchema('foo'), undefined)
+  t.assert.deepStrictEqual(fastify.getSchema('abc'), schemas[1])
+  t.assert.deepStrictEqual(fastify.getSchema('id'), schemas[0])
+  t.assert.deepStrictEqual(fastify.getSchema('foo'), undefined)
 
   fastify.register((instance, opts, done) => {
     const pluginSchema = { $id: 'cde', my: 'schema' }
     instance.addSchema(pluginSchema)
-    t.same(instance.getSchema('cde'), pluginSchema)
+    t.assert.deepStrictEqual(instance.getSchema('cde'), pluginSchema)
     done()
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get validatorCompiler after setValidatorCompiler', t => {
+test('Get validatorCompiler after setValidatorCompiler', (t, testDone) => {
   t.plan(2)
   const myCompiler = () => { }
   const fastify = Fastify()
   fastify.setValidatorCompiler(myCompiler)
   const sc = fastify.validatorCompiler
-  t.ok(Object.is(myCompiler, sc))
-  fastify.ready(err => t.error(err))
+  t.assert.ok(Object.is(myCompiler, sc))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get serializerCompiler after setSerializerCompiler', t => {
+test('Get serializerCompiler after setSerializerCompiler', (t, testDone) => {
   t.plan(2)
   const myCompiler = () => { }
   const fastify = Fastify()
   fastify.setSerializerCompiler(myCompiler)
   const sc = fastify.serializerCompiler
-  t.ok(Object.is(myCompiler, sc))
-  fastify.ready(err => t.error(err))
+  t.assert.ok(Object.is(myCompiler, sc))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get compilers is empty when settle on routes', t => {
+test('Get compilers is empty when settle on routes', (t, testDone) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -130,9 +141,10 @@ test('Get compilers is empty when settle on routes', t => {
     payload: {},
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(fastify.validatorCompiler, undefined)
-    t.equal(fastify.serializerCompiler, undefined)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.validatorCompiler, undefined)
+    t.assert.strictEqual(fastify.serializerCompiler, undefined)
+    testDone()
   })
 })
 
@@ -141,9 +153,9 @@ test('Should throw if the $id property is missing', t => {
   const fastify = Fastify()
   try {
     fastify.addSchema({ type: 'string' })
-    t.fail()
+    t.assert.fail()
   } catch (err) {
-    t.equal(err.code, 'FST_ERR_SCH_MISSING_ID')
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_MISSING_ID')
   }
 })
 
@@ -155,12 +167,12 @@ test('Cannot add multiple times the same id', t => {
   try {
     fastify.addSchema({ $id: 'id' })
   } catch (err) {
-    t.equal(err.code, 'FST_ERR_SCH_ALREADY_PRESENT')
-    t.equal(err.message, 'Schema with id \'id\' already declared!')
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_ALREADY_PRESENT')
+    t.assert.strictEqual(err.message, 'Schema with id \'id\' already declared!')
   }
 })
 
-test('Cannot add schema for query and querystring', t => {
+test('Cannot add schema for query and querystring', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -183,12 +195,13 @@ test('Cannot add schema for query and querystring', t => {
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_DUPLICATE')
-    t.equal(err.message, 'Schema with \'querystring\' already present!')
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_DUPLICATE')
+    t.assert.strictEqual(err.message, 'Schema with \'querystring\' already present!')
+    testDone()
   })
 })
 
-test('Should throw of the schema does not exists in input', t => {
+test('Should throw of the schema does not exists in input', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -205,12 +218,13 @@ test('Should throw of the schema does not exists in input', t => {
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
-    t.equal(err.message, "Failed building the validation schema for GET: /:id, due to error can't resolve reference #notExist from id #")
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.assert.strictEqual(err.message, "Failed building the validation schema for GET: /:id, due to error can't resolve reference #notExist from id #")
+    testDone()
   })
 })
 
-test('Should throw if schema is missing for content type', t => {
+test('Should throw if schema is missing for content type', (t, testDone) => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -226,12 +240,13 @@ test('Should throw if schema is missing for content type', t => {
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_CONTENT_MISSING_SCHEMA')
-    t.equal(err.message, "Schema is missing for the content type 'application/json'")
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_CONTENT_MISSING_SCHEMA')
+    t.assert.strictEqual(err.message, "Schema is missing for the content type 'application/json'")
+    testDone()
   })
 })
 
-test('Should throw of the schema does not exists in output', t => {
+test('Should throw of the schema does not exists in output', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -250,12 +265,13 @@ test('Should throw of the schema does not exists in output', t => {
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
-    t.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot find reference.*/) // error from fast-json-stringify
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
+    t.assert.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot find reference.*/) // error from fast-json-stringify
+    testDone()
   })
 })
 
-test('Should not change the input schemas', t => {
+test('Should not change the input schemas', (t, testDone) => {
   t.plan(4)
 
   const theSchema = {
@@ -294,24 +310,25 @@ test('Should not change the input schemas', t => {
     method: 'POST',
     payload: { name: 'Foo', surname: 'Bar' }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { name: 'Foo' })
-    t.ok(theSchema.$id, 'the $id is not removed')
-    t.same(fastify.getSchema('helloSchema'), theSchema)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { name: 'Foo' })
+    t.assert.ok(theSchema.$id, 'the $id is not removed')
+    t.assert.deepStrictEqual(fastify.getSchema('helloSchema'), theSchema)
+    testDone()
   })
 })
 
-test('Should emit warning if the schema headers is undefined', t => {
+test('Should emit warning if the schema headers is undefined', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, FSTWRN001.code)
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN001.code)
   }
 
-  t.teardown(() => {
+  t.after(() => {
     process.removeListener('warning', onWarning)
     FSTWRN001.emitted = false
   })
@@ -327,22 +344,23 @@ test('Should emit warning if the schema headers is undefined', t => {
     method: 'POST',
     url: '/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Should emit warning if the schema body is undefined', t => {
+test('Should emit warning if the schema body is undefined', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, FSTWRN001.code)
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN001.code)
   }
 
-  t.teardown(() => {
+  t.after(() => {
     process.removeListener('warning', onWarning)
     FSTWRN001.emitted = false
   })
@@ -358,22 +376,23 @@ test('Should emit warning if the schema body is undefined', t => {
     method: 'POST',
     url: '/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Should emit warning if the schema query is undefined', t => {
+test('Should emit warning if the schema query is undefined', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, FSTWRN001.code)
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN001.code)
   }
 
-  t.teardown(() => {
+  t.after(() => {
     process.removeListener('warning', onWarning)
     FSTWRN001.emitted = false
   })
@@ -389,22 +408,23 @@ test('Should emit warning if the schema query is undefined', t => {
     method: 'POST',
     url: '/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Should emit warning if the schema params is undefined', t => {
+test('Should emit warning if the schema params is undefined', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, FSTWRN001.code)
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN001.code)
   }
 
-  t.teardown(() => {
+  t.after(() => {
     process.removeListener('warning', onWarning)
     FSTWRN001.emitted = false
   })
@@ -420,12 +440,13 @@ test('Should emit warning if the schema params is undefined', t => {
     method: 'POST',
     url: '/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Should emit a warning for every route with undefined schema', t => {
+test('Should emit a warning for every route with undefined schema', (t, testDone) => {
   t.plan(16)
   const fastify = Fastify()
 
@@ -436,13 +457,13 @@ test('Should emit a warning for every route with undefined schema', t => {
   // - 2 - GET and HEAD for /undefinedBody/:id
   // => 3 x 4 assertions = 12 assertions
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, FSTWRN001.code)
-    t.equal(runs++, expectedWarningEmitted.shift())
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN001.code)
+    t.assert.strictEqual(runs++, expectedWarningEmitted.shift())
   }
 
   process.on('warning', onWarning)
-  t.teardown(() => {
+  t.after(() => {
     process.removeListener('warning', onWarning)
     FSTWRN001.emitted = false
   })
@@ -465,20 +486,21 @@ test('Should emit a warning for every route with undefined schema', t => {
     method: 'GET',
     url: '/undefinedParams/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
     method: 'GET',
     url: '/undefinedBody/123'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('First level $ref', t => {
+test('First level $ref', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -506,8 +528,9 @@ test('First level $ref', t => {
     method: 'GET',
     url: '/123'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { id: 246 })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { id: 246 })
+    testDone()
   })
 })
 
@@ -516,38 +539,38 @@ test('Customize validator compiler in instance and route', t => {
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
-    t.equal(method, 'POST') // run 4 times
-    t.equal(url, '/:id') // run 4 times
+    t.assert.strictEqual(method, 'POST') // run 4 times
+    t.assert.strictEqual(url, '/:id') // run 4 times
     switch (httpPart) {
       case 'body':
-        t.pass('body evaluated')
+        t.assert.ok('body evaluated')
         return body => {
-          t.same(body, { foo: ['bar', 'BAR'] })
+          t.assert.deepStrictEqual(body, { foo: ['bar', 'BAR'] })
           return true
         }
       case 'params':
-        t.pass('params evaluated')
+        t.assert.ok('params evaluated')
         return params => {
-          t.same(params, { id: 1234 })
+          t.assert.strictEqual(params.id, '1234')
           return true
         }
       case 'querystring':
-        t.pass('querystring evaluated')
+        t.assert.ok('querystring evaluated')
         return query => {
-          t.same(query, { lang: 'en' })
+          t.assert.strictEqual(query.lang, 'en')
           return true
         }
       case 'headers':
-        t.pass('headers evaluated')
+        t.assert.ok('headers evaluated')
         return headers => {
-          t.match(headers, { x: 'hello' })
+          t.assert.strictEqual(headers.x, 'hello')
           return true
         }
       case '2xx':
-        t.fail('the validator doesn\'t process the response')
+        t.assert.fail('the validator doesn\'t process the response')
         break
       default:
-        t.fail(`unknown httpPart ${httpPart}`)
+        t.assert.fail(`unknown httpPart ${httpPart}`)
     }
   })
 
@@ -592,8 +615,8 @@ test('Customize validator compiler in instance and route', t => {
   fastify.get('/wow/:id', {
     handler: echoParams,
     validatorCompiler: ({ schema, method, url, httpPart }) => {
-      t.equal(method, 'GET') // run 3 times (params, headers, query)
-      t.equal(url, '/wow/:id') // run 4 times
+      t.assert.strictEqual(method, 'GET') // run 3 times (params, headers, query)
+      t.assert.strictEqual(url, '/wow/:id') // run 4 times
       return () => { return true } // ignore the validation
     },
     schema: {
@@ -626,6 +649,8 @@ test('Customize validator compiler in instance and route', t => {
     }
   })
 
+  const { stepIn, patience } = waitForCb({ steps: 2 })
+
   fastify.inject({
     url: '/1234',
     method: 'POST',
@@ -633,9 +658,10 @@ test('Customize validator compiler in instance and route', t => {
     query: { lang: 'en' },
     payload: { foo: ['bar', 'BAR'] }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: ['bar', 'BAR'] })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: ['bar', 'BAR'] })
+    stepIn()
   })
 
   fastify.inject({
@@ -644,13 +670,16 @@ test('Customize validator compiler in instance and route', t => {
     headers: { x: 'hello' },
     query: { lang: 'jp' } // not in the enum
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200) // the validation is always true
-    t.same(res.json(), {})
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200) // the validation is always true
+    t.assert.deepStrictEqual(res.json(), {})
+    stepIn()
   })
+
+  return patience
 })
 
-test('Use the same schema across multiple routes', t => {
+test('Use the same schema across multiple routes', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -694,20 +723,21 @@ test('Use the same schema across multiple routes', t => {
     method: 'GET',
     url: '/first/123'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, 'number')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, 'number')
   })
 
   fastify.inject({
     method: 'GET',
     url: '/second/123'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, 'number')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, 'number')
+    testDone()
   })
 })
 
-test('Encapsulation should intervene', t => {
+test('Encapsulation should intervene', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -738,12 +768,13 @@ test('Encapsulation should intervene', t => {
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
-    t.equal(err.message, "Failed building the validation schema for GET: /:id, due to error can't resolve reference encapsulation#/properties/id from id #")
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.assert.strictEqual(err.message, "Failed building the validation schema for GET: /:id, due to error can't resolve reference encapsulation#/properties/id from id #")
+    testDone()
   })
 })
 
-test('Encapsulation isolation', t => {
+test('Encapsulation isolation', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -757,10 +788,13 @@ test('Encapsulation isolation', t => {
     done()
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Add schema after register', t => {
+test('Add schema after register', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -784,8 +818,8 @@ test('Add schema after register', t => {
     try {
       instance.addSchema({ $id: 'test' })
     } catch (err) {
-      t.equal(err.code, 'FST_ERR_SCH_ALREADY_PRESENT')
-      t.equal(err.message, 'Schema with id \'test\' already declared!')
+      t.assert.strictEqual(err.code, 'FST_ERR_SCH_ALREADY_PRESENT')
+      t.assert.strictEqual(err.message, 'Schema with id \'test\' already declared!')
     }
     done()
   })
@@ -794,13 +828,14 @@ test('Add schema after register', t => {
     method: 'GET',
     url: '/4242'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { id: 4242 })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { id: 4242 })
+    testDone()
   })
 })
 
-test('Encapsulation isolation for getSchemas', t => {
+test('Encapsulation isolation for getSchemas', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -835,15 +870,16 @@ test('Encapsulation isolation for getSchemas', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.same(fastify.getSchemas(), { z: schemas.z })
-    t.same(pluginDeepOneSide.getSchemas(), { z: schemas.z, a: schemas.a })
-    t.same(pluginDeepOne.getSchemas(), { z: schemas.z, b: schemas.b })
-    t.same(pluginDeepTwo.getSchemas(), { z: schemas.z, b: schemas.b, c: schemas.c })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(fastify.getSchemas(), { z: schemas.z })
+    t.assert.deepStrictEqual(pluginDeepOneSide.getSchemas(), { z: schemas.z, a: schemas.a })
+    t.assert.deepStrictEqual(pluginDeepOne.getSchemas(), { z: schemas.z, b: schemas.b })
+    t.assert.deepStrictEqual(pluginDeepTwo.getSchemas(), { z: schemas.z, b: schemas.b, c: schemas.c })
+    testDone()
   })
 })
 
-test('Use the same schema id in different places', t => {
+test('Use the same schema id in different places', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -887,10 +923,13 @@ test('Use the same schema id in different places', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get schema anyway should not add `properties` if allOf is present', t => {
+test('Get schema anyway should not add `properties` if allOf is present', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -924,10 +963,13 @@ test('Get schema anyway should not add `properties` if allOf is present', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get schema anyway should not add `properties` if oneOf is present', t => {
+test('Get schema anyway should not add `properties` if oneOf is present', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -961,10 +1003,13 @@ test('Get schema anyway should not add `properties` if oneOf is present', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Get schema anyway should not add `properties` if anyOf is present', t => {
+test('Get schema anyway should not add `properties` if anyOf is present', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -998,10 +1043,13 @@ test('Get schema anyway should not add `properties` if anyOf is present', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('Shared schema should be ignored in string enum', t => {
+test('Shared schema should be ignored in string enum', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -1021,12 +1069,13 @@ test('Shared schema should be ignored in string enum', t => {
   })
 
   fastify.inject('/C%23', (err, res) => {
-    t.error(err)
-    t.same(res.json(), { lang: 'C#' })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { lang: 'C#' })
+    testDone()
   })
 })
 
-test('Shared schema should NOT be ignored in != string enum', t => {
+test('Shared schema should NOT be ignored in != string enum', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -1053,12 +1102,13 @@ test('Shared schema should NOT be ignored in != string enum', t => {
     method: 'POST',
     payload: { lang: 'C#' }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { lang: 'C#' })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { lang: 'C#' })
+    testDone()
   })
 })
 
-test('Case insensitive header validation', t => {
+test('Case insensitive header validation', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
   fastify.get('/', {
@@ -1082,12 +1132,13 @@ test('Case insensitive header validation', t => {
       FooBar: 'Baz'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, 'Baz')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, 'Baz')
+    testDone()
   })
 })
 
-test('Not evaluate json-schema $schema keyword', t => {
+test('Not evaluate json-schema $schema keyword', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
   fastify.post('/', {
@@ -1110,19 +1161,20 @@ test('Not evaluate json-schema $schema keyword', t => {
     method: 'POST',
     body: { hello: 'world', foo: 'bar' }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { hello: 'world' })
+    testDone()
   })
 })
 
-test('Validation context in validation result', t => {
+test('Validation context in validation result', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
   // custom error handler to expose validation context in response, so we can test it later
   fastify.setErrorHandler((err, request, reply) => {
-    t.equal(err instanceof Error, true)
-    t.ok(err.validation, 'detailed errors')
-    t.equal(err.validationContext, 'body')
+    t.assert.strictEqual(err instanceof Error, true)
+    t.assert.ok(err.validation, 'detailed errors')
+    t.assert.strictEqual(err.validationContext, 'body')
     reply.code(400).send()
   })
   fastify.post('/', {
@@ -1142,12 +1194,13 @@ test('Validation context in validation result', t => {
     url: '/',
     payload: {} // body lacks required field, will fail validation
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    testDone()
   })
 })
 
-test('The schema build should not modify the input', t => {
+test('The schema build should not modify the input', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -1205,14 +1258,15 @@ test('The schema build should not modify the input', t => {
     }
   })
 
-  t.ok(first.$id)
+  t.assert.ok(first.$id)
   fastify.ready(err => {
-    t.error(err)
-    t.ok(first.$id)
+    t.assert.ifError(err)
+    t.assert.ok(first.$id)
+    testDone()
   })
 })
 
-test('Cross schema reference with encapsulation references', t => {
+test('Cross schema reference with encapsulation references', (t, testDone) => {
   t.plan(1)
 
   const fastify = Fastify()
@@ -1262,29 +1316,30 @@ test('Cross schema reference with encapsulation references', t => {
   fastify.get('/get', { schema: { params: refItem, response: { 200: refItem } } }, () => { })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('Check how many AJV instances are built #1', t => {
+test('Check how many AJV instances are built #1', (t, testDone) => {
   t.plan(12)
   const fastify = Fastify()
   addRandomRoute(fastify) // this trigger the schema validation creation
-  t.notOk(fastify.validatorCompiler, 'validator not initialized')
+  t.assert.ok(!fastify.validatorCompiler, 'validator not initialized')
 
   const instances = []
   fastify.register((instance, opts, done) => {
-    t.notOk(fastify.validatorCompiler, 'validator not initialized')
+    t.assert.ok(!fastify.validatorCompiler, 'validator not initialized')
     instances.push(instance)
     done()
   })
   fastify.register((instance, opts, done) => {
-    t.notOk(fastify.validatorCompiler, 'validator not initialized')
+    t.assert.ok(!fastify.validatorCompiler, 'validator not initialized')
     addRandomRoute(instance)
     instances.push(instance)
     done()
     instance.register((instance, opts, done) => {
-      t.notOk(fastify.validatorCompiler, 'validator not initialized')
+      t.assert.ok(!fastify.validatorCompiler, 'validator not initialized')
       addRandomRoute(instance)
       instances.push(instance)
       done()
@@ -1292,18 +1347,19 @@ test('Check how many AJV instances are built #1', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
+    t.assert.ifError(err)
 
-    t.ok(fastify.validatorCompiler, 'validator initialized on preReady')
+    t.assert.ok(fastify.validatorCompiler, 'validator initialized on preReady')
     fastify.validatorCompiler.checkPointer = true
     instances.forEach(i => {
-      t.ok(i.validatorCompiler, 'validator initialized on preReady')
-      t.equal(i.validatorCompiler.checkPointer, true, 'validator is only one for all the instances')
+      t.assert.ok(i.validatorCompiler, 'validator initialized on preReady')
+      t.assert.strictEqual(i.validatorCompiler.checkPointer, true, 'validator is only one for all the instances')
     })
+    testDone()
   })
 })
 
-test('onReady hook has the compilers ready', t => {
+test('onReady hook has the compilers ready', (t, testDone) => {
   t.plan(6)
 
   const fastify = Fastify()
@@ -1317,16 +1373,16 @@ test('onReady hook has the compilers ready', t => {
   })
 
   fastify.addHook('onReady', function (done) {
-    t.ok(this.validatorCompiler)
-    t.ok(this.serializerCompiler)
+    t.assert.ok(this.validatorCompiler)
+    t.assert.ok(this.serializerCompiler)
     done()
   })
 
   let hookCallCounter = 0
   fastify.register(async (i, o) => {
     i.addHook('onReady', function (done) {
-      t.ok(this.validatorCompiler)
-      t.ok(this.serializerCompiler)
+      t.assert.ok(this.validatorCompiler)
+      t.assert.ok(this.serializerCompiler)
       done()
     })
 
@@ -1339,44 +1395,45 @@ test('onReady hook has the compilers ready', t => {
   })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(hookCallCounter, 1, 'it is called once')
+    t.assert.ifError(err)
+    t.assert.strictEqual(hookCallCounter, 1, 'it is called once')
+    testDone()
   })
 })
 
-test('Check how many AJV instances are built #2 - verify validatorPool', t => {
+test('Check how many AJV instances are built #2 - verify validatorPool', (t, testDone) => {
   t.plan(13)
   const fastify = Fastify()
-  t.notOk(fastify.validatorCompiler, 'validator not initialized')
+  t.assert.ok(!fastify.validatorCompiler, 'validator not initialized')
 
   fastify.register(function sibling1 (instance, opts, done) {
     addRandomRoute(instance)
-    t.notOk(instance.validatorCompiler, 'validator not initialized')
+    t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
     instance.ready(() => {
-      t.ok(instance.validatorCompiler, 'validator is initialized')
+      t.assert.ok(instance.validatorCompiler, 'validator is initialized')
       instance.validatorCompiler.sharedPool = 1
     })
     instance.after(() => {
-      t.notOk(instance.validatorCompiler, 'validator not initialized')
+      t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
     })
     done()
   })
 
   fastify.register(function sibling2 (instance, opts, done) {
     addRandomRoute(instance)
-    t.notOk(instance.validatorCompiler, 'validator not initialized')
+    t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
     instance.ready(() => {
-      t.equal(instance.validatorCompiler.sharedPool, 1, 'this context must share the validator with the same schemas')
+      t.assert.strictEqual(instance.validatorCompiler.sharedPool, 1, 'this context must share the validator with the same schemas')
       instance.validatorCompiler.sharedPool = 2
     })
     instance.after(() => {
-      t.notOk(instance.validatorCompiler, 'validator not initialized')
+      t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
     })
 
     instance.register((instance, opts, done) => {
-      t.notOk(instance.validatorCompiler, 'validator not initialized')
+      t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
       instance.ready(() => {
-        t.equal(instance.validatorCompiler.sharedPool, 2, 'this context must share the validator of the parent')
+        t.assert.strictEqual(instance.validatorCompiler.sharedPool, 2, 'this context must share the validator of the parent')
       })
       done()
     })
@@ -1389,15 +1446,18 @@ test('Check how many AJV instances are built #2 - verify validatorPool', t => {
     // this trigger to don't reuse the same compiler pool
     instance.addSchema({ $id: 'diff', type: 'object' })
 
-    t.notOk(instance.validatorCompiler, 'validator not initialized')
+    t.assert.ok(!instance.validatorCompiler, 'validator not initialized')
     instance.ready(() => {
-      t.ok(instance.validatorCompiler, 'validator is initialized')
-      t.notOk(instance.validatorCompiler.sharedPool, 'this context has its own compiler')
+      t.assert.ok(instance.validatorCompiler, 'validator is initialized')
+      t.assert.ok(!instance.validatorCompiler.sharedPool, 'this context has its own compiler')
     })
     done()
   })
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
 function addRandomRoute (server) {
@@ -1407,7 +1467,7 @@ function addRandomRoute (server) {
   )
 }
 
-test('Add schema order should not break the startup', t => {
+test('Add schema order should not break the startup', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -1433,10 +1493,13 @@ test('Add schema order should not break the startup', t => {
     }
   }, () => {})
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('The schema compiler recreate itself if needed', t => {
+test('The schema compiler recreate itself if needed', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -1463,23 +1526,26 @@ test('The schema compiler recreate itself if needed', t => {
     done()
   })
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
 test('Schema controller setter', t => {
   t.plan(2)
   Fastify({ schemaController: {} })
-  t.pass('allow empty object')
+  t.assert.ok('allow empty object')
 
   try {
     Fastify({ schemaController: { bucket: {} } })
     t.fail('the bucket option must be a function')
   } catch (err) {
-    t.equal(err.message, "schemaController.bucket option should be a function, instead got 'object'")
+    t.assert.strictEqual(err.message, "schemaController.bucket option should be a function, instead got 'object'")
   }
 })
 
-test('Schema controller bucket', t => {
+test('Schema controller bucket', (t, testDone) => {
   t.plan(10)
 
   let added = 0
@@ -1489,7 +1555,7 @@ test('Schema controller bucket', t => {
 
   function factoryBucket (storeInit) {
     builtBucket++
-    t.same(initStoreQueue.pop(), storeInit)
+    t.assert.deepStrictEqual(initStoreQueue.pop(), storeInit)
     const store = new Map(storeInit)
     return {
       add (schema) {
@@ -1516,13 +1582,13 @@ test('Schema controller bucket', t => {
   fastify.register(async (instance) => {
     instance.addSchema({ $id: 'b', type: 'string' })
     instance.addHook('onReady', function (done) {
-      t.equal(instance.getSchemas().size, 2)
+      t.assert.strictEqual(instance.getSchemas().size, 2)
       done()
     })
     instance.register(async (subinstance) => {
       subinstance.addSchema({ $id: 'c', type: 'string' })
       subinstance.addHook('onReady', function (done) {
-        t.equal(subinstance.getSchemas().size, 3)
+        t.assert.strictEqual(subinstance.getSchemas().size, 3)
         done()
       })
     })
@@ -1530,7 +1596,7 @@ test('Schema controller bucket', t => {
 
   fastify.register(async (instance) => {
     instance.addHook('onReady', function (done) {
-      t.equal(instance.getSchemas().size, 1)
+      t.assert.strictEqual(instance.getSchemas().size, 1)
       done()
     })
   })
@@ -1538,20 +1604,21 @@ test('Schema controller bucket', t => {
   fastify.addSchema({ $id: 'a', type: 'string' })
 
   fastify.ready(err => {
-    t.error(err)
-    t.equal(added, 3, 'three schema added')
-    t.equal(builtBucket, 4, 'one bucket built for every register call + 1 for the root instance')
+    t.assert.ifError(err)
+    t.assert.strictEqual(added, 3, 'three schema added')
+    t.assert.strictEqual(builtBucket, 4, 'one bucket built for every register call + 1 for the root instance')
+    testDone()
   })
 })
 
-test('setSchemaController per instance', t => {
+test('setSchemaController per instance', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify({})
 
   fastify.register(async (instance1) => {
     instance1.setSchemaController({
       bucket: function factoryBucket (storeInit) {
-        t.pass('instance1 has created the bucket')
+        t.assert.ok('instance1 has created the bucket')
         return {
           add (schema) { t.fail('add is not called') },
           getSchema (id) { t.fail('getSchema is not called') },
@@ -1566,19 +1633,19 @@ test('setSchemaController per instance', t => {
 
     instance2.setSchemaController({
       bucket: function factoryBucket (storeInit) {
-        t.pass('instance2 has created the bucket')
+        t.assert.ok('instance2 has created the bucket')
         const map = {}
         return {
           add (schema) {
-            t.equal(schema.$id, bSchema.$id, 'add is called')
+            t.assert.strictEqual(schema.$id, bSchema.$id, 'add is called')
             map[schema.$id] = schema
           },
           getSchema (id) {
-            t.pass('getSchema is called')
+            t.assert.ok('getSchema is called')
             return map[id]
           },
           getSchemas () {
-            t.pass('getSchemas is called')
+            t.assert.ok('getSchemas is called')
           }
         }
       }
@@ -1588,12 +1655,15 @@ test('setSchemaController per instance', t => {
 
     instance2.addHook('onReady', function (done) {
       instance2.getSchemas()
-      t.same(instance2.getSchema('b'), bSchema, 'the schema are loaded')
+      t.assert.deepStrictEqual(instance2.getSchema('b'), bSchema, 'the schema are loaded')
       done()
     })
   })
 
-  fastify.ready(err => { t.error(err) })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
 test('setSchemaController: Inherits correctly parent schemas with a customized validator instance', async t => {
@@ -1628,8 +1698,8 @@ test('setSchemaController: Inherits correctly parent schemas with a customized v
       compilersFactory: {
         buildValidator: function (externalSchemas) {
           const schemaKeys = Object.keys(externalSchemas)
-          t.equal(schemaKeys.length, 2, 'Contains same number of schemas')
-          t.hasStrict([someSchema, errorResponseSchema], Object.values(externalSchemas), 'Contains expected schemas')
+          t.assert.strictEqual(schemaKeys.length, 2, 'Contains same number of schemas')
+          t.assert.deepStrictEqual([someSchema, errorResponseSchema], Object.values(externalSchemas), 'Contains expected schemas')
           for (const key of schemaKeys) {
             if (customAjv.getSchema(key) == null) {
               customAjv.addSchema(externalSchemas[key], key)
@@ -1678,9 +1748,9 @@ test('setSchemaController: Inherits correctly parent schemas with a customized v
   })
   const json = res.json()
 
-  t.equal(json.message, 'querystring/msg must be array')
-  t.equal(json.statusCode, 400)
-  t.equal(res.statusCode, 400, 'Should not coerce the string into array')
+  t.assert.strictEqual(json.message, 'querystring/msg must be array')
+  t.assert.strictEqual(json.statusCode, 400)
+  t.assert.strictEqual(res.statusCode, 400, 'Should not coerce the string into array')
 })
 
 test('setSchemaController: Inherits buildSerializer from parent if not present within the instance', async t => {
@@ -1786,17 +1856,17 @@ test('setSchemaController: Inherits buildSerializer from parent if not present w
     method: 'GET',
     url: '/',
     query: {
-      msg: 'string'
+      msg: ['string']
     }
   })
   const json = res.json()
 
-  t.equal(json.statusCode, 400)
-  t.equal(json.message, 'querystring/msg must be array')
-  t.equal(rootSerializerCalled, 1, 'Should be called from the child')
-  t.equal(rootValidatorCalled, 0, 'Should not be called from the child')
-  t.equal(childValidatorCalled, 1, 'Should be called from the child')
-  t.equal(res.statusCode, 400, 'Should not coerce the string into array')
+  t.assert.strictEqual(json.statusCode, 400)
+  t.assert.strictEqual(json.message, 'querystring/msg must be array')
+  t.assert.strictEqual(rootSerializerCalled, 1, 'Should be called from the child')
+  t.assert.strictEqual(rootValidatorCalled, 0, 'Should not be called from the child')
+  t.assert.strictEqual(childValidatorCalled, 1, 'Should be called from the child')
+  t.assert.strictEqual(res.statusCode, 400, 'Should not coerce the string into array')
 })
 
 test('setSchemaController: Inherits buildValidator from parent if not present within the instance', async t => {
@@ -1911,12 +1981,12 @@ test('setSchemaController: Inherits buildValidator from parent if not present wi
   })
   const json = res.json()
 
-  t.equal(json.statusCode, 400)
-  t.equal(json.message, 'querystring/msg must be array')
-  t.equal(rootSerializerCalled, 0, 'Should be called from the child')
-  t.equal(rootValidatorCalled, 1, 'Should not be called from the child')
-  t.equal(childSerializerCalled, 1, 'Should be called from the child')
-  t.equal(res.statusCode, 400, 'Should not coerce the string into array')
+  t.assert.strictEqual(json.statusCode, 400)
+  t.assert.strictEqual(json.message, 'querystring/msg must be array')
+  t.assert.strictEqual(rootSerializerCalled, 0, 'Should be called from the child')
+  t.assert.strictEqual(rootValidatorCalled, 1, 'Should not be called from the child')
+  t.assert.strictEqual(childSerializerCalled, 1, 'Should be called from the child')
+  t.assert.strictEqual(res.statusCode, 400, 'Should not coerce the string into array')
 })
 
 test('Should throw if not default validator passed', async t => {
@@ -1938,8 +2008,8 @@ test('Should throw if not default validator passed', async t => {
       compilersFactory: {
         buildValidator: function (externalSchemas) {
           const schemaKeys = Object.keys(externalSchemas)
-          t.equal(schemaKeys.length, 2)
-          t.same(schemaKeys, ['some', 'another'])
+          t.assert.strictEqual(schemaKeys.length, 2)
+          t.assert.deepStrictEqual(schemaKeys, ['some', 'another'])
 
           for (const key of schemaKeys) {
             if (customAjv.getSchema(key) == null) {
@@ -2003,10 +2073,10 @@ test('Should throw if not default validator passed', async t => {
       }
     })
 
-    t.equal(res.json().message, 'querystring/msg must be array')
-    t.equal(res.statusCode, 400, 'Should not coerce the string into array')
+    t.assert.strictEqual(res.json().message, 'querystring/msg must be array')
+    t.assert.strictEqual(res.statusCode, 400, 'Should not coerce the string into array')
   } catch (err) {
-    t.error(err)
+    t.assert.ifError(err)
   }
 })
 
@@ -2070,14 +2140,14 @@ test('Should coerce the array if the default validator is used', async t => {
       }
     })
 
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { msg: ['string'] }, 'Should coerce the string into array')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { msg: ['string'] }, 'Should coerce the string into array')
   } catch (err) {
-    t.error(err)
+    t.assert.ifError(err)
   }
 })
 
-test('Should return a human-friendly error if response status codes are not specified', t => {
+test('Should return a human-friendly error if response status codes are not specified', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -2096,8 +2166,9 @@ test('Should return a human-friendly error if response status codes are not spec
   })
 
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
-    t.match(err.message, 'Failed building the serialization schema for GET: /, due to error response schemas should be nested under a valid status code, e.g { 2xx: { type: "object" } }')
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
+    t.assert.strictEqual(err.message, 'Failed building the serialization schema for GET: /, due to error response schemas should be nested under a valid status code, e.g { 2xx: { type: "object" } }')
+    testDone()
   })
 })
 
@@ -2110,7 +2181,7 @@ test('setSchemaController: custom validator instance should not mutate headers s
     compilersFactory: {
       buildValidator: function () {
         return ({ schema, method, url, httpPart }) => {
-          t.type(schema, Headers)
+          t.assert.ok(schema instanceof Headers)
           return () => {}
         }
       }