fastify 5.3.2 → 5.3.3

package/test/hooks.on-listen.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
 const split = require('split2')
@@ -15,60 +15,63 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('onListen should not be processed when .ready() is called', t => {
+test('onListen should not be processed when .ready() is called', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.addHook('onListen', function (done) {
-    t.fail()
+    t.assert.fail()
     done()
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    testDone()
+  })
 })
 
-test('localhost onListen should be called in order', t => {
+test('localhost onListen should be called in order', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
     done()
   })
 
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
 test('localhost async onListen should be called in order', async t => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, '1st async called in root')
+    t.assert.strictEqual(++order, 1, '1st async called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd async called in root')
+    t.assert.strictEqual(++order, 2, '2nd async called in root')
   })
 
   await fastify.listen({
     host: 'localhost',
     port: 0
   })
-  t.equal(order, 2, 'the onListen hooks are awaited')
+  t.assert.strictEqual(order, 2, 'the onListen hooks are awaited')
 })
 
 test('localhost onListen sync should log errors as warnings and continue /1', async t => {
@@ -82,30 +85,30 @@ test('localhost onListen sync should log errors as warnings and continue /1', as
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.equal(order, 2)
-      t.pass('Logged Error Message')
+      t.assert.strictEqual(order, 2)
+      t.assert.ok('Logged Error Message')
     }
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st call')
-    t.pass('called in root')
+    t.assert.strictEqual(++order, 1, '1st call')
+    t.assert.ok('called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd call')
-    t.pass('called onListen error')
+    t.assert.strictEqual(++order, 2, '2nd call')
+    t.assert.ok('called onListen error')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 3, '3rd call')
-    t.pass('onListen hooks continue after error')
+    t.assert.strictEqual(++order, 3, '3rd call')
+    t.assert.ok('onListen hooks continue after error')
     done()
   })
 
@@ -115,7 +118,7 @@ test('localhost onListen sync should log errors as warnings and continue /1', as
   })
 })
 
-test('localhost onListen sync should log errors as warnings and continue /2', t => {
+test('localhost onListen sync should log errors as warnings and continue /2', (t, testDone) => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -125,38 +128,38 @@ test('localhost onListen sync should log errors as warnings and continue /2', t
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st call')
-    t.pass('called in root')
+    t.assert.strictEqual(++order, 1, '1st call')
+    t.assert.ok('called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd call')
-    t.pass('called onListen error')
+    t.assert.strictEqual(++order, 2, '2nd call')
+    t.assert.ok('called onListen error')
     done(new Error('FAIL ON LISTEN'))
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 3, '3rd call')
-    t.pass('onListen hooks continue after error')
+    t.assert.strictEqual(++order, 3, '3rd call')
+    t.assert.ok('onListen hooks continue after error')
     done()
   })
 
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
 test('localhost onListen async should log errors as warnings and continue', async t => {
@@ -169,25 +172,25 @@ test('localhost onListen async should log errors as warnings and continue', asyn
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   fastify.addHook('onListen', async function () {
-    t.pass('called in root')
+    t.assert.ok('called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.pass('called onListen error')
+    t.assert.ok('called onListen error')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', async function () {
-    t.pass('onListen hooks continue after error')
+    t.assert.ok('onListen hooks continue after error')
   })
 
   await fastify.listen({
@@ -196,14 +199,14 @@ test('localhost onListen async should log errors as warnings and continue', asyn
   })
 })
 
-test('localhost Register onListen hook after a plugin inside a plugin', t => {
+test('localhost Register onListen hook after a plugin inside a plugin', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
     done()
@@ -211,12 +214,12 @@ test('localhost Register onListen hook after a plugin inside a plugin', t => {
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -226,10 +229,10 @@ test('localhost Register onListen hook after a plugin inside a plugin', t => {
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
-test('localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', t => {
+test('localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', (t, testDone) => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -239,17 +242,17 @@ test('localhost Register onListen hook after a plugin inside a plugin should log
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('Plugin Error')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
     done()
@@ -257,12 +260,12 @@ test('localhost Register onListen hook after a plugin inside a plugin should log
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
 
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
 
@@ -272,40 +275,40 @@ test('localhost Register onListen hook after a plugin inside a plugin should log
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
 test('localhost onListen encapsulation should be called in order', async t => {
   t.plan(8)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   await fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
 
     await childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
 
     await childOne.register(async (childTwoPeer, o) => {
       childTwoPeer.addHook('onListen', async function () {
-        t.equal(++order, 4, 'called second in childTwo')
-        t.equal(this.pluginName, childTwoPeer.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 4, 'called second in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwoPeer.pluginName, 'the this binding is the right instance')
       })
     })
   })
@@ -318,12 +321,12 @@ test('localhost onListen encapsulation should be called in order', async t => {
 test('localhost onListen encapsulation with only nested hook', async t => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   await fastify.register(async (child) => {
     await child.register(async (child2) => {
       child2.addHook('onListen', function (done) {
-        t.pass()
+        t.assert.ok()
         done()
       })
     })
@@ -338,19 +341,19 @@ test('localhost onListen encapsulation with only nested hook', async t => {
 test('localhost onListen peer encapsulations with only nested hooks', async t => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   await fastify.register(async (child) => {
     await child.register(async (child2) => {
       child2.addHook('onListen', function (done) {
-        t.pass()
+        t.assert.ok()
         done()
       })
     })
 
     await child.register(async (child2) => {
       child2.addHook('onListen', function (done) {
-        t.pass()
+        t.assert.ok()
         done()
       })
     })
@@ -362,7 +365,7 @@ test('localhost onListen peer encapsulations with only nested hooks', async t =>
   })
 })
 
-test('localhost onListen encapsulation should be called in order and should log errors as warnings and continue', t => {
+test('localhost onListen encapsulation should be called in order and should log errors as warnings and continue', (t, testDone) => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -372,32 +375,32 @@ test('localhost onListen encapsulation should be called in order and should log
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('Error in onListen hook of childTwo')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
     childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
         throw new Error('Error in onListen hook of childTwo')
       })
     })
@@ -405,44 +408,44 @@ test('localhost onListen encapsulation should be called in order and should log
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
-test('non-localhost onListen should be called in order', { skip: isIPv6Missing }, t => {
+test('non-localhost onListen should be called in order', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(2)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
     done()
   })
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
 test('non-localhost async onListen should be called in order', { skip: isIPv6Missing }, async t => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, '1st async called in root')
+    t.assert.strictEqual(++order, 1, '1st async called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd async called in root')
+    t.assert.strictEqual(++order, 2, '2nd async called in root')
   })
 
   await fastify.listen({
@@ -451,7 +454,7 @@ test('non-localhost async onListen should be called in order', { skip: isIPv6Mis
   })
 })
 
-test('non-localhost sync onListen should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
+test('non-localhost sync onListen should log errors as warnings and continue', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(4)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -461,34 +464,34 @@ test('non-localhost sync onListen should log errors as warnings and continue', {
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1)
+    t.assert.strictEqual(++order, 1)
     done()
   })
 
   fastify.addHook('onListen', function () {
-    t.equal(++order, 2)
+    t.assert.strictEqual(++order, 2)
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 3, 'should still run')
+    t.assert.strictEqual(++order, 3, 'should still run')
     done()
   })
 
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
 test('non-localhost async onListen should log errors as warnings and continue', { skip: isIPv6Missing }, async t => {
@@ -501,29 +504,29 @@ test('non-localhost async onListen should log errors as warnings and continue',
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1)
-    t.pass('called in root')
+    t.assert.strictEqual(++order, 1)
+    t.assert.ok('called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd async failed in root')
+    t.assert.strictEqual(++order, 2, '2nd async failed in root')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 3)
-    t.pass('should still run')
+    t.assert.strictEqual(++order, 3)
+    t.assert.ok('should still run')
   })
 
   await fastify.listen({
@@ -532,14 +535,14 @@ test('non-localhost async onListen should log errors as warnings and continue',
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
     done()
@@ -547,12 +550,12 @@ test('non-localhost Register onListen hook after a plugin inside a plugin', { sk
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -562,10 +565,10 @@ test('non-localhost Register onListen hook after a plugin inside a plugin', { sk
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -575,17 +578,17 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('Plugin Error')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
     done()
@@ -593,12 +596,12 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
 
     instance.addHook('onListen', function () {
-      t.pass('called')
+      t.assert.ok('called')
       throw new Error('Plugin Error')
     })
 
@@ -608,42 +611,42 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
-test('non-localhost onListen encapsulation should be called in order', { skip: isIPv6Missing }, t => {
+test('non-localhost onListen encapsulation should be called in order', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
     childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
   })
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
-test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
+test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -653,33 +656,33 @@ test('non-localhost onListen encapsulation should be called in order and should
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('Error in onListen hook of childTwo')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
+    t.assert.strictEqual(++order, 1, 'called in root')
 
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
     childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
         throw new Error('Error in onListen hook of childTwo')
       })
     })
@@ -687,52 +690,54 @@ test('non-localhost onListen encapsulation should be called in order and should
   fastify.listen({
     host: '::1',
     port: 0
-  })
+  }, testDone)
 })
 
-test('onListen localhost should work in order with callback', t => {
+test('onListen localhost should work in order with callback', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
     done()
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen localhost should work in order with callback in async', t => {
+test('onListen localhost should work in order with callback in async', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
   })
 
   fastify.listen({ host: 'localhost', port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen localhost sync with callback should log errors as warnings and continue', t => {
+test('onListen localhost sync with callback should log errors as warnings and continue', (t, testDone) => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -742,38 +747,39 @@ test('onListen localhost sync with callback should log errors as warnings and co
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function () {
-    t.equal(++order, 2, 'error sync called in root')
+    t.assert.strictEqual(++order, 2, 'error sync called in root')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 3, '1st called in root')
+    t.assert.strictEqual(++order, 3, '1st called in root')
     done()
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
-    t.equal(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    testDone()
   })
 })
 
-test('onListen localhost async with callback should log errors as warnings and continue', t => {
+test('onListen localhost async with callback should log errors as warnings and continue', (t, testDone) => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -783,43 +789,44 @@ test('onListen localhost async with callback should log errors as warnings and c
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.pass('1st called in root')
+    t.assert.ok('1st called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, 'error sync called in root')
+    t.assert.strictEqual(++order, 1, 'error sync called in root')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', async function () {
-    t.pass('3rd called in root')
+    t.assert.ok('3rd called in root')
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
-    t.equal(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    testDone()
   })
 })
 
-test('Register onListen hook localhost with callback after a plugin inside a plugin', t => {
+test('Register onListen hook localhost with callback after a plugin inside a plugin', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
     done()
@@ -827,12 +834,12 @@ test('Register onListen hook localhost with callback after a plugin inside a plu
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -840,86 +847,90 @@ test('Register onListen hook localhost with callback after a plugin inside a plu
   }))
 
   fastify.listen({ port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen localhost with callback encapsulation should be called in order', t => {
+test('onListen localhost with callback encapsulation should be called in order', (t, testDone) => {
   t.plan(8)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
     childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
   })
   fastify.listen({ port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen non-localhost should work in order with callback in sync', { skip: isIPv6Missing }, t => {
+test('onListen non-localhost should work in order with callback in sync', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
     done()
   })
 
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, '::1')
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen non-localhost should work in order with callback in async', { skip: isIPv6Missing }, t => {
+test('onListen non-localhost should work in order with callback in async', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
   })
 
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, '::1')
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen non-localhost sync with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
+test('onListen non-localhost sync with callback should log errors as warnings and continue', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -930,40 +941,41 @@ test('onListen non-localhost sync with callback should log errors as warnings an
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1)
-    t.pass('1st called in root')
+    t.assert.strictEqual(++order, 1)
+    t.assert.ok('1st called in root')
     done()
   })
 
   fastify.addHook('onListen', function () {
-    t.equal(++order, 2)
+    t.assert.strictEqual(++order, 2)
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 3)
-    t.pass('3rd called in root')
+    t.assert.strictEqual(++order, 3)
+    t.assert.ok('3rd called in root')
     done()
   })
 
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.error(err)
-    t.equal(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    testDone()
   })
 })
 
-test('onListen non-localhost async with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
+test('onListen non-localhost async with callback should log errors as warnings and continue', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -974,45 +986,46 @@ test('onListen non-localhost async with callback should log errors as warnings a
       level: 'info'
     }
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   stream.on('data', message => {
     if (message.msg.includes('FAIL ON LISTEN')) {
-      t.pass('Logged Error Message')
+      t.assert.ok('Logged Error Message')
     }
   })
 
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1)
-    t.pass('1st called in root')
+    t.assert.strictEqual(++order, 1)
+    t.assert.ok('1st called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, 'error sync called in root')
+    t.assert.strictEqual(++order, 2, 'error sync called in root')
     throw new Error('FAIL ON LISTEN')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 3)
-    t.pass('3rd called in root')
+    t.assert.strictEqual(++order, 3)
+    t.assert.ok('3rd called in root')
   })
 
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.error(err)
-    t.equal(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    testDone()
   })
 })
 
-test('Register onListen hook non-localhost with callback after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
+test('Register onListen hook non-localhost with callback after a plugin inside a plugin', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
     done()
@@ -1020,12 +1033,12 @@ test('Register onListen hook non-localhost with callback after a plugin inside a
 
   fastify.register(fp(function (instance, opts, done) {
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
     instance.addHook('onListen', function (done) {
-      t.pass('called')
+      t.assert.ok('called')
       done()
     })
 
@@ -1033,91 +1046,93 @@ test('Register onListen hook non-localhost with callback after a plugin inside a
   }))
 
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, '::1')
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen non-localhost with callback encapsulation should be called in order', { skip: isIPv6Missing }, t => {
+test('onListen non-localhost with callback encapsulation should be called in order', { skip: isIPv6Missing }, (t, testDone) => {
   t.plan(8)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   let order = 0
 
   fastify.addHook('onListen', function (done) {
-    t.equal(++order, 1, 'called in root')
-    t.equal(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    t.assert.strictEqual(++order, 1, 'called in root')
+    t.assert.strictEqual(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
     done()
   })
 
   fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
-      t.equal(++order, 2, 'called in childOne')
-      t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      t.assert.strictEqual(++order, 2, 'called in childOne')
+      t.assert.strictEqual(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
     childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
-        t.equal(++order, 3, 'called in childTwo')
-        t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        t.assert.strictEqual(++order, 3, 'called in childTwo')
+        t.assert.strictEqual(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
   })
   fastify.listen({ host: '::1', port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, '::1')
-    t.error(err)
+    t.assert.strictEqual(fastify.server.address().address, '::1')
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('onListen sync should work if user does not pass done', t => {
+test('onListen sync should work if user does not pass done', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', function () {
-    t.equal(++order, 1, '1st called in root')
+    t.assert.strictEqual(++order, 1, '1st called in root')
   })
 
   fastify.addHook('onListen', function () {
-    t.equal(++order, 2, '2nd called in root')
+    t.assert.strictEqual(++order, 2, '2nd called in root')
   })
 
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
-test('async onListen does not need to be awaited', t => {
+test('async onListen does not need to be awaited', (t, testDone) => {
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   let order = 0
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 1, '1st async called in root')
+    t.assert.strictEqual(++order, 1, '1st async called in root')
   })
 
   fastify.addHook('onListen', async function () {
-    t.equal(++order, 2, '2nd async called in root')
+    t.assert.strictEqual(++order, 2, '2nd async called in root')
     t.end()
   })
 
   fastify.listen({
     host: 'localhost',
     port: 0
-  })
+  }, testDone)
 })
 
-test('onListen hooks do not block /1', t => {
+test('onListen hooks do not block /1', (t, testDone) => {
   t.plan(2)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.addHook('onListen', function (done) {
-    t.equal(fastify[kState].listening, true)
+    t.assert.strictEqual(fastify[kState].listening, true)
     done()
   })
 
@@ -1125,7 +1140,8 @@ test('onListen hooks do not block /1', t => {
     host: 'localhost',
     port: 0
   }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
@@ -1133,10 +1149,10 @@ test('onListen hooks do not block /2', async t => {
   t.plan(1)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.addHook('onListen', async function () {
-    t.equal(fastify[kState].listening, true)
+    t.assert.strictEqual(fastify[kState].listening, true)
   })
 
   await fastify.listen({