fastify 5.3.2 → 5.4.0

package/test/schema-validation.test.js

@@ -1,11 +1,12 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const { request } = require('undici')
 
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
+const { waitForCb } = require('./toolkit')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -70,7 +71,7 @@ const schemaArtist = {
   required: ['name', 'work']
 }
 
-test('Basic validation test', t => {
+test('Basic validation test', (t, testDone) => {
   t.plan(6)
 
   const fastify = Fastify()
@@ -82,6 +83,7 @@ test('Basic validation test', t => {
     reply.code(200).send(req.body.name)
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     payload: {
@@ -90,23 +92,25 @@ test('Basic validation test', t => {
     },
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'michelangelo')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'michelangelo')
+    t.assert.strictEqual(res.statusCode, 200)
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     payload: { name: 'michelangelo' },
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Different schema per content type', t => {
+test('Different schema per content type', (t, testDone) => {
   t.plan(12)
 
   const fastify = Fastify()
@@ -135,6 +139,7 @@ test('Different schema per content type', t => {
     return reply.send(req.body)
   })
 
+  const completion = waitForCb({ steps: 4 })
   fastify.inject({
     url: '/',
     method: 'POST',
@@ -144,46 +149,48 @@ test('Different schema per content type', t => {
       work: 'sculptor, painter, architect and poet'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload).name, 'michelangelo')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload).name, 'michelangelo')
+    t.assert.strictEqual(res.statusCode, 200)
+    completion.stepIn()
   })
-
   fastify.inject({
     url: '/',
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: { name: 'michelangelo' }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
-
   fastify.inject({
     url: '/',
     method: 'POST',
     headers: { 'Content-Type': 'application/octet-stream' },
     body: Buffer.from('AAAAAAAA')
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'AAAAAAAA')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'AAAAAAAA')
+    t.assert.strictEqual(res.statusCode, 200)
+    completion.stepIn()
   })
-
   fastify.inject({
     url: '/',
     method: 'POST',
     headers: { 'Content-Type': 'text/plain' },
     body: 'AAAAAAAA'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'AAAAAAAA')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'AAAAAAAA')
+    t.assert.strictEqual(res.statusCode, 200)
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Skip validation if no schema for content type', t => {
+test('Skip validation if no schema for content type', (t, testDone) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -201,20 +208,20 @@ test('Skip validation if no schema for content type', t => {
   }, async function (req, reply) {
     return reply.send(req.body)
   })
-
   fastify.inject({
     url: '/',
     method: 'POST',
     headers: { 'Content-Type': 'text/plain' },
     body: 'AAAAAAAA'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'AAAAAAAA')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'AAAAAAAA')
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Skip validation if no content type schemas', t => {
+test('Skip validation if no content type schemas', (t, testDone) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -229,20 +236,20 @@ test('Skip validation if no content type schemas', t => {
   }, async function (req, reply) {
     return reply.send(req.body)
   })
-
   fastify.inject({
     url: '/',
     method: 'POST',
     headers: { 'Content-Type': 'text/plain' },
     body: 'AAAAAAAA'
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'AAAAAAAA')
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'AAAAAAAA')
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('External AJV instance', t => {
+test('External AJV instance', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -255,7 +262,7 @@ test('External AJV instance', t => {
   fastify.addSchema(schemaBRefToA)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
-    t.pass('custom validator compiler called')
+    t.assert.ok('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -269,26 +276,29 @@ test('External AJV instance', t => {
     }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { foo: 42 }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { foo: 'not a number' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Encapsulation', t => {
+test('Encapsulation', (t, testDone) => {
   t.plan(21)
 
   const fastify = Fastify()
@@ -302,7 +312,7 @@ test('Encapsulation', t => {
 
   fastify.register((instance, opts, done) => {
     const validator = ({ schema, method, url, httpPart }) => {
-      t.pass('custom validator compiler called')
+      t.assert.ok('custom validator compiler called')
       return ajv.compile(schema)
     }
     instance.setValidatorCompiler(validator)
@@ -316,7 +326,7 @@ test('Encapsulation', t => {
     instance.register((instance, opts, done) => {
       instance.post('/two', {
         handler (req, reply) {
-          t.same(instance.validatorCompiler, validator)
+          t.assert.deepStrictEqual(instance.validatorCompiler, validator)
           reply.send({ foo: 'two' })
         },
         schema: {
@@ -330,7 +340,7 @@ test('Encapsulation', t => {
       instance.post('/three', {
         validatorCompiler: anotherValidator,
         handler (req, reply) {
-          t.same(instance.validatorCompiler, validator, 'the route validator does not change the instance one')
+          t.assert.deepStrictEqual(instance.validatorCompiler, validator, 'the route validator does not change the instance one')
           reply.send({ foo: 'three' })
         },
         schema: {
@@ -344,72 +354,75 @@ test('Encapsulation', t => {
 
   fastify.register((instance, opts, done) => {
     instance.post('/clean', function (req, reply) {
-      t.equal(instance.validatorCompiler, undefined)
+      t.assert.strictEqual(instance.validatorCompiler, undefined)
       reply.send({ foo: 'bar' })
     })
     done()
   })
 
+  const completion = waitForCb({ steps: 6 })
   fastify.inject({
     method: 'POST',
     url: '/one',
     payload: { foo: 1 }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: 'one' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: 'one' })
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/one',
     payload: { wrongFoo: 'bar' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/two',
     payload: { foo: 2 }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: 'two' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: 'two' })
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/two',
     payload: { wrongFoo: 'bar' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/three',
     payload: { wrongFoo: 'but works' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: 'three' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: 'three' })
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/clean',
     payload: { wrongFoo: 'bar' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: 'bar' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: 'bar' })
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Triple $ref with a simple $id', t => {
+test('Triple $ref with a simple $id', (t, testDone) => {
   t.plan(7)
 
   const fastify = Fastify()
@@ -424,7 +437,7 @@ test('Triple $ref with a simple $id', t => {
   fastify.addSchema(schemaCRefToB)
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
-    t.pass('custom validator compiler called')
+    t.assert.ok('custom validator compiler called')
     return ajv.compile(schema)
   })
 
@@ -438,28 +451,31 @@ test('Triple $ref with a simple $id', t => {
     }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { foo: 43 }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { foo: 105 })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { foo: 105 })
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { fool: 'bar' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json().message, "body must have required property 'foo'")
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(res.json().message, "body must have required property 'foo'")
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Extending schema', t => {
+test('Extending schema', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -499,7 +515,6 @@ test('Extending schema', t => {
       }
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -510,10 +525,9 @@ test('Extending schema', t => {
       }
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -525,12 +539,13 @@ test('Extending schema', t => {
       }
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    testDone()
   })
 })
 
-test('Should work with nested ids', t => {
+test('Should work with nested ids', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -560,6 +575,7 @@ test('Should work with nested ids', t => {
     }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/123',
@@ -567,11 +583,11 @@ test('Should work with nested ids', t => {
       hello: 'world'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'number')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'number')
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/abc',
@@ -579,14 +595,16 @@ test('Should work with nested ids', t => {
       hello: 'world'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.equal(res.json().message, 'params/id must be number')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.strictEqual(res.json().message, 'params/id must be number')
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Use the same schema across multiple routes', t => {
-  t.plan(8)
+test('Use the same schema across multiple routes', async (t) => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.addSchema({
@@ -611,34 +629,35 @@ test('Use the same schema across multiple routes', t => {
     }
   })
 
-  ;[
+  const validTestCases = [
     '/first/123',
     '/second/123'
-  ].forEach(url => {
-    fastify.inject({
+  ]
+
+  for (const url of validTestCases) {
+    const res = await fastify.inject({
       url,
       method: 'GET'
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.payload, 'number')
     })
-  })
 
-  ;[
+    t.assert.strictEqual(res.payload, 'number')
+  }
+
+  const invalidTestCases = [
     '/first/abc',
     '/second/abc'
-  ].forEach(url => {
-    fastify.inject({
+  ]
+
+  for (const url of invalidTestCases) {
+    const res = await fastify.inject({
       url,
       method: 'GET'
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 400)
     })
-  })
+    t.assert.strictEqual(res.statusCode, 400)
+  }
 })
 
-test('JSON Schema validation keywords', t => {
+test('JSON Schema validation keywords', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -660,31 +679,34 @@ test('JSON Schema validation keywords', t => {
     }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'GET',
     url: '/127.0.0.1'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'string')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'string')
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'GET',
     url: '/localhost'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(res.json(), {
       statusCode: 400,
       code: 'FST_ERR_VALIDATION',
       error: 'Bad Request',
       message: 'params/ip must match format "ipv4"'
     })
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Nested id calls', t => {
+test('Nested id calls', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -714,33 +736,36 @@ test('Nested id calls', t => {
     }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { host: { ip: '127.0.0.1' } }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, 'string')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'string')
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { host: { ip: 'localhost' } }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(res.json(), {
       error: 'Bad Request',
       message: 'body/host/ip must match format "ipv4"',
       statusCode: 400,
       code: 'FST_ERR_VALIDATION'
     })
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Use the same schema id in different places', t => {
+test('Use the same schema id in different places', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -761,18 +786,18 @@ test('Use the same schema id in different places', t => {
       }
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { id: 42 }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { id: 21 })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { id: 21 })
+    testDone()
   })
 })
 
-test('Use shared schema and $ref with $id ($ref to $id)', t => {
+test('Use shared schema and $ref with $id ($ref to $id)', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -815,6 +840,7 @@ test('Use shared schema and $ref with $id ($ref to $id)', t => {
   })
 
   const id = Date.now()
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -823,27 +849,29 @@ test('Use shared schema and $ref with $id ($ref to $id)', t => {
       test: { id }
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json(), { id })
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json(), { id })
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { test: { id } }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(res.json(), {
       error: 'Bad Request',
       message: "body must have required property 'address'",
       statusCode: 400,
       code: 'FST_ERR_VALIDATION'
     })
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Use items with $ref', t => {
+test('Use items with $ref', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -865,26 +893,29 @@ test('Use items with $ref', t => {
     handler: (_, r) => { r.send('ok') }
   })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: [{ hello: 'world' }]
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.payload, 'ok')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, 'ok')
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
     payload: { hello: 'world' }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Use $ref to /definitions', t => {
+test('Use $ref to /definitions', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -931,16 +962,17 @@ test('Use $ref to /definitions', t => {
     address: { city: 'New Node' },
     test: { id: Date.now() }
   }
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/',
     payload
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), payload)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), payload)
+    completion.stepIn()
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -949,18 +981,20 @@ test('Use $ref to /definitions', t => {
       test: { id: 'wrong' }
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
-    t.same(res.json(), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.deepStrictEqual(res.json(), {
       error: 'Bad Request',
       message: 'body/test/id must be number',
       statusCode: 400,
       code: 'FST_ERR_VALIDATION'
     })
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
-test('Custom AJV settings - pt1', t => {
+test('Custom AJV settings - pt1', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -974,11 +1008,10 @@ test('Custom AJV settings - pt1', t => {
       }
     },
     handler: (req, reply) => {
-      t.equal(req.body.num, 12)
+      t.assert.strictEqual(req.body.num, 12)
       reply.send(req.body)
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -986,13 +1019,14 @@ test('Custom AJV settings - pt1', t => {
       num: '12'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), { num: 12 })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { num: 12 })
+    testDone()
   })
 })
 
-test('Custom AJV settings - pt2', t => {
+test('Custom AJV settings - pt2', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify({
     ajv: {
@@ -1015,7 +1049,6 @@ test('Custom AJV settings - pt2', t => {
       t.fail('the handler is not called because the "12" is not coerced to number')
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/',
@@ -1023,12 +1056,13 @@ test('Custom AJV settings - pt2', t => {
       num: '12'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    testDone()
   })
 })
 
-test('Custom AJV settings on different parameters - pt1', t => {
+test('Custom AJV settings on different parameters - pt1', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -1054,7 +1088,6 @@ test('Custom AJV settings on different parameters - pt1', t => {
       t.fail('the handler is not called because the "12" is not coerced to number')
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/api/42',
@@ -1062,12 +1095,13 @@ test('Custom AJV settings on different parameters - pt1', t => {
       num: '12'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 400)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 400)
+    testDone()
   })
 })
 
-test('Custom AJV settings on different parameters - pt2', t => {
+test('Custom AJV settings on different parameters - pt2', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1091,13 +1125,13 @@ test('Custom AJV settings on different parameters - pt2', t => {
       }
     },
     handler: (req, reply) => {
-      t.same(typeof req.params.id, 'number')
-      t.same(typeof req.body.num, 'number')
-      t.same(req.params.id, 42)
-      t.same(req.body.num, 12)
+      t.assert.deepStrictEqual(typeof req.params.id, 'number')
+      t.assert.deepStrictEqual(typeof req.body.num, 'number')
+      t.assert.deepStrictEqual(req.params.id, 42)
+      t.assert.deepStrictEqual(req.body.num, 12)
+      testDone()
     }
   })
-
   fastify.inject({
     method: 'POST',
     url: '/api/42',
@@ -1107,7 +1141,7 @@ test('Custom AJV settings on different parameters - pt2', t => {
   })
 })
 
-test("The same $id in route's schema must not overwrite others", t => {
+test("The same $id in route's schema must not overwrite others", (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -1158,23 +1192,26 @@ test("The same $id in route's schema must not overwrite others", t => {
       handler: () => { return 'ok' }
     })
 
+  const completion = waitForCb({ steps: 2 })
   fastify.inject({
     method: 'POST',
     url: '/user',
     body: {}
   }, (err, res) => {
-    t.error(err)
-    t.same(res.json().message, "body must have required property 'username'")
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.json().message, "body must have required property 'username'")
+    completion.stepIn()
   })
-
   fastify.inject({
     url: '/user/1',
     method: 'PATCH',
     body: {}
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'ok')
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'ok')
+    completion.stepIn()
   })
+  completion.patience.then(testDone)
 })
 
 test('Custom validator compiler should not mutate schema', async t => {
@@ -1183,7 +1220,7 @@ test('Custom validator compiler should not mutate schema', async t => {
   const fastify = Fastify()
 
   fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
-    t.type(schema, Headers)
+    t.assert.ok(schema instanceof Headers)
     return () => { }
   })
 
@@ -1221,8 +1258,8 @@ test('Custom validator builder override by custom validator compiler', async t =
       }
     },
     handler: (req, _reply) => {
-      t.same(typeof req.params.id, 'number')
-      t.same(req.params.id, 43)
+      t.assert.deepStrictEqual(typeof req.params.id, 'number')
+      t.assert.deepStrictEqual(req.params.id, 43)
       return 'ok'
     }
   })
@@ -1233,7 +1270,7 @@ test('Custom validator builder override by custom validator compiler', async t =
     method: 'POST',
     url: '/two/43'
   })
-  t.equal(two.statusCode, 200)
+  t.assert.strictEqual(two.statusCode, 200)
 })
 
 test('Custom validator builder override by custom validator compiler in child instance', async t => {
@@ -1261,8 +1298,8 @@ test('Custom validator builder override by custom validator compiler in child in
         }
       },
       handler: (req, _reply) => {
-        t.same(typeof req.params.id, 'number')
-        t.same(req.params.id, 43)
+        t.assert.deepStrictEqual(typeof req.params.id, 'number')
+        t.assert.deepStrictEqual(req.params.id, 43)
         return 'ok'
       }
     })
@@ -1281,8 +1318,8 @@ test('Custom validator builder override by custom validator compiler in child in
       }
     },
     handler: (req, _reply) => {
-      t.same(typeof req.params.id, 'number')
-      t.same(req.params.id, 42)
+      t.assert.deepStrictEqual(typeof req.params.id, 'number')
+      t.assert.deepStrictEqual(req.params.id, 42)
       return 'ok'
     }
   })
@@ -1293,13 +1330,13 @@ test('Custom validator builder override by custom validator compiler in child in
     method: 'POST',
     url: '/one/42'
   })
-  t.equal(one.statusCode, 200)
+  t.assert.strictEqual(one.statusCode, 200)
 
   const two = await fastify.inject({
     method: 'POST',
     url: '/two/43'
   })
-  t.equal(two.statusCode, 200)
+  t.assert.strictEqual(two.statusCode, 200)
 })
 
 test('Schema validation when no content type is provided', async t => {
@@ -1339,12 +1376,10 @@ test('Schema validation when no content type is provided', async t => {
     },
     body: { invalid: 'string' }
   })
-  t.equal(invalid.statusCode, 200)
+  t.assert.strictEqual(invalid.statusCode, 200)
 })
 
 test('Schema validation will not be bypass by different content type', async t => {
-  t.plan(10)
-
   const fastify = Fastify()
 
   fastify.post('/', {
@@ -1367,7 +1402,7 @@ test('Schema validation will not be bypass by different content type', async t =
   }, async () => 'ok')
 
   await fastify.listen({ port: 0 })
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
   const address = fastify.listeningOrigin
 
   const correct1 = await request(address, {
@@ -1378,7 +1413,7 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ foo: 'string' })
   })
-  t.equal(correct1.statusCode, 200)
+  t.assert.strictEqual(correct1.statusCode, 200)
   await correct1.body.dump()
 
   const correct2 = await request(address, {
@@ -1389,7 +1424,7 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ foo: 'string' })
   })
-  t.equal(correct2.statusCode, 200)
+  t.assert.strictEqual(correct2.statusCode, 200)
   await correct2.body.dump()
 
   const invalid1 = await request(address, {
@@ -1400,8 +1435,8 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.equal(invalid1.statusCode, 400)
-  t.equal((await invalid1.body.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(invalid1.statusCode, 400)
+  t.assert.strictEqual((await invalid1.body.json()).code, 'FST_ERR_VALIDATION')
 
   const invalid2 = await request(address, {
     method: 'POST',
@@ -1411,8 +1446,8 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.equal(invalid2.statusCode, 400)
-  t.equal((await invalid2.body.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(invalid2.statusCode, 400)
+  t.assert.strictEqual((await invalid2.body.json()).code, 'FST_ERR_VALIDATION')
 
   const invalid3 = await request(address, {
     method: 'POST',
@@ -1422,8 +1457,8 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.equal(invalid3.statusCode, 400)
-  t.equal((await invalid3.body.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(invalid3.statusCode, 400)
+  t.assert.strictEqual((await invalid3.body.json()).code, 'FST_ERR_VALIDATION')
 
   const invalid4 = await request(address, {
     method: 'POST',
@@ -1433,6 +1468,50 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.equal(invalid4.statusCode, 400)
-  t.equal((await invalid4.body.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(invalid4.statusCode, 400)
+  t.assert.strictEqual((await invalid4.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid5 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn \tfoo;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(invalid5.statusCode, 400)
+  t.assert.strictEqual((await invalid5.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid6 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\t foo;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(invalid6.statusCode, 415)
+  t.assert.strictEqual((await invalid6.body.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+
+  const invalid7 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn \t'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(invalid7.statusCode, 400)
+  t.assert.strictEqual((await invalid7.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid8 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\t'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(invalid8.statusCode, 400)
+  t.assert.strictEqual((await invalid8.body.json()).code, 'FST_ERR_VALIDATION')
 })