From a5a9a0f016714a4df3100ae4fb055ed98c7c6624 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Wed, 1 Jan 2025 23:19:00 +0100
Subject: [PATCH 01/93] chore: remove tap

---
 .taprc                    |    2 -
 package.json              |    3 +-
 test/content-type.test.js |   50 +-
 test/dir-list.test.js     |  284 +++---
 test/static.test.js       | 1779 ++++++++++++++++++-------------------
 5 files changed, 1047 insertions(+), 1071 deletions(-)
 delete mode 100644 .taprc

diff --git a/.taprc b/.taprc
deleted file mode 100644
index eb6eb3e8..00000000
--- a/.taprc
+++ /dev/null
@@ -1,2 +0,0 @@
-files:
-  - test/**/*.test.js
diff --git a/package.json b/package.json
index 9024492b..8b54cfcd 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "tap",
+    "test:unit": "node --test",
     "example": "node example/server.js"
   },
   "repository": {
@@ -76,7 +76,6 @@
     "pino": "^9.1.0",
     "proxyquire": "^2.1.3",
     "simple-get": "^4.0.1",
-    "tap": "^18.7.1",
     "tsd": "^0.31.0"
   },
   "tsd": {
diff --git a/test/content-type.test.js b/test/content-type.test.js
index 4e012602..05d5c0a0 100644
--- a/test/content-type.test.js
+++ b/test/content-type.test.js
@@ -3,7 +3,7 @@
 /* eslint n/no-deprecated-api: "off" */
 
 const path = require('node:path')
-const { test } = require('tap')
+const { test } = require('node:test')
 const simple = require('simple-get')
 const Fastify = require('fastify')
 
@@ -19,10 +19,10 @@ test('register /content-type', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -32,8 +32,8 @@ test('register /content-type', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.html'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
       })
     })
 
@@ -43,8 +43,8 @@ test('register /content-type', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.css'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/css; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
       })
     })
 
@@ -54,8 +54,8 @@ test('register /content-type', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'image/jpeg')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'image/jpeg')
       })
     })
 
@@ -65,8 +65,8 @@ test('register /content-type', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/test.txt'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
       })
     })
 
@@ -76,8 +76,8 @@ test('register /content-type', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/binary'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'application/octet-stream')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'application/octet-stream')
       })
     })
   })
@@ -94,10 +94,10 @@ test('register /content-type preCompressed', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -110,8 +110,8 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
       })
     })
 
@@ -124,8 +124,8 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/css; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
       })
     })
 
@@ -138,8 +138,8 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'image/jpeg')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'image/jpeg')
       })
     })
 
@@ -152,8 +152,8 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
       })
     })
 
@@ -166,8 +166,8 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.headers['content-type'], 'application/octet-stream')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.headers['content-type'], 'application/octet-stream')
       })
     })
   })
diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 74aacea3..fc83d972 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -4,7 +4,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const t = require('tap')
+const { test } = require('node:test')
 const simple = require('simple-get')
 const Fastify = require('fastify')
 
@@ -18,9 +18,9 @@ const helper = {
   arrangeModule: function (t, options, mock, f) {
     const fastify = Fastify()
     fastify.register(mock, options)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.listen({ port: 0 }, err => {
-      t.error(err)
+      t.assert.ok(err instanceof Error)
       fastify.server.unref()
       f('http://localhost:' + fastify.server.address().port)
     })
@@ -32,47 +32,47 @@ try {
   fs.mkdirSync(path.join(__dirname, 'static/shallow/empty'))
 } catch (error) {}
 
-t.test('throws when `root` is an array', t => {
+test('throws when `root` is an array', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ root: ['hello', 'world'], list: true })
-  t.type(err, TypeError)
-  t.equal(err.message, 'multi-root with list option is not supported')
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.message, 'multi-root with list option is not supported')
 })
 
-t.test('throws when `list.format` option is invalid', t => {
+test('throws when `list.format` option is invalid', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ list: { format: 'hello' } })
-  t.type(err, TypeError)
-  t.equal(err.message, 'The `list.format` option must be json or html')
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.message, 'The `list.format` option must be json or html')
 })
 
-t.test('throws when `list.names option` is not an array', t => {
+test('throws when `list.names option` is not an array', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ list: { names: 'hello' } })
-  t.type(err, TypeError)
-  t.equal(err.message, 'The `list.names` option must be an array')
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.message, 'The `list.names` option must be an array')
 })
 
-t.test('throws when `list.jsonFormat` option is invalid', t => {
+test('throws when `list.jsonFormat` option is invalid', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ list: { jsonFormat: 'hello' } })
-  t.type(err, TypeError)
-  t.equal(err.message, 'The `list.jsonFormat` option must be name or extended')
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.message, 'The `list.jsonFormat` option must be name or extended')
 })
 
-t.test('throws when `list.format` is html and `list render` is not a function', t => {
+test('throws when `list.format` is html and `list render` is not a function', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ list: { format: 'html', render: 'hello' } })
-  t.type(err, TypeError)
-  t.equal(err.message, 'The `list.render` option must be a function and is required with html format')
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.message, 'The `list.render` option must be a function and is required with html format')
 })
 
-t.test('dir list wrong options', t => {
+test('dir list wrong options', t => {
   t.plan(3)
 
   const cases = [
@@ -111,13 +111,13 @@ t.test('dir list wrong options', t => {
     const fastify = Fastify()
     fastify.register(fastifyStatic, case_.options)
     fastify.listen({ port: 0 }, err => {
-      t.equal(err.message, case_.error.message)
+      t.assert.equal(err.message, case_.error.message)
       fastify.server.unref()
     })
   }
 })
 
-t.test('dir list default options', t => {
+test('dir list default options', t => {
   t.plan(2)
 
   const options = {
@@ -129,21 +129,21 @@ t.test('dir list default options', t => {
   const content = { dirs: ['empty'], files: ['sample.jpg'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list, custom options', t => {
+test('dir list, custom options', t => {
   t.plan(2)
 
   const options = {
@@ -157,21 +157,21 @@ t.test('dir list, custom options', t => {
   const content = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list, custom options with empty array index', t => {
+test('dir list, custom options with empty array index', t => {
   t.plan(2)
 
   const options = {
@@ -185,21 +185,21 @@ t.test('dir list, custom options with empty array index', t => {
   const content = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list html format', t => {
+test('dir list html format', t => {
   t.plan(3)
 
   const options = {
@@ -229,15 +229,15 @@ t.test('dir list html format', t => {
 
   helper.arrange(t, options, (url) => {
     for (const route of routes) {
-      t.test(route, t => {
+      test(route, t => {
         t.plan(3)
         simple.concat({
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.equal(body.toString(), `
+          t.assert.ok(err instanceof Error)
+          t.assert.equal(response.statusCode, 200)
+          t.assert.equal(body.toString(), `
 <html><body>
 <ul>
   <li><a href="/public/deep">deep</a></li>
@@ -260,7 +260,7 @@ t.test('dir list html format', t => {
   })
 })
 
-t.test('dir list href nested structure', t => {
+test('dir list href nested structure', t => {
   t.plan(6)
 
   const options = {
@@ -285,21 +285,21 @@ t.test('dir list href nested structure', t => {
   ]
   helper.arrange(t, options, (url) => {
     for (const route of routes) {
-      t.test(route.path, t => {
+      test(route.path, t => {
         t.plan(5)
         simple.concat({
           method: 'GET',
           url: url + route.path
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.equal(body.toString(), route.response)
+          t.assert.ok(err instanceof Error)
+          t.assert.equal(response.statusCode, 200)
+          t.assert.equal(body.toString(), route.response)
           simple.concat({
             method: 'GET',
             url: url + body.toString()
           }, (err, response, body) => {
-            t.error(err)
-            t.equal(response.statusCode, 200)
+            t.assert.ok(err instanceof Error)
+            t.assert.equal(response.statusCode, 200)
           })
         })
       })
@@ -307,7 +307,7 @@ t.test('dir list href nested structure', t => {
   })
 })
 
-t.test('dir list html format - stats', t => {
+test('dir list html format - stats', t => {
   t.plan(7)
 
   const options1 = {
@@ -339,13 +339,13 @@ t.test('dir list html format - stats', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
     })
   })
 })
 
-t.test('dir list html format - extended info', t => {
+test('dir list html format - extended info', t => {
   t.plan(4)
 
   const route = '/public/'
@@ -358,18 +358,18 @@ t.test('dir list html format - extended info', t => {
       format: 'html',
       extendedFolderInfo: true,
       render (dirs, files) {
-        t.test('dirs', t => {
+        test('dirs', t => {
           t.plan(dirs.length * 7)
 
           for (const value of dirs) {
             t.ok(value.extendedInfo)
 
-            t.equal(typeof value.extendedInfo.fileCount, 'number')
-            t.equal(typeof value.extendedInfo.totalFileCount, 'number')
-            t.equal(typeof value.extendedInfo.folderCount, 'number')
-            t.equal(typeof value.extendedInfo.totalFolderCount, 'number')
-            t.equal(typeof value.extendedInfo.totalSize, 'number')
-            t.equal(typeof value.extendedInfo.lastModified, 'number')
+            t.assert.equal(typeof value.extendedInfo.fileCount, 'number')
+            t.assert.equal(typeof value.extendedInfo.totalFileCount, 'number')
+            t.assert.equal(typeof value.extendedInfo.folderCount, 'number')
+            t.assert.equal(typeof value.extendedInfo.totalFolderCount, 'number')
+            t.assert.equal(typeof value.extendedInfo.totalSize, 'number')
+            t.assert.equal(typeof value.extendedInfo.lastModified, 'number')
           }
         })
       }
@@ -381,13 +381,13 @@ t.test('dir list html format - extended info', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
     })
   })
 })
 
-t.test('dir list json format', t => {
+test('dir list json format', t => {
   t.plan(2)
 
   const options = {
@@ -404,22 +404,22 @@ t.test('dir list json format', t => {
 
   helper.arrange(t, options, (url) => {
     for (const route of routes) {
-      t.test(route, t => {
+      test(route, t => {
         t.plan(3)
         simple.concat({
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.equal(body.toString(), JSON.stringify(content))
+          t.assert.ok(err instanceof Error)
+          t.assert.equal(response.statusCode, 200)
+          t.assert.equal(body.toString(), JSON.stringify(content))
         })
       })
     }
   })
 })
 
-t.test('dir list json format - extended info', t => {
+test('dir list json format - extended info', t => {
   t.plan(2)
 
   const options = {
@@ -438,25 +438,25 @@ t.test('dir list json format - extended info', t => {
 
   helper.arrange(t, options, (url) => {
     for (const route of routes) {
-      t.test(route, t => {
+      test(route, t => {
         t.plan(5)
         simple.concat({
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
+          t.assert.ok(err instanceof Error)
+          t.assert.equal(response.statusCode, 200)
           const bodyObject = JSON.parse(body.toString())
-          t.equal(bodyObject.dirs[0].name, 'empty')
-          t.equal(typeof bodyObject.dirs[0].stats.atimeMs, 'number')
-          t.equal(typeof bodyObject.dirs[0].extendedInfo.totalSize, 'number')
+          t.assert.equal(bodyObject.dirs[0].name, 'empty')
+          t.assert.equal(typeof bodyObject.dirs[0].stats.atimeMs, 'number')
+          t.assert.equal(typeof bodyObject.dirs[0].extendedInfo.totalSize, 'number')
         })
       })
     }
   })
 })
 
-t.test('json format with url parameter format', t => {
+test('json format with url parameter format', t => {
   t.plan(13)
 
   const options = {
@@ -478,9 +478,9 @@ t.test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
 
@@ -488,9 +488,9 @@ t.test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), 'html')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
     })
 
@@ -498,15 +498,15 @@ t.test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
   })
 })
 
-t.test('json format with url parameter format and without render option', t => {
+test('json format with url parameter format and without render option', t => {
   t.plan(12)
 
   const options = {
@@ -525,9 +525,9 @@ t.test('json format with url parameter format and without render option', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
 
@@ -535,24 +535,24 @@ t.test('json format with url parameter format and without render option', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-      t.equal(JSON.parse(body.toString()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 500)
+      t.assert.equal(JSON.parse(body.toString()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
     })
 
     simple.concat({
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
   })
 })
 
-t.test('html format with url parameter format', t => {
+test('html format with url parameter format', t => {
   t.plan(13)
 
   const options = {
@@ -574,9 +574,9 @@ t.test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), 'html')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
     })
 
@@ -584,9 +584,9 @@ t.test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), 'html')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
     })
 
@@ -594,15 +594,15 @@ t.test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
   })
 })
 
-t.test('dir list on empty dir', t => {
+test('dir list on empty dir', t => {
   t.plan(2)
 
   const options = {
@@ -614,21 +614,21 @@ t.test('dir list on empty dir', t => {
   const content = { dirs: [], files: [] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list serve index.html on index option', t => {
+test('dir list serve index.html on index option', t => {
   t.plan(2)
 
   const options = {
@@ -643,7 +643,7 @@ t.test('dir list serve index.html on index option', t => {
   }
 
   helper.arrange(t, options, (url) => {
-    t.test('serve index.html from fs', t => {
+    test('serve index.html from fs', t => {
       t.plan(6)
 
       let route = '/public/index.html'
@@ -652,9 +652,9 @@ t.test('dir list serve index.html on index option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
       })
 
       route = '/public/index'
@@ -662,15 +662,15 @@ t.test('dir list serve index.html on index option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), 'dir list index')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), 'dir list index')
       })
     })
   })
 })
 
-t.test('serve a non existent dir and get error', t => {
+test('serve a non existent dir and get error', t => {
   t.plan(2)
 
   const options = {
@@ -681,20 +681,20 @@ t.test('serve a non existent dir and get error', t => {
   const route = '/public/'
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
   })
 })
 
-t.test('serve a non existent dir and get error', t => {
+test('serve a non existent dir and get error', t => {
   t.plan(2)
 
   const options = {
@@ -707,20 +707,20 @@ t.test('serve a non existent dir and get error', t => {
   const route = '/public/none/index'
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
   })
 })
 
-t.test('dir list with dotfiles allow option', t => {
+test('dir list with dotfiles allow option', t => {
   t.plan(2)
 
   const options = {
@@ -734,21 +734,21 @@ t.test('dir list with dotfiles allow option', t => {
   const content = { dirs: ['dir'], files: ['.aaa', 'test.txt'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list with dotfiles deny option', t => {
+test('dir list with dotfiles deny option', t => {
   t.plan(2)
 
   const options = {
@@ -762,21 +762,21 @@ t.test('dir list with dotfiles deny option', t => {
   const content = { dirs: ['dir'], files: ['test.txt'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list with dotfiles ignore option', t => {
+test('dir list with dotfiles ignore option', t => {
   t.plan(2)
 
   const options = {
@@ -790,21 +790,21 @@ t.test('dir list with dotfiles ignore option', t => {
   const content = { dirs: ['dir'], files: ['test.txt'] }
 
   helper.arrange(t, options, (url) => {
-    t.test(route, t => {
+    test(route, t => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), JSON.stringify(content))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), JSON.stringify(content))
       })
     })
   })
 })
 
-t.test('dir list error', t => {
+test('dir list error', t => {
   t.plan(7)
 
   const options = {
@@ -834,9 +834,9 @@ t.test('dir list error', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(JSON.parse(body.toString()).message, errorMessage)
-        t.equal(response.statusCode, 500)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(JSON.parse(body.toString()).message, errorMessage)
+        t.assert.equal(response.statusCode, 500)
       })
     }
   })
diff --git a/test/static.test.js b/test/static.test.js
index feab2212..e768d6e1 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -6,7 +6,7 @@ const path = require('node:path')
 const fs = require('node:fs')
 const url = require('node:url')
 const http = require('node:http')
-const t = require('tap')
+const { test } = require('node:test')
 const simple = require('simple-get')
 const Fastify = require('fastify')
 const compress = require('@fastify/compress')
@@ -58,20 +58,20 @@ const jsonHiddenContent = fs.readFileSync('./test/static-hidden/.hidden/sample.j
 
 const GENERIC_RESPONSE_CHECK_COUNT = 5
 function genericResponseChecks (t, response) {
-  t.ok(/text\/(html|css)/.test(response.headers['content-type']))
-  t.ok(response.headers.etag)
-  t.ok(response.headers['last-modified'])
-  t.ok(response.headers.date)
-  t.ok(response.headers['cache-control'])
+  t.assert.ok(/text\/(html|css)/.test(response.headers['content-type']))
+  t.assert.ok(response.headers.etag)
+  t.assert.ok(response.headers['last-modified'])
+  t.assert.ok(response.headers.date)
+  t.assert.ok(response.headers['cache-control'])
 }
 
 const GENERIC_ERROR_RESPONSE_CHECK_COUNT = 2
 function genericErrorResponseChecks (t, response) {
-  t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-  t.ok(response.headers.date)
+  t.assert.equal(response.headers['content-type'], 'application/json; charset=utf-8')
+  t.assert.ok(response.headers.date)
 }
 
-t.test('register /static prefixAvoidTrailingSlash', t => {
+test('register /static prefixAvoidTrailingSlash', t => {
   t.plan(12)
 
   const pluginOptions = {
@@ -82,157 +82,157 @@ t.test('register /static prefixAvoidTrailingSlash', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.css', (t) => {
+    test('/static/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/', (t) => {
+    test('/static/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', (t) => {
+    test('/static', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test/', (t) => {
+    test('/static/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/for/test', (t) => {
+    test('/static/this/path/for/test', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/doesnt/exist.html', (t) => {
+    test('/static/this/path/doesnt/exist.html', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/../index.js', (t) => {
+    test('/static/../index.js', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('file not exposed outside of the plugin', (t) => {
+    test('file not exposed outside of the plugin', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         // foobar is in static
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('file not exposed outside of the plugin', t => {
+    test('file not exposed outside of the plugin', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register /static', (t) => {
+test('register /static', (t) => {
   t.plan(11)
 
   const pluginOptions = {
@@ -242,142 +242,142 @@ t.test('register /static', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.css', (t) => {
+    test('/static/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/', (t) => {
+    test('/static/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', (t) => {
+    test('/static', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('/static/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test/', (t) => {
+    test('/static/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/for/test', (t) => {
+    test('/static/this/path/for/test', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/doesnt/exist.html', (t) => {
+    test('/static/this/path/doesnt/exist.html', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/../index.js', (t) => {
+    test('/static/../index.js', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('file not exposed outside of the plugin', (t) => {
+    test('file not exposed outside of the plugin', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         // foobar is in static
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
   })
 })
 
-t.test('register /static/', t => {
+test('register /static/', t => {
   t.plan(12)
 
   const pluginOptions = {
@@ -387,150 +387,150 @@ t.test('register /static/', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.html', t => {
+    test('/static/index.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.css', (t) => {
+    test('/static/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/', (t) => {
+    test('/static/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', (t) => {
+    test('/static', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('/static/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test/', (t) => {
+    test('/static/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/for/test', (t) => {
+    test('/static/this/path/for/test', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/doesnt/exist.html', (t) => {
+    test('/static/this/path/doesnt/exist.html', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/../index.js', (t) => {
+    test('/static/../index.js', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('304', t => {
+    test('304', t => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
+        t.assert.ok(err instanceof Error)
         const etag = response.headers.etag
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
 
         simple.concat({
@@ -540,15 +540,15 @@ t.test('register /static/', t => {
             'if-none-match': etag
           }
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 304)
+          t.assert.ok(err instanceof Error)
+          t.assert.equal(response.statusCode, 304)
         })
       })
     })
   })
 })
 
-t.test('register /static and /static2', (t) => {
+test('register /static and /static2', (t) => {
   t.plan(5)
 
   const pluginOptions = {
@@ -566,69 +566,69 @@ t.test('register /static and /static2', (t) => {
     rep.sendFile('bar.html')
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         t.not(body.toString(), index2Content)
-        t.equal(body.toString(), indexContent)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/bar.html', (t) => {
+    test('/static/bar.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/bar.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), barContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('sendFile foo.html', (t) => {
+    test('sendFile foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), fooContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), fooContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('sendFile bar.html', (t) => {
+    test('sendFile bar.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/bar'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), barContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register /static with constraints', (t) => {
+test('register /static with constraints', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -641,14 +641,14 @@ t.test('register /static with constraints', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('example.com/static/index.html', (t) => {
+    test('example.com/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
@@ -657,14 +657,14 @@ t.test('register /static with constraints', (t) => {
           host: 'example.com'
         }
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('not-example.com/static/index.html', (t) => {
+    test('not-example.com/static/index.html', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
@@ -673,15 +673,15 @@ t.test('register /static with constraints', (t) => {
           host: 'not-example.com'
         }
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('payload.path is set', (t) => {
+test('payload.path is set', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -696,45 +696,45 @@ t.test('payload.path is set', (t) => {
     next()
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
-        t.equal(typeof gotFilename, 'string')
-        t.equal(gotFilename, path.join(pluginOptions.root, 'index.html'))
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
+        t.assert.equal(typeof gotFilename, 'string')
+        t.assert.equal(gotFilename, path.join(pluginOptions.root, 'index.html'))
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/this/path/doesnt/exist.html', (t) => {
+    test('/static/this/path/doesnt/exist.html', (t) => {
       t.plan(3 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
-        t.equal(typeof gotFilename, 'undefined')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
+        t.assert.equal(typeof gotFilename, 'undefined')
         genericErrorResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('error responses can be customized with fastify.setErrorHandler()', t => {
+test('error responses can be customized with fastify.setErrorHandler()', t => {
   t.plan(2)
 
   const pluginOptions = {
@@ -748,14 +748,14 @@ t.test('error responses can be customized with fastify.setErrorHandler()', t =>
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/../index.js', t => {
+    test('/../index.js', t => {
       t.plan(4)
 
       simple.concat({
@@ -763,16 +763,16 @@ t.test('error responses can be customized with fastify.setErrorHandler()', t =>
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.equal(body.toString(), '403 Custom error message')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
+        t.assert.equal(response.headers['content-type'], 'text/plain')
+        t.assert.equal(body.toString(), '403 Custom error message')
       })
     })
   })
 })
 
-t.test('not found responses can be customized with fastify.setNotFoundHandler()', t => {
+test('not found responses can be customized with fastify.setNotFoundHandler()', t => {
   t.plan(2)
 
   const pluginOptions = {
@@ -786,14 +786,14 @@ t.test('not found responses can be customized with fastify.setNotFoundHandler()'
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/path/does/not/exist.html', t => {
+    test('/path/does/not/exist.html', t => {
       t.plan(4)
 
       simple.concat({
@@ -801,16 +801,16 @@ t.test('not found responses can be customized with fastify.setNotFoundHandler()'
         url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.equal(body.toString(), '/path/does/not/exist.html Not Found')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
+        t.assert.equal(response.headers['content-type'], 'text/plain')
+        t.assert.equal(body.toString(), '/path/does/not/exist.html Not Found')
       })
     })
   })
 })
 
-t.test('fastify.setNotFoundHandler() is called for dotfiles when when send is configured to ignore dotfiles', t => {
+test('fastify.setNotFoundHandler() is called for dotfiles when when send is configured to ignore dotfiles', t => {
   t.plan(2)
 
   const pluginOptions = {
@@ -827,16 +827,16 @@ t.test('fastify.setNotFoundHandler() is called for dotfiles when when send is co
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
     // Requesting files with a leading dot doesn't follow the same code path as
     // other 404 errors
-    t.test('/path/does/not/.exist.html', t => {
+    test('/path/does/not/.exist.html', t => {
       t.plan(4)
 
       simple.concat({
@@ -844,16 +844,16 @@ t.test('fastify.setNotFoundHandler() is called for dotfiles when when send is co
         url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/.exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
-        t.equal(response.headers['content-type'], 'text/plain')
-        t.equal(body.toString(), '/path/does/not/.exist.html Not Found')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
+        t.assert.equal(response.headers['content-type'], 'text/plain')
+        t.assert.equal(body.toString(), '/path/does/not/.exist.html Not Found')
       })
     })
   })
 })
 
-t.test('serving disabled', (t) => {
+test('serving disabled', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -868,40 +868,40 @@ t.test('serving disabled', (t) => {
     reply.sendFile('index.html')
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html not found', (t) => {
+    test('/static/index.html not found', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('/static/index.html via sendFile found', (t) => {
+    test('/static/index.html via sendFile found', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('sendFile', (t) => {
+test('sendFile', (t) => {
   t.plan(5)
 
   const pluginOptions = {
@@ -928,70 +928,70 @@ t.test('sendFile', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('reply.sendFile()', (t) => {
+    test('reply.sendFile()', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.sendFile() with rootPath', (t) => {
+    test('reply.sendFile() with rootPath', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.sendFile() again without root path', (t) => {
+    test('reply.sendFile() again without root path', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.sendFile() with options', (t) => {
+    test('reply.sendFile() with options', (t) => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/options/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['cache-control'], `public, max-age=${maxAge / 1000}`)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['cache-control'], `public, max-age=${maxAge / 1000}`)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('sendFile disabled', (t) => {
+test('sendFile disabled', (t) => {
   t.plan(2)
 
   const pluginOptions = {
@@ -1011,26 +1011,26 @@ t.test('sendFile disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('reply.sendFile undefined', (t) => {
+    test('reply.sendFile undefined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), 'pass')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), 'pass')
       })
     })
   })
 })
 
-t.test('allowedPath option - pathname', (t) => {
+test('allowedPath option - pathname', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1040,38 +1040,38 @@ t.test('allowedPath option - pathname', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/foobar.html not found', (t) => {
+    test('/foobar.html not found', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/index.css found', (t) => {
+    test('/index.css found', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
       })
     })
   })
 })
 
-t.test('allowedPath option - request', (t) => {
+test('allowedPath option - request', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1081,38 +1081,38 @@ t.test('allowedPath option - request', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/foobar.html not found', (t) => {
+    test('/foobar.html not found', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/index.css found', (t) => {
+    test('/index.css found', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css?key=temporaryKey',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
       })
     })
   })
 })
 
-t.test('download', (t) => {
+test('download', (t) => {
   t.plan(7)
 
   const pluginOptions = {
@@ -1170,105 +1170,105 @@ t.test('download', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('reply.download()', (t) => {
+    test('reply.download()', (t) => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.download() with fileName', t => {
+    test('reply.download() with fileName', t => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/change',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.download() with fileName', (t) => {
+    test('reply.download() with fileName', (t) => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="foo.html"')
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="foo.html"')
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.download() with custom opts', (t) => {
+    test('reply.download() with custom opts', (t) => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.equal(response.headers['cache-control'], 'public, max-age=7200, immutable')
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
+        t.assert.equal(response.headers['cache-control'], 'public, max-age=7200, immutable')
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.download() with custom opts (2)', (t) => {
+    test('reply.download() with custom opts (2)', (t) => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override/2',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
-        t.equal(response.headers['accept-ranges'], undefined)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
+        t.assert.equal(response.headers['accept-ranges'], undefined)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('reply.download() with rootPath and fileName', (t) => {
+    test('reply.download() with rootPath and fileName', (t) => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test/change',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('sendFile disabled', (t) => {
+test('sendFile disabled', (t) => {
   t.plan(2)
 
   const pluginOptions = {
@@ -1288,26 +1288,26 @@ t.test('sendFile disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('reply.sendFile undefined', (t) => {
+    test('reply.sendFile undefined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), 'pass')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), 'pass')
       })
     })
   })
 })
 
-t.test('download disabled', (t) => {
+test('download disabled', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1320,7 +1320,7 @@ t.test('download disabled', (t) => {
 
   fastify.get('/foo/bar', function (req, reply) {
     if (reply.download === undefined) {
-      t.equal(reply.download, undefined)
+      t.assert.equal(reply.download, undefined)
       reply.send('pass')
     } else {
       reply.send('fail')
@@ -1328,38 +1328,38 @@ t.test('download disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('reply.sendFile undefined', (t) => {
+    test('reply.sendFile undefined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), 'pass')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), 'pass')
       })
     })
   })
 })
 
-t.test('prefix default', (t) => {
+test('prefix default', (t) => {
   t.plan(1)
   const pluginOptions = { root: path.join(__dirname, 'static') }
   const fastify = Fastify({ logger: false })
-  t.doesNotThrow(() => fastify.register(fastifyStatic, pluginOptions))
+  t.assert.doesNotThrow(() => fastify.register(fastifyStatic, pluginOptions))
 })
 
-t.test('root not found warning', (t) => {
+test('root not found warning', (t) => {
   t.plan(2)
   const rootPath = path.join(__dirname, 'does-not-exist')
   const pluginOptions = { root: rootPath }
   const destination = concat((data) => {
-    t.equal(JSON.parse(data).msg, `"root" path "${rootPath}" must exist`)
+    t.assert.equal(JSON.parse(data).msg, `"root" path "${rootPath}" must exist`)
   })
   const loggerInstance = pino(
     {
@@ -1370,13 +1370,13 @@ t.test('root not found warning', (t) => {
   const fastify = Fastify({ loggerInstance })
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
     fastify.server.unref()
     destination.end()
   })
 })
 
-t.test('send options', (t) => {
+test('send options', (t) => {
   t.plan(12)
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1394,18 +1394,18 @@ t.test('send options', (t) => {
   const fastify = Fastify({ logger: false })
   const fastifyStatic = require('proxyquire')('../', {
     '@fastify/send': function sendStub (req, pathName, options) {
-      t.equal(pathName, '/index.html')
-      t.equal(options.root, path.join(__dirname, '/static'))
-      t.equal(options.acceptRanges, 'acceptRanges')
-      t.equal(options.contentType, 'contentType')
-      t.equal(options.cacheControl, 'cacheControl')
-      t.equal(options.dotfiles, 'dotfiles')
-      t.equal(options.etag, 'etag')
-      t.equal(options.extensions, 'extensions')
-      t.equal(options.immutable, 'immutable')
-      t.equal(options.index, 'index')
-      t.equal(options.lastModified, 'lastModified')
-      t.equal(options.maxAge, 'maxAge')
+      t.assert.equal(pathName, '/index.html')
+      t.assert.equal(options.root, path.join(__dirname, '/static'))
+      t.assert.equal(options.acceptRanges, 'acceptRanges')
+      t.assert.equal(options.contentType, 'contentType')
+      t.assert.equal(options.cacheControl, 'cacheControl')
+      t.assert.equal(options.dotfiles, 'dotfiles')
+      t.assert.equal(options.etag, 'etag')
+      t.assert.equal(options.extensions, 'extensions')
+      t.assert.equal(options.immutable, 'immutable')
+      t.assert.equal(options.index, 'index')
+      t.assert.equal(options.lastModified, 'lastModified')
+      t.assert.equal(options.maxAge, 'maxAge')
       return { on: () => { }, pipe: () => { } }
     }
   })
@@ -1413,23 +1413,23 @@ t.test('send options', (t) => {
   fastify.inject({ url: '/index.html' })
 })
 
-t.test('setHeaders option', (t) => {
+test('setHeaders option', (t) => {
   t.plan(6 + GENERIC_RESPONSE_CHECK_COUNT)
 
   const pluginOptions = {
     root: path.join(__dirname, 'static'),
     setHeaders: function (res, pathName) {
-      t.equal(pathName, path.join(__dirname, 'static/index.html'))
+      t.assert.equal(pathName, path.join(__dirname, 'static/index.html'))
       res.setHeader('X-Test-Header', 'test')
     }
   }
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -1438,16 +1438,16 @@ t.test('setHeaders option', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['x-test-header'], 'test')
-      t.equal(body.toString(), indexContent)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(response.headers['x-test-header'], 'test')
+      t.assert.equal(body.toString(), indexContent)
       genericResponseChecks(t, response)
     })
   })
 })
 
-t.test('maxAge option', (t) => {
+test('maxAge option', (t) => {
   t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
   const pluginOptions = {
@@ -1457,10 +1457,10 @@ t.test('maxAge option', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -1469,121 +1469,121 @@ t.test('maxAge option', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['cache-control'], 'public, max-age=3600')
-      t.equal(body.toString(), indexContent)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(response.headers['cache-control'], 'public, max-age=3600')
+      t.assert.equal(body.toString(), indexContent)
       genericResponseChecks(t, response)
     })
   })
 })
 
-t.test('errors', (t) => {
+test('errors', (t) => {
   t.plan(11)
 
-  t.test('no root', (t) => {
+  test('no root', (t) => {
     t.plan(1)
     const pluginOptions = {}
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root is not a string', (t) => {
+  test('root is not a string', (t) => {
     t.plan(1)
     const pluginOptions = { root: 42 }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root is not an absolute path', (t) => {
+  test('root is not an absolute path', (t) => {
     t.plan(1)
     const pluginOptions = { root: './my/path' }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root is not a directory', (t) => {
+  test('root is not a directory', (t) => {
     t.plan(1)
     const pluginOptions = { root: __filename }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root is an empty array', (t) => {
+  test('root is an empty array', (t) => {
     t.plan(1)
     const pluginOptions = { root: [] }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root array does not contain strings', (t) => {
+  test('root array does not contain strings', (t) => {
     t.plan(1)
     const pluginOptions = { root: [1] }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root array does not contain an absolute path', (t) => {
+  test('root array does not contain an absolute path', (t) => {
     t.plan(1)
     const pluginOptions = { root: ['./my/path'] }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('root array path is not a directory', (t) => {
+  test('root array path is not a directory', (t) => {
     t.plan(1)
     const pluginOptions = { root: [__filename] }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('all root array paths must be valid', (t) => {
+  test('all root array paths must be valid', (t) => {
     t.plan(1)
     const pluginOptions = { root: [path.join(__dirname, '/static'), 1] }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('duplicate root paths are not allowed', (t) => {
+  test('duplicate root paths are not allowed', (t) => {
     t.plan(1)
     const pluginOptions = {
       root: [path.join(__dirname, '/static'), path.join(__dirname, '/static')]
     }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, Error)
+      t.assert.equal(err.constructor, Error)
     })
   })
 
-  t.test('setHeaders is not a function', (t) => {
+  test('setHeaders is not a function', (t) => {
     t.plan(1)
     const pluginOptions = { root: __dirname, setHeaders: 'headers' }
     const fastify = Fastify({ logger: false })
     fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.equal(err.constructor, TypeError)
+      t.assert.equal(err.constructor, TypeError)
     })
   })
 })
 
-t.test('register no prefix', (t) => {
+test('register no prefix', (t) => {
   t.plan(8)
 
   const pluginOptions = {
@@ -1596,105 +1596,105 @@ t.test('register no prefix', (t) => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.html', (t) => {
+    test('/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/index.css', (t) => {
+    test('/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/', (t) => {
+    test('/', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/deep/path/for/test/', (t) => {
+    test('/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/this/path/doesnt/exist.html', (t) => {
+    test('/this/path/doesnt/exist.html', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/../index.js', (t) => {
+    test('/../index.js', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('with fastify-compress', t => {
+test('with fastify-compress', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1704,12 +1704,12 @@ t.test('with fastify-compress', t => {
   fastify.register(compress, { threshold: 0 })
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
-    t.test('deflate', function (t) {
+    test('deflate', function (t) {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
@@ -1719,29 +1719,29 @@ t.test('with fastify-compress', t => {
           'accept-encoding': ['deflate']
         }
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-encoding'], 'deflate')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-encoding'], 'deflate')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('gzip', function (t) {
+    test('gzip', function (t) {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-encoding'], 'gzip')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(response.headers['content-encoding'], 'gzip')
         genericResponseChecks(t, response)
       })
     })
   })
 })
-t.test('register /static/ with schemaHide true', t => {
+test('register /static/ with schemaHide true', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1753,35 +1753,35 @@ t.test('register /static/ with schemaHide true', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRoute', function (routeOptions) {
-    t.same(routeOptions.schema, { hide: true })
+    t.assert.deepStrictEqual(routeOptions.schema, { hide: true })
   })
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register /static/ with schemaHide false', t => {
+test('register /static/ with schemaHide false', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1793,35 +1793,35 @@ t.test('register /static/ with schemaHide false', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRoute', function (routeOptions) {
-    t.same(routeOptions.schema, { hide: false })
+    t.assert.deepStrictEqual(routeOptions.schema, { hide: false })
   })
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register /static/ without schemaHide', t => {
+test('register /static/ without schemaHide', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -1832,35 +1832,35 @@ t.test('register /static/ without schemaHide', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRoute', function (routeOptions) {
-    t.same(routeOptions.schema, { hide: true })
+    t.assert.deepStrictEqual(routeOptions.schema, { hide: true })
   })
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('fastify with exposeHeadRoutes', t => {
+test('fastify with exposeHeadRoutes', t => {
   t.plan(2)
 
   const pluginOptions = {
@@ -1870,29 +1870,29 @@ t.test('fastify with exposeHeadRoutes', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.html', t => {
+    test('/index.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register with wildcard false', t => {
+test('register with wildcard false', t => {
   t.plan(9)
 
   const pluginOptions = {
@@ -1906,118 +1906,118 @@ t.test('register with wildcard false', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.html', t => {
+    test('/index.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/index.css', (t) => {
+    test('/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/', (t) => {
+    test('/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/not-defined', (t) => {
+    test('/not-defined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/deep/path/for/test/', (t) => {
+    test('/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/../index.js', (t) => {
+    test('/../index.js', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/index.css', t => {
+    test('/index.css', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register with wildcard false (trailing slash in the root)', t => {
+test('register with wildcard false (trailing slash in the root)', t => {
   t.plan(6)
 
   const pluginOptions = {
@@ -2035,79 +2035,79 @@ t.test('register with wildcard false (trailing slash in the root)', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.css', (t) => {
+    test('/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/not-defined', (t) => {
+    test('/not-defined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/not-defined'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/deep/path/for/test/purpose/foo.html', (t) => {
+    test('/deep/path/for/test/purpose/foo.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/../index.js', (t) => {
+    test('/../index.js', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/index.css', t => {
+    test('/index.css', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register with wildcard string', (t) => {
+test('register with wildcard string', (t) => {
   t.plan(1)
 
   const pluginOptions = {
@@ -2122,11 +2122,11 @@ t.test('register with wildcard string', (t) => {
   })
 
   fastify.ready(function (err) {
-    t.ok(err)
+    t.assert.ok(err)
   })
 })
 
-t.test('register with wildcard string on multiple root paths', (t) => {
+test('register with wildcard string on multiple root paths', (t) => {
   t.plan(1)
 
   const pluginOptions = {
@@ -2140,16 +2140,16 @@ t.test('register with wildcard string on multiple root paths', (t) => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.ok(err)
+    t.assert.ok(err)
 
     fastify.server.unref()
   })
 })
 
-t.test('register with wildcard false and alternative index', t => {
+test('register with wildcard false and alternative index', t => {
   t.plan(11)
 
   const pluginOptions = {
@@ -2164,144 +2164,144 @@ t.test('register with wildcard false and alternative index', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.html', (t) => {
+    test('/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/index.html', t => {
+    test('/index.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/index.css', (t) => {
+    test('/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/?a=b', (t) => {
+    test('/?a=b', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), foobarContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), foobarContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/?a=b', t => {
+    test('/?a=b', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/not-defined', (t) => {
+    test('/not-defined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/deep/path/for/test/purpose/', (t) => {
+    test('/deep/path/for/test/purpose/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/deep/path/for/test/', (t) => {
+    test('/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/deep/path/for/test/', t => {
+    test('/deep/path/for/test/', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/../index.js', (t) => {
+    test('/../index.js', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
   })
 })
 
-t.test('register /static with wildcard false and alternative index', t => {
+test('register /static with wildcard false and alternative index', t => {
   t.plan(11)
 
   const pluginOptions = {
@@ -2317,151 +2317,151 @@ t.test('register /static with wildcard false and alternative index', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.html', t => {
+    test('/static/index.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/index.css', (t) => {
+    test('/static/index.css', (t) => {
       t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', (t) => {
+    test('/static', (t) => {
       t.plan(2)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       // to verify we do not get a redirect when not requested
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 200)
+        t.assert.equal(res.statusCode, 200)
         let body = ''
         res.on('data', (chunk) => {
           body += chunk.toString()
         })
         res.on('end', () => {
-          t.same(JSON.parse(body.toString()), { hello: 'world' })
+          t.assert.deepStrictEqual(JSON.parse(body.toString()), { hello: 'world' })
         })
       })
       req.on('error', (err) => console.error(err))
       req.end()
     })
 
-    t.test('/static/', (t) => {
+    test('/static/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), foobarContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), foobarContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/', t => {
+    test('/static/', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/not-defined', (t) => {
+    test('/static/not-defined', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/not-defined'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
 
-    t.test('/static/deep/path/for/test/purpose/', (t) => {
+    test('/static/deep/path/for/test/purpose/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), deepContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test/', (t) => {
+    test('/static/deep/path/for/test/', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/../index.js', (t) => {
+    test('/static/../index.js', (t) => {
       t.plan(3)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
     })
   })
 })
 
-t.test('register /static with redirect true', t => {
+test('register /static with redirect true', t => {
   t.plan(7)
 
   const pluginOptions = {
@@ -2475,21 +2475,21 @@ t.test('register /static with redirect true', t => {
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static?a=b', (t) => {
+    test('/static?a=b', (t) => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 301)
-        t.equal(res.headers.location, '/static/?a=b')
+        t.assert.equal(res.statusCode, 301)
+        t.assert.equal(res.headers.location, '/static/?a=b')
       })
       req.on('error', (err) => console.error(err))
       req.end()
@@ -2498,61 +2498,61 @@ t.test('register /static with redirect true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', t => {
+    test('/static', t => {
       t.plan(2)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 301)
-        t.equal(res.headers.location, '/static/')
+        t.assert.equal(res.statusCode, 301)
+        t.assert.equal(res.headers.location, '/static/')
       })
       req.on('error', err => console.error(err))
       req.end()
     })
 
-    t.test('/static/', t => {
+    test('/static/', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep', (t) => {
+    test('/static/deep', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test?a=b', (t) => {
+    test('/static/deep/path/for/test?a=b', (t) => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 301)
-        t.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+        t.assert.equal(res.statusCode, 301)
+        t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
       })
       req.on('error', (err) => console.error(err))
       req.end()
@@ -2562,30 +2562,30 @@ t.test('register /static with redirect true', t => {
         method: 'GET',
         url: testurl
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test', (t) => {
+    test('/static/deep/path/for/test', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('register /static with redirect true and wildcard false', t => {
+test('register /static with redirect true and wildcard false', t => {
   t.plan(8)
 
   const pluginOptions = {
@@ -2600,21 +2600,21 @@ t.test('register /static with redirect true and wildcard false', t => {
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static?a=b', t => {
+    test('/static?a=b', t => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 301)
-        t.equal(res.headers.location, '/static/?a=b')
+        t.assert.equal(res.statusCode, 301)
+        t.assert.equal(res.headers.location, '/static/?a=b')
       })
       req.on('error', err => console.error(err))
       req.end()
@@ -2623,62 +2623,62 @@ t.test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/?a=b', t => {
+    test('/static/?a=b', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/?a=b', t => {
+    test('/static/?a=b', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep', t => {
+    test('/static/deep', t => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test?a=b', t => {
+    test('/static/deep/path/for/test?a=b', t => {
       t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
       // simple-get doesn't tell us about redirects so use http.request directly
       const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
       const req = http.request(url.parse(testurl), res => {
-        t.equal(res.statusCode, 301)
-        t.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+        t.assert.equal(res.statusCode, 301)
+        t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
       })
       req.on('error', err => console.error(err))
       req.end()
@@ -2688,44 +2688,44 @@ t.test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: testurl
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test', t => {
+    test('/static/deep/path/for/test', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), innerIndex)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/deep/path/for/test', t => {
+    test('/static/deep/path/for/test', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
       simple.concat({
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), '')
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('trailing slash behavior with redirect = false', (t) => {
+test('trailing slash behavior with redirect = false', (t) => {
   t.plan(6)
 
   const fastify = Fastify()
@@ -2736,71 +2736,71 @@ t.test('trailing slash behavior with redirect = false', (t) => {
   })
   fastify.server.unref()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     const host = 'http://localhost:' + fastify.server.address().port
 
-    t.test('prefix with no trailing slash => 404', (t) => {
+    test('prefix with no trailing slash => 404', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: host + '/static'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('prefix with trailing trailing slash => 200', (t) => {
+    test('prefix with trailing trailing slash => 200', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: host + '/static/'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
       })
     })
 
-    t.test('deep path with no index.html or trailing slash => 404', (t) => {
+    test('deep path with no index.html or trailing slash => 404', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: host + '/static/deep/path'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
 
-    t.test('deep path with index.html but no trailing slash => 200', (t) => {
+    test('deep path with index.html but no trailing slash => 200', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: host + '/static/deep/path/for/test'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
       })
     })
 
-    t.test('deep path with index.html and trailing slash => 200', (t) => {
+    test('deep path with index.html and trailing slash => 200', (t) => {
       t.plan(2)
       simple.concat({
         method: 'GET',
         url: host + '/static/deep/path/for/test/'
       }, (err, response) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
       })
     })
   })
 })
 
-t.test('if dotfiles are properly served according to plugin options', (t) => {
+test('if dotfiles are properly served according to plugin options', (t) => {
   t.plan(3)
   const exampleContents = fs
     .readFileSync(path.join(__dirname, 'static', '.example'), {
@@ -2808,7 +2808,7 @@ t.test('if dotfiles are properly served according to plugin options', (t) => {
     })
     .toString()
 
-  t.test('freely serve dotfiles', (t) => {
+  test('freely serve dotfiles', (t) => {
     t.plan(4)
     const fastify = Fastify()
 
@@ -2820,22 +2820,22 @@ t.test('if dotfiles are properly served according to plugin options', (t) => {
 
     fastify.register(fastifyStatic, pluginOptions)
 
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.error(err)
+      t.assert.ok(err instanceof Error)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), exampleContents)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), exampleContents)
       })
     })
   })
 
-  t.test('ignore dotfiles', (t) => {
+  test('ignore dotfiles', (t) => {
     t.plan(3)
     const fastify = Fastify()
 
@@ -2847,21 +2847,21 @@ t.test('if dotfiles are properly served according to plugin options', (t) => {
 
     fastify.register(fastifyStatic, pluginOptions)
 
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.error(err)
+      t.assert.ok(err instanceof Error)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
       })
     })
   })
 
-  t.test('deny requests to serve a dotfile', (t) => {
+  test('deny requests to serve a dotfile', (t) => {
     t.plan(3)
     const fastify = Fastify()
 
@@ -2873,22 +2873,22 @@ t.test('if dotfiles are properly served according to plugin options', (t) => {
 
     fastify.register(fastifyStatic, pluginOptions)
 
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.error(err)
+      t.assert.ok(err instanceof Error)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 403)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 403)
       })
     })
   })
 })
 
-t.test('register with failing glob handler', (t) => {
+test('register with failing glob handler', (t) => {
   const fastifyStatic = proxyquire.noCallThru()('../', {
     glob: function globStub (pattern, options, cb) {
       process.nextTick(function () {
@@ -2905,16 +2905,15 @@ t.test('register with failing glob handler', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
     fastify.server.unref()
-    t.ok(err)
-    t.end()
+    t.assert.ok(err)
   })
 })
 
-t.test(
+test(
   'register with rootpath that causes statSync to fail with non-ENOENT code',
   (t) => {
     const fastifyStatic = proxyquire('../', {
@@ -2932,33 +2931,32 @@ t.test(
     const fastify = Fastify()
     fastify.register(fastifyStatic, pluginOptions)
 
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
       fastify.server.unref()
-      t.ok(err)
-      t.end()
+      t.assert.ok(err)
     })
   }
 )
 
-t.test('inject support', async (t) => {
+test('inject support', async (t) => {
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
     prefix: '/static'
   }
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   const response = await fastify.inject({
     method: 'GET',
     url: '/static/index.html'
   })
-  t.equal(response.statusCode, 200)
-  t.equal(response.body.toString(), indexContent)
+  t.assert.equal(response.statusCode, 200)
+  t.assert.equal(response.body.toString(), indexContent)
 })
 
-t.test('routes should use custom errorHandler premature stream close', t => {
+test('routes should use custom errorHandler premature stream close', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -2969,7 +2967,7 @@ t.test('routes should use custom errorHandler premature stream close', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRoute', function (routeOptions) {
-    t.ok(routeOptions.errorHandler instanceof Function)
+    t.assert.ok(routeOptions.errorHandler instanceof Function)
 
     routeOptions.onRequest = (request, reply, done) => {
       const fakeError = new Error()
@@ -2979,7 +2977,7 @@ t.test('routes should use custom errorHandler premature stream close', t => {
   })
 
   fastify.register(fastifyStatic, pluginOptions)
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.inject(
     {
@@ -2987,13 +2985,13 @@ t.test('routes should use custom errorHandler premature stream close', t => {
       url: '/static/index.html'
     },
     (err, response) => {
-      t.error(err)
-      t.equal(response, null)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response, null)
     }
   )
 })
 
-t.test('routes should fallback to default errorHandler', t => {
+test('routes should fallback to default errorHandler', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -3004,7 +3002,7 @@ t.test('routes should fallback to default errorHandler', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRoute', function (routeOptions) {
-    t.ok(routeOptions.errorHandler instanceof Function)
+    t.assert.ok(routeOptions.errorHandler instanceof Function)
 
     routeOptions.preHandler = (request, reply, done) => {
       const fakeError = new Error()
@@ -3014,14 +3012,14 @@ t.test('routes should fallback to default errorHandler', t => {
   })
 
   fastify.register(fastifyStatic, pluginOptions)
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.inject({
     method: 'GET',
     url: '/static/index.html'
   }, (err, response) => {
-    t.error(err)
-    t.same(JSON.parse(response.payload), {
+    t.assert.ok(err instanceof Error)
+    t.assert.deepStrictEqual(JSON.parse(response.payload), {
       statusCode: 500,
       code: 'SOMETHING_ELSE',
       error: 'Internal Server Error',
@@ -3030,7 +3028,7 @@ t.test('routes should fallback to default errorHandler', t => {
   })
 })
 
-t.test('percent encoded URLs in glob mode', (t) => {
+test('percent encoded URLs in glob mode', (t) => {
   t.plan(4)
 
   const fastify = Fastify({})
@@ -3041,10 +3039,10 @@ t.test('percent encoded URLs in glob mode', (t) => {
     wildcard: true
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
     fastify.server.unref()
 
     simple.concat({
@@ -3052,9 +3050,9 @@ t.test('percent encoded URLs in glob mode', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/static/a .md',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(
         fs.readFileSync(path.join(__dirname, 'static', 'a .md'), 'utf-8'),
         body.toString()
       )
@@ -3062,7 +3060,7 @@ t.test('percent encoded URLs in glob mode', (t) => {
   })
 })
 
-t.test('register /static and /static2 without wildcard', t => {
+test('register /static and /static2 without wildcard', t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -3072,43 +3070,43 @@ t.test('register /static and /static2 without wildcard', t => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/index.html', t => {
+    test('/index.html', t => {
       t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
         t.not(body.toString(), index2Content)
-        t.equal(body.toString(), indexContent)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static/bar.html', t => {
+    test('/static/bar.html', t => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/bar.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), barContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test(
+test(
   'will serve pre-compressed files with .br at the highest priority',
   async (t) => {
     const pluginOptions = {
@@ -3120,7 +3118,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3131,14 +3129,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeBr)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files and fallback to .gz if .br is not on disk',
   async (t) => {
     const pluginOptions = {
@@ -3150,7 +3147,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3161,14 +3158,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, gzipOnly)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files with .gzip if * directive used',
   async (t) => {
     const pluginOptions = {
@@ -3180,7 +3176,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3191,14 +3187,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeGzip)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files with .gzip if multiple * directives used',
   async (t) => {
     const pluginOptions = {
@@ -3210,7 +3205,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3221,14 +3216,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeGzip)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
 
-t.test(
+test(
   'will serve uncompressed files if there are no compressed variants on disk',
   async (t) => {
     const pluginOptions = {
@@ -3240,7 +3234,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3251,14 +3245,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], undefined)
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, uncompressedStatic)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], undefined)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, uncompressedStatic)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files with .br at the highest priority (with wildcard: false)',
   async (t) => {
     const pluginOptions = {
@@ -3271,7 +3264,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3282,14 +3275,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeBr)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files and fallback to .gz if .br is not on disk (with wildcard: false)',
   async (t) => {
     const pluginOptions = {
@@ -3302,7 +3294,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3313,14 +3305,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, gzipOnly)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files with .gzip if * directive used (with wildcard: false)',
   async (t) => {
     const pluginOptions = {
@@ -3333,7 +3324,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3344,14 +3335,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeGzip)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
 
-t.test(
+test(
   'will serve pre-compressed files with .gzip if multiple * directives used (with wildcard: false)',
   async (t) => {
     const pluginOptions = {
@@ -3364,7 +3354,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3375,14 +3365,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeGzip)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
 
-t.test(
+test(
   'will serve uncompressed files if there are no compressed variants on disk (with wildcard: false)',
   async (t) => {
     const pluginOptions = {
@@ -3395,7 +3384,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3406,14 +3395,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], undefined)
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, uncompressedStatic)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], undefined)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, uncompressedStatic)
   }
 )
 
-t.test(
+test(
   'will serve uncompressed files the accept-encoding header is missing',
   async (t) => {
     const pluginOptions = {
@@ -3425,7 +3413,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3433,14 +3421,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], undefined)
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, uncompressedStatic)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], undefined)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, uncompressedStatic)
   }
 )
 
-t.test(
+test(
   'will serve precompressed index',
   async (t) => {
     const pluginOptions = {
@@ -3452,7 +3439,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3463,14 +3450,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, indexBr)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, indexBr)
   }
 )
 
-t.test(
+test(
   'will serve preCompressed index without trailing slash',
   async (t) => {
     const pluginOptions = {
@@ -3483,7 +3469,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3494,14 +3480,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, dirIndexBr)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, dirIndexBr)
   }
 )
 
-t.test(
+test(
   'will serve precompressed gzip index in subdir',
   async (t) => {
     const pluginOptions = {
@@ -3512,7 +3497,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3523,14 +3508,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, dirIndexGz)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, dirIndexGz)
   }
 )
 
-t.test(
+test(
   'will serve precompressed index with alternative index option',
   async (t) => {
     const pluginOptions = {
@@ -3543,7 +3527,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3554,14 +3538,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeBr)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
 
-t.test(
+test(
   'will serve precompressed file without content-type charset',
   async (t) => {
     const pluginOptions = {
@@ -3573,7 +3556,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3583,14 +3566,13 @@ t.test(
       }
     })
 
-    t.equal(response.headers['content-type'], 'image/jpeg')
-    t.equal(response.headers['content-encoding'], 'br')
-    t.equal(response.statusCode, 200)
-    t.end()
+    t.assert.equal(response.headers['content-type'], 'image/jpeg')
+    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.statusCode, 200)
   }
 )
 
-t.test(
+test(
   'nonexistent index with precompressed option',
   async (t) => {
     const pluginOptions = {
@@ -3602,7 +3584,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3612,13 +3594,12 @@ t.test(
       }
     })
 
-    t.equal(response.statusCode, 404)
+    t.assert.equal(response.statusCode, 404)
     genericErrorResponseChecks(t, response)
-    t.end()
   }
 )
 
-t.test('should not redirect to protocol-relative locations', (t) => {
+test('should not redirect to protocol-relative locations', (t) => {
   const urls = [
     ['//^/..', '/', 301],
     ['//^/.', null, 404], // it is NOT recognized as a directory by pillarjs/send
@@ -3638,15 +3619,15 @@ t.test('should not redirect to protocol-relative locations', (t) => {
     root: path.join(__dirname, '/static'),
     redirect: true
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
     urls.forEach(([testUrl, expected, status]) => {
       const req = http.request(url.parse(address + testUrl), res => {
-        t.equal(res.statusCode, status, `status ${testUrl}`)
+        t.assert.equal(res.statusCode, status, `status ${testUrl}`)
 
         if (expected) {
-          t.equal(res.headers.location, expected)
+          t.assert.equal(res.headers.location, expected)
         } else {
           t.notOk(res.headers.location)
         }
@@ -3657,7 +3638,7 @@ t.test('should not redirect to protocol-relative locations', (t) => {
   })
 })
 
-t.test('should not serve index if option is `false`', (t) => {
+test('should not serve index if option is `false`', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -3668,70 +3649,70 @@ t.test('should not serve index if option is `false`', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
-    t.test('/static/index.html', (t) => {
+    test('/static/index.html', (t) => {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(body.toString(), indexContent)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 200)
+        t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
       })
     })
 
-    t.test('/static', (t) => {
+    test('/static', (t) => {
       t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
+        t.assert.ok(err instanceof Error)
+        t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
     })
   })
 })
 
-t.test('should follow symbolic link without wildcard', (t) => {
+test('should follow symbolic link without wildcard', (t) => {
   t.plan(5)
   const fastify = Fastify()
   fastify.register(fastifyStatic, {
     root: path.join(__dirname, '/static-symbolic-link'),
     wildcard: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     simple.concat({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/origin/subdir/subdir/index.html'
     }, (err, response) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
     })
 
     simple.concat({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/dir/symlink/subdir/subdir/index.html'
     }, (err, response) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
     })
   })
 })
 
-t.test('should serve files into hidden dir with wildcard `false`', (t) => {
+test('should serve files into hidden dir with wildcard `false`', (t) => {
   t.plan(9)
 
   const pluginOptions = {
@@ -3742,10 +3723,10 @@ t.test('should serve files into hidden dir with wildcard `false`', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -3753,19 +3734,19 @@ t.test('should serve files into hidden dir with wildcard `false`', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), jsonHiddenContent)
-      t.ok(/application\/(json)/.test(response.headers['content-type']))
-      t.ok(response.headers.etag)
-      t.ok(response.headers['last-modified'])
-      t.ok(response.headers.date)
-      t.ok(response.headers['cache-control'])
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), jsonHiddenContent)
+      t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
+      t.assert.ok(response.headers.etag)
+      t.assert.ok(response.headers['last-modified'])
+      t.assert.ok(response.headers.date)
+      t.assert.ok(response.headers['cache-control'])
     })
   })
 })
 
-t.test('should not found hidden file with wildcard is `false`', (t) => {
+test('should not found hidden file with wildcard is `false`', (t) => {
   t.plan(3)
 
   const pluginOptions = {
@@ -3775,10 +3756,10 @@ t.test('should not found hidden file with wildcard is `false`', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -3786,13 +3767,13 @@ t.test('should not found hidden file with wildcard is `false`', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 404)
     })
   })
 })
 
-t.test('should serve files into hidden dir without wildcard option', (t) => {
+test('should serve files into hidden dir without wildcard option', (t) => {
   t.plan(9)
 
   const pluginOptions = {
@@ -3801,10 +3782,10 @@ t.test('should serve files into hidden dir without wildcard option', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -3812,19 +3793,19 @@ t.test('should serve files into hidden dir without wildcard option', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), jsonHiddenContent)
-      t.ok(/application\/(json)/.test(response.headers['content-type']))
-      t.ok(response.headers.etag)
-      t.ok(response.headers['last-modified'])
-      t.ok(response.headers.date)
-      t.ok(response.headers['cache-control'])
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(body.toString(), jsonHiddenContent)
+      t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
+      t.assert.ok(response.headers.etag)
+      t.assert.ok(response.headers['last-modified'])
+      t.assert.ok(response.headers.date)
+      t.assert.ok(response.headers['cache-control'])
     })
   })
 })
 
-t.test(
+test(
   'will serve pre-compressed files with .gzip if multi-root',
   async (t) => {
     const pluginOptions = {
@@ -3835,7 +3816,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3846,14 +3827,13 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(response.statusCode, 200)
-    t.same(response.rawPayload, allThreeGzip)
-    t.end()
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
 
-t.test(
+test(
   'will still serve un-compressed files with multi-root and preCompressed as true',
   async (t) => {
     const pluginOptions = {
@@ -3864,7 +3844,7 @@ t.test(
     const fastify = Fastify()
 
     fastify.register(fastifyStatic, pluginOptions)
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const response = await fastify.inject({
       method: 'GET',
@@ -3875,13 +3855,12 @@ t.test(
     })
 
     genericResponseChecks(t, response)
-    t.equal(response.statusCode, 200)
-    t.same(response.body, foobarContent)
-    t.end()
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
 
-t.test(
+test(
   'converts URL to path',
   async (t) => {
     t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
@@ -3900,12 +3879,12 @@ t.test(
       }
     })
     genericResponseChecks(t, response)
-    t.equal(response.statusCode, 200)
-    t.same(response.body, foobarContent)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
 
-t.test(
+test(
   'converts array of URLs to path, contains string path',
   async (t) => {
     t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
@@ -3924,12 +3903,12 @@ t.test(
       }
     })
     genericResponseChecks(t, response)
-    t.equal(response.statusCode, 200)
-    t.same(response.body, foobarContent)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
 
-t.test(
+test(
   'serves files with paths that have characters modified by encodeUri when wildcard is false',
   async (t) => {
     const aContent = fs.readFileSync(path.join(__dirname, 'static-encode/[...]', 'a .md'), 'utf-8')
@@ -3950,8 +3929,8 @@ t.test(
         'accept-encoding': '*, *'
       }
     })
-    t.equal(response.statusCode, 200)
-    t.same(response.body, aContent)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, aContent)
 
     const response2 = await fastify.inject({
       method: 'GET',
@@ -3960,12 +3939,12 @@ t.test(
         'accept-encoding': '*, *'
       }
     })
-    t.equal(response2.statusCode, 200)
-    t.same(response2.body, aContent)
+    t.assert.equal(response2.statusCode, 200)
+    t.assert.deepStrictEqual(response2.body, aContent)
   }
 )
 
-t.test(
+test(
   'serves files with % in the filename',
   async (t) => {
     t.plan(2)
@@ -3987,12 +3966,12 @@ t.test(
         'accept-encoding': '*, *'
       }
     })
-    t.equal(response.statusCode, 200)
-    t.same(response.body, txtContent)
+    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, txtContent)
   }
 )
 
-t.test('content-length in head route should not return zero when using wildcard', t => {
+test('content-length in head route should not return zero when using wildcard', t => {
   t.plan(6)
 
   const pluginOptions = {
@@ -4002,10 +3981,10 @@ t.test('content-length in head route should not return zero when using wildcard'
 
   fastify.register(fastifyStatic, pluginOptions)
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -4017,16 +3996,16 @@ t.test('content-length in head route should not return zero when using wildcard'
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-      t.equal(response.headers['content-length'], contentLength)
-      t.equal(body.toString(), '')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+      t.assert.equal(response.headers['content-length'], contentLength)
+      t.assert.equal(body.toString(), '')
     })
   })
 })
 
-t.test('respect the .code when using with sendFile', t => {
+test('respect the .code when using with sendFile', t => {
   t.plan(6)
 
   const pluginOptions = {
@@ -4040,10 +4019,10 @@ t.test('respect the .code when using with sendFile', t => {
     return reply.code(404).type('text/html').sendFile('foo.html')
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -4055,16 +4034,16 @@ t.test('respect the .code when using with sendFile', t => {
       url: 'http://localhost:' + fastify.server.address().port + '/custom',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-      t.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-      t.equal(response.headers['content-length'], contentLength)
-      t.equal(body.toString(), '')
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 404)
+      t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+      t.assert.equal(response.headers['content-length'], contentLength)
+      t.assert.equal(body.toString(), '')
     })
   })
 })
 
-t.test('respect the .type when using with sendFile with contentType disabled', t => {
+test('respect the .type when using with sendFile with contentType disabled', t => {
   t.plan(6)
 
   const pluginOptions = {
@@ -4079,10 +4058,10 @@ t.test('respect the .type when using with sendFile with contentType disabled', t
     return reply.type('text/html; charset=windows-1252').sendFile('foo.html')
   })
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ok(err instanceof Error)
 
     fastify.server.unref()
 
@@ -4094,11 +4073,11 @@ t.test('respect the .type when using with sendFile with contentType disabled', t
       url: 'http://localhost:' + fastify.server.address().port + '/custom',
       followRedirect: false
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-type'], 'text/html; charset=windows-1252')
-      t.equal(response.headers['content-length'], contentLength)
-      t.equal(body.toString(), fooContent)
+      t.assert.ok(err instanceof Error)
+      t.assert.equal(response.statusCode, 200)
+      t.assert.equal(response.headers['content-type'], 'text/html; charset=windows-1252')
+      t.assert.equal(response.headers['content-length'], contentLength)
+      t.assert.equal(body.toString(), fooContent)
     })
   })
 })

From 2e52f58b86813bd4220b312700addce78d001fa2 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Wed, 1 Jan 2025 23:33:49 +0100
Subject: [PATCH 02/93] chore: content type promises

---
 test/content-type.test.js | 130 ++++++++++---
 test/dir-list.test.js     |  58 +++---
 test/static.test.js       | 384 +++++++++++++++++++-------------------
 3 files changed, 327 insertions(+), 245 deletions(-)

diff --git a/test/content-type.test.js b/test/content-type.test.js
index 05d5c0a0..5b1c2346 100644
--- a/test/content-type.test.js
+++ b/test/content-type.test.js
@@ -21,66 +21,107 @@ test('register /content-type', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+  const { resolve, promise } = Promise.withResolvers()
+
+  fastify.listen({ port: 0 }, async (err) => {
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
-    t.test('/content-type/index.html', (t) => {
+    await t.test('/content-type/index.html', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.html'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/index.css', (t) => {
+    await t.test('/content-type/index.css', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.css'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/sample.jpg', (t) => {
+    await t.test('/content-type/sample.jpg', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'image/jpeg')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/test.txt', (t) => {
+    await t.test('/content-type/test.txt', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/test.txt'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/binary', (t) => {
+    await t.test('/content-type/binary', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/binary'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'application/octet-stream')
+
+        resolve()
       })
+
+      return promise
     })
+
+    resolve()
   })
+
+  return promise
 })
 
 test('register /content-type preCompressed', t => {
@@ -96,13 +137,18 @@ test('register /content-type preCompressed', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+  const { resolve, promise } = Promise.withResolvers()
+
+  fastify.listen({ port: 0 }, async (err) => {
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
-    t.test('/content-type/index.html', (t) => {
+    await t.test('/content-type/index.html', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.html',
@@ -110,13 +156,20 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/index.css', (t) => {
+    await t.test('/content-type/index.css', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.css',
@@ -124,13 +177,20 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/sample.jpg', (t) => {
+    await t.test('/content-type/sample.jpg', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg',
@@ -138,13 +198,20 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'image/jpeg')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/test.txt', (t) => {
+    await t.test('/content-type/test.txt', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/test.txt',
@@ -152,13 +219,20 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
+
+        resolve()
       })
+
+      return promise
     })
 
-    t.test('/content-type/binary', (t) => {
+    await t.test('/content-type/binary', (t) => {
       t.plan(2)
+
+      const { resolve, promise } = Promise.withResolvers()
+
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/content-type/binary',
@@ -166,9 +240,17 @@ test('register /content-type preCompressed', t => {
           'accept-encoding': 'gzip, deflate, br'
         }
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.headers['content-type'], 'application/octet-stream')
+
+        resolve()
       })
+
+      return promise
     })
+
+    resolve()
   })
+
+  return promise
 })
diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index fc83d972..21487fa2 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -20,7 +20,7 @@ const helper = {
     fastify.register(mock, options)
     t.after(() => fastify.close())
     fastify.listen({ port: 0 }, err => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       fastify.server.unref()
       f('http://localhost:' + fastify.server.address().port)
     })
@@ -135,7 +135,7 @@ test('dir list default options', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -163,7 +163,7 @@ test('dir list, custom options', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -191,7 +191,7 @@ test('dir list, custom options with empty array index', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -235,7 +235,7 @@ test('dir list html format', t => {
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.assert.ok(err instanceof Error)
+          t.assert.ifError(err)
           t.assert.equal(response.statusCode, 200)
           t.assert.equal(body.toString(), `
 <html><body>
@@ -291,14 +291,14 @@ test('dir list href nested structure', t => {
           method: 'GET',
           url: url + route.path
         }, (err, response, body) => {
-          t.assert.ok(err instanceof Error)
+          t.assert.ifError(err)
           t.assert.equal(response.statusCode, 200)
           t.assert.equal(body.toString(), route.response)
           simple.concat({
             method: 'GET',
             url: url + body.toString()
           }, (err, response, body) => {
-            t.assert.ok(err instanceof Error)
+            t.assert.ifError(err)
             t.assert.equal(response.statusCode, 200)
           })
         })
@@ -339,7 +339,7 @@ test('dir list html format - stats', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
     })
   })
@@ -381,7 +381,7 @@ test('dir list html format - extended info', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
     })
   })
@@ -410,7 +410,7 @@ test('dir list json format', t => {
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.assert.ok(err instanceof Error)
+          t.assert.ifError(err)
           t.assert.equal(response.statusCode, 200)
           t.assert.equal(body.toString(), JSON.stringify(content))
         })
@@ -444,7 +444,7 @@ test('dir list json format - extended info', t => {
           method: 'GET',
           url: url + route
         }, (err, response, body) => {
-          t.assert.ok(err instanceof Error)
+          t.assert.ifError(err)
           t.assert.equal(response.statusCode, 200)
           const bodyObject = JSON.parse(body.toString())
           t.assert.equal(bodyObject.dirs[0].name, 'empty')
@@ -478,7 +478,7 @@ test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
@@ -488,7 +488,7 @@ test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
@@ -498,7 +498,7 @@ test('json format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
@@ -525,7 +525,7 @@ test('json format with url parameter format and without render option', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
@@ -535,7 +535,7 @@ test('json format with url parameter format and without render option', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 500)
       t.assert.equal(JSON.parse(body.toString()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
     })
@@ -544,7 +544,7 @@ test('json format with url parameter format and without render option', t => {
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
@@ -574,7 +574,7 @@ test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
@@ -584,7 +584,7 @@ test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=html'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), 'html')
       t.ok(response.headers['content-type'].includes('text/html'))
@@ -594,7 +594,7 @@ test('html format with url parameter format', t => {
       method: 'GET',
       url: url + route + '?format=json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
@@ -620,7 +620,7 @@ test('dir list on empty dir', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -652,7 +652,7 @@ test('dir list serve index.html on index option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
       })
@@ -662,7 +662,7 @@ test('dir list serve index.html on index option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), 'dir list index')
       })
@@ -687,7 +687,7 @@ test('serve a non existent dir and get error', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -713,7 +713,7 @@ test('serve a non existent dir and get error', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -740,7 +740,7 @@ test('dir list with dotfiles allow option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -768,7 +768,7 @@ test('dir list with dotfiles deny option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -796,7 +796,7 @@ test('dir list with dotfiles ignore option', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), JSON.stringify(content))
       })
@@ -834,7 +834,7 @@ test('dir list error', t => {
         method: 'GET',
         url: url + route
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(JSON.parse(body.toString()).message, errorMessage)
         t.assert.equal(response.statusCode, 500)
       })
diff --git a/test/static.test.js b/test/static.test.js
index e768d6e1..e51dea68 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -85,7 +85,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -95,7 +95,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -108,7 +108,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -120,7 +120,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -133,7 +133,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -146,7 +146,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -159,7 +159,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -173,7 +173,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -186,7 +186,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -199,7 +199,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
@@ -212,7 +212,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         // foobar is in static
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -223,7 +223,7 @@ test('register /static prefixAvoidTrailingSlash', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -245,7 +245,7 @@ test('register /static', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -255,7 +255,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -268,7 +268,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -280,7 +280,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -293,7 +293,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -304,7 +304,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -317,7 +317,7 @@ test('register /static', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -331,7 +331,7 @@ test('register /static', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -344,7 +344,7 @@ test('register /static', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -357,7 +357,7 @@ test('register /static', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
@@ -370,7 +370,7 @@ test('register /static', (t) => {
         // foobar is in static
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -390,7 +390,7 @@ test('register /static/', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -400,7 +400,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -413,7 +413,7 @@ test('register /static/', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -426,7 +426,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -438,7 +438,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -451,7 +451,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -462,7 +462,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -475,7 +475,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -489,7 +489,7 @@ test('register /static/', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -502,7 +502,7 @@ test('register /static/', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -515,7 +515,7 @@ test('register /static/', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
@@ -527,7 +527,7 @@ test('register /static/', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         const etag = response.headers.etag
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
@@ -540,7 +540,7 @@ test('register /static/', t => {
             'if-none-match': etag
           }
         }, (err, response, body) => {
-          t.assert.ok(err instanceof Error)
+          t.assert.ifError(err)
           t.assert.equal(response.statusCode, 304)
         })
       })
@@ -569,7 +569,7 @@ test('register /static and /static2', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -579,7 +579,7 @@ test('register /static and /static2', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.not(body.toString(), index2Content)
         t.assert.equal(body.toString(), indexContent)
@@ -593,7 +593,7 @@ test('register /static and /static2', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/bar.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
@@ -606,7 +606,7 @@ test('register /static and /static2', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), fooContent)
         genericResponseChecks(t, response)
@@ -619,7 +619,7 @@ test('register /static and /static2', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/bar'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
@@ -644,7 +644,7 @@ test('register /static with constraints', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -657,7 +657,7 @@ test('register /static with constraints', (t) => {
           host: 'example.com'
         }
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -673,7 +673,7 @@ test('register /static with constraints', (t) => {
           host: 'not-example.com'
         }
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -699,7 +699,7 @@ test('payload.path is set', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -709,7 +709,7 @@ test('payload.path is set', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         t.assert.equal(typeof gotFilename, 'string')
@@ -725,7 +725,7 @@ test('payload.path is set', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         t.assert.equal(typeof gotFilename, 'undefined')
         genericErrorResponseChecks(t, response)
@@ -751,7 +751,7 @@ test('error responses can be customized with fastify.setErrorHandler()', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -763,7 +763,7 @@ test('error responses can be customized with fastify.setErrorHandler()', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
         t.assert.equal(response.headers['content-type'], 'text/plain')
         t.assert.equal(body.toString(), '403 Custom error message')
@@ -789,7 +789,7 @@ test('not found responses can be customized with fastify.setNotFoundHandler()',
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -801,7 +801,7 @@ test('not found responses can be customized with fastify.setNotFoundHandler()',
         url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         t.assert.equal(response.headers['content-type'], 'text/plain')
         t.assert.equal(body.toString(), '/path/does/not/exist.html Not Found')
@@ -830,7 +830,7 @@ test('fastify.setNotFoundHandler() is called for dotfiles when when send is conf
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -844,7 +844,7 @@ test('fastify.setNotFoundHandler() is called for dotfiles when when send is conf
         url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/.exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         t.assert.equal(response.headers['content-type'], 'text/plain')
         t.assert.equal(body.toString(), '/path/does/not/.exist.html Not Found')
@@ -871,7 +871,7 @@ test('serving disabled', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -881,7 +881,7 @@ test('serving disabled', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -892,7 +892,7 @@ test('serving disabled', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -928,7 +928,7 @@ test('sendFile', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -939,7 +939,7 @@ test('sendFile', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -953,7 +953,7 @@ test('sendFile', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -967,7 +967,7 @@ test('sendFile', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -981,7 +981,7 @@ test('sendFile', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/options/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['cache-control'], `public, max-age=${maxAge / 1000}`)
         t.assert.equal(body.toString(), indexContent)
@@ -1011,7 +1011,7 @@ test('sendFile disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1022,7 +1022,7 @@ test('sendFile disabled', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), 'pass')
       })
@@ -1040,7 +1040,7 @@ test('allowedPath option - pathname', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1051,7 +1051,7 @@ test('allowedPath option - pathname', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -1064,7 +1064,7 @@ test('allowedPath option - pathname', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/index.css',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
       })
     })
@@ -1081,7 +1081,7 @@ test('allowedPath option - request', (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1092,7 +1092,7 @@ test('allowedPath option - request', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -1105,7 +1105,7 @@ test('allowedPath option - request', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/index.css?key=temporaryKey',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
       })
     })
@@ -1170,7 +1170,7 @@ test('download', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1181,7 +1181,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
         t.assert.equal(body.toString(), indexContent)
@@ -1196,7 +1196,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/change',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
         t.assert.equal(body.toString(), indexContent)
@@ -1211,7 +1211,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="foo.html"')
         t.assert.equal(body.toString(), deepContent)
@@ -1226,7 +1226,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
         t.assert.equal(response.headers['cache-control'], 'public, max-age=7200, immutable')
@@ -1242,7 +1242,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override/2',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
         t.assert.equal(response.headers['accept-ranges'], undefined)
@@ -1258,7 +1258,7 @@ test('download', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test/change',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
         t.assert.equal(body.toString(), deepContent)
@@ -1288,7 +1288,7 @@ test('sendFile disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1299,7 +1299,7 @@ test('sendFile disabled', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), 'pass')
       })
@@ -1328,7 +1328,7 @@ test('download disabled', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1339,7 +1339,7 @@ test('download disabled', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), 'pass')
       })
@@ -1370,7 +1370,7 @@ test('root not found warning', (t) => {
   const fastify = Fastify({ loggerInstance })
   fastify.register(fastifyStatic, pluginOptions)
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
     fastify.server.unref()
     destination.end()
   })
@@ -1429,7 +1429,7 @@ test('setHeaders option', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1438,7 +1438,7 @@ test('setHeaders option', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(response.headers['x-test-header'], 'test')
       t.assert.equal(body.toString(), indexContent)
@@ -1460,7 +1460,7 @@ test('maxAge option', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1469,7 +1469,7 @@ test('maxAge option', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(response.headers['cache-control'], 'public, max-age=3600')
       t.assert.equal(body.toString(), indexContent)
@@ -1599,7 +1599,7 @@ test('register no prefix', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1609,7 +1609,7 @@ test('register no prefix', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1622,7 +1622,7 @@ test('register no prefix', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -1634,7 +1634,7 @@ test('register no prefix', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -1646,7 +1646,7 @@ test('register no prefix', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -1659,7 +1659,7 @@ test('register no prefix', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -1673,7 +1673,7 @@ test('register no prefix', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/this/path/doesnt/exist.html',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -1686,7 +1686,7 @@ test('register no prefix', (t) => {
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
         genericErrorResponseChecks(t, response)
       })
@@ -1707,7 +1707,7 @@ test('with fastify-compress', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     test('deflate', function (t) {
       t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
@@ -1719,7 +1719,7 @@ test('with fastify-compress', t => {
           'accept-encoding': ['deflate']
         }
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-encoding'], 'deflate')
         genericResponseChecks(t, response)
@@ -1733,7 +1733,7 @@ test('with fastify-compress', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(response.headers['content-encoding'], 'gzip')
         genericResponseChecks(t, response)
@@ -1761,7 +1761,7 @@ test('register /static/ with schemaHide true', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1772,7 +1772,7 @@ test('register /static/ with schemaHide true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1801,7 +1801,7 @@ test('register /static/ with schemaHide false', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1812,7 +1812,7 @@ test('register /static/ with schemaHide false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1840,7 +1840,7 @@ test('register /static/ without schemaHide', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1851,7 +1851,7 @@ test('register /static/ without schemaHide', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1873,7 +1873,7 @@ test('fastify with exposeHeadRoutes', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1883,7 +1883,7 @@ test('fastify with exposeHeadRoutes', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -1909,7 +1909,7 @@ test('register with wildcard false', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -1919,7 +1919,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1932,7 +1932,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -1944,7 +1944,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -1957,7 +1957,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -1969,7 +1969,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -1982,7 +1982,7 @@ test('register with wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -1996,7 +1996,7 @@ test('register with wildcard false', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2008,7 +2008,7 @@ test('register with wildcard false', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2038,7 +2038,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -2048,7 +2048,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -2060,7 +2060,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/not-defined'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2072,7 +2072,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -2086,7 +2086,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/assets/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2098,7 +2098,7 @@ test('register with wildcard false (trailing slash in the root)', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2167,7 +2167,7 @@ test('register with wildcard false and alternative index', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -2177,7 +2177,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2190,7 +2190,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2203,7 +2203,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -2215,7 +2215,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), foobarContent)
         genericResponseChecks(t, response)
@@ -2228,7 +2228,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2241,7 +2241,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2253,7 +2253,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -2266,7 +2266,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2279,7 +2279,7 @@ test('register with wildcard false and alternative index', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2293,7 +2293,7 @@ test('register with wildcard false and alternative index', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2320,7 +2320,7 @@ test('register /static with wildcard false and alternative index', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -2330,7 +2330,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2343,7 +2343,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2356,7 +2356,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         genericResponseChecks(t, response)
       })
@@ -2388,7 +2388,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), foobarContent)
         genericResponseChecks(t, response)
@@ -2401,7 +2401,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2414,7 +2414,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/not-defined'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2426,7 +2426,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), deepContent)
         genericResponseChecks(t, response)
@@ -2439,7 +2439,7 @@ test('register /static with wildcard false and alternative index', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2453,7 +2453,7 @@ test('register /static with wildcard false and alternative index', t => {
         url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
         followRedirect: false
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
@@ -2478,7 +2478,7 @@ test('register /static with redirect true', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -2498,7 +2498,7 @@ test('register /static with redirect true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2525,7 +2525,7 @@ test('register /static with redirect true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2539,7 +2539,7 @@ test('register /static with redirect true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -2562,7 +2562,7 @@ test('register /static with redirect true', t => {
         method: 'GET',
         url: testurl
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2576,7 +2576,7 @@ test('register /static with redirect true', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2603,7 +2603,7 @@ test('register /static with redirect true and wildcard false', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -2623,7 +2623,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2637,7 +2637,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -2651,7 +2651,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2665,7 +2665,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -2688,7 +2688,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: testurl
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2702,7 +2702,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), innerIndex)
         genericResponseChecks(t, response)
@@ -2716,7 +2716,7 @@ test('register /static with redirect true and wildcard false', t => {
         method: 'HEAD',
         url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), '')
         genericResponseChecks(t, response)
@@ -2739,7 +2739,7 @@ test('trailing slash behavior with redirect = false', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     const host = 'http://localhost:' + fastify.server.address().port
 
@@ -2749,7 +2749,7 @@ test('trailing slash behavior with redirect = false', (t) => {
         method: 'GET',
         url: host + '/static'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -2760,7 +2760,7 @@ test('trailing slash behavior with redirect = false', (t) => {
         method: 'GET',
         url: host + '/static/'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
       })
     })
@@ -2771,7 +2771,7 @@ test('trailing slash behavior with redirect = false', (t) => {
         method: 'GET',
         url: host + '/static/deep/path'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -2782,7 +2782,7 @@ test('trailing slash behavior with redirect = false', (t) => {
         method: 'GET',
         url: host + '/static/deep/path/for/test'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
       })
     })
@@ -2793,7 +2793,7 @@ test('trailing slash behavior with redirect = false', (t) => {
         method: 'GET',
         url: host + '/static/deep/path/for/test/'
       }, (err, response) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
       })
     })
@@ -2822,13 +2822,13 @@ test('if dotfiles are properly served according to plugin options', (t) => {
 
     t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), exampleContents)
       })
@@ -2849,13 +2849,13 @@ test('if dotfiles are properly served according to plugin options', (t) => {
 
     t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
       })
     })
@@ -2875,13 +2875,13 @@ test('if dotfiles are properly served according to plugin options', (t) => {
 
     t.after(() => fastify.close())
     fastify.listen({ port: 0 }, (err) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
 
       simple.concat({
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 403)
       })
     })
@@ -2985,7 +2985,7 @@ test('routes should use custom errorHandler premature stream close', t => {
       url: '/static/index.html'
     },
     (err, response) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response, null)
     }
   )
@@ -3018,7 +3018,7 @@ test('routes should fallback to default errorHandler', t => {
     method: 'GET',
     url: '/static/index.html'
   }, (err, response) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
     t.assert.deepStrictEqual(JSON.parse(response.payload), {
       statusCode: 500,
       code: 'SOMETHING_ELSE',
@@ -3042,7 +3042,7 @@ test('percent encoded URLs in glob mode', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
     fastify.server.unref()
 
     simple.concat({
@@ -3050,7 +3050,7 @@ test('percent encoded URLs in glob mode', (t) => {
       url: 'http://localhost:' + fastify.server.address().port + '/static/a .md',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(
         fs.readFileSync(path.join(__dirname, 'static', 'a .md'), 'utf-8'),
@@ -3073,7 +3073,7 @@ test('register /static and /static2 without wildcard', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3083,7 +3083,7 @@ test('register /static and /static2 without wildcard', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.not(body.toString(), index2Content)
         t.assert.equal(body.toString(), indexContent)
@@ -3097,7 +3097,7 @@ test('register /static and /static2 without wildcard', t => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/bar.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), barContent)
         genericResponseChecks(t, response)
@@ -3621,7 +3621,7 @@ test('should not redirect to protocol-relative locations', (t) => {
   })
   t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err, address) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
     urls.forEach(([testUrl, expected, status]) => {
       const req = http.request(url.parse(address + testUrl), res => {
         t.assert.equal(res.statusCode, status, `status ${testUrl}`)
@@ -3652,7 +3652,7 @@ test('should not serve index if option is `false`', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3662,7 +3662,7 @@ test('should not serve index if option is `false`', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 200)
         t.assert.equal(body.toString(), indexContent)
         genericResponseChecks(t, response)
@@ -3675,7 +3675,7 @@ test('should not serve index if option is `false`', (t) => {
         method: 'GET',
         url: 'http://localhost:' + fastify.server.address().port + '/static'
       }, (err, response, body) => {
-        t.assert.ok(err instanceof Error)
+        t.assert.ifError(err)
         t.assert.equal(response.statusCode, 404)
         genericErrorResponseChecks(t, response)
       })
@@ -3692,13 +3692,13 @@ test('should follow symbolic link without wildcard', (t) => {
   })
   t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     simple.concat({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/origin/subdir/subdir/index.html'
     }, (err, response) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
     })
 
@@ -3706,7 +3706,7 @@ test('should follow symbolic link without wildcard', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/dir/symlink/subdir/subdir/index.html'
     }, (err, response) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
     })
   })
@@ -3726,7 +3726,7 @@ test('should serve files into hidden dir with wildcard `false`', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3734,7 +3734,7 @@ test('should serve files into hidden dir with wildcard `false`', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), jsonHiddenContent)
       t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
@@ -3759,7 +3759,7 @@ test('should not found hidden file with wildcard is `false`', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3767,7 +3767,7 @@ test('should not found hidden file with wildcard is `false`', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 404)
     })
   })
@@ -3785,7 +3785,7 @@ test('should serve files into hidden dir without wildcard option', (t) => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3793,7 +3793,7 @@ test('should serve files into hidden dir without wildcard option', (t) => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(body.toString(), jsonHiddenContent)
       t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
@@ -3984,7 +3984,7 @@ test('content-length in head route should not return zero when using wildcard',
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -3996,7 +3996,7 @@ test('content-length in head route should not return zero when using wildcard',
       url: 'http://localhost:' + fastify.server.address().port + '/index.html',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
       t.assert.equal(response.headers['content-length'], contentLength)
@@ -4022,7 +4022,7 @@ test('respect the .code when using with sendFile', t => {
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -4034,7 +4034,7 @@ test('respect the .code when using with sendFile', t => {
       url: 'http://localhost:' + fastify.server.address().port + '/custom',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 404)
       t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
       t.assert.equal(response.headers['content-length'], contentLength)
@@ -4061,7 +4061,7 @@ test('respect the .type when using with sendFile with contentType disabled', t =
   t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.assert.ok(err instanceof Error)
+    t.assert.ifError(err)
 
     fastify.server.unref()
 
@@ -4073,7 +4073,7 @@ test('respect the .type when using with sendFile with contentType disabled', t =
       url: 'http://localhost:' + fastify.server.address().port + '/custom',
       followRedirect: false
     }, (err, response, body) => {
-      t.assert.ok(err instanceof Error)
+      t.assert.ifError(err)
       t.assert.equal(response.statusCode, 200)
       t.assert.equal(response.headers['content-type'], 'text/html; charset=windows-1252')
       t.assert.equal(response.headers['content-length'], contentLength)

From b8578c36be19f2a6cef545a08d7dd5c5263febb1 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Wed, 1 Jan 2025 23:54:35 +0100
Subject: [PATCH 03/93] chore: removed simple get

---
 test/content-type.test.js | 176 +++++++++-----------------------------
 1 file changed, 40 insertions(+), 136 deletions(-)

diff --git a/test/content-type.test.js b/test/content-type.test.js
index 5b1c2346..a7157325 100644
--- a/test/content-type.test.js
+++ b/test/content-type.test.js
@@ -4,7 +4,6 @@
 
 const path = require('node:path')
 const { test } = require('node:test')
-const simple = require('simple-get')
 const Fastify = require('fastify')
 
 const fastifyStatic = require('../')
@@ -28,94 +27,44 @@ test('register /content-type', t => {
 
     fastify.server.unref()
 
-    await t.test('/content-type/index.html', (t) => {
+    await t.test('/content-type/index.html', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.html'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-
-        resolve()
-      })
-
-      return promise
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
     })
 
-    await t.test('/content-type/index.css', (t) => {
+    await t.test('/content-type/index.css', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.css'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
-
-        resolve()
-      })
-
-      return promise
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
     })
 
-    await t.test('/content-type/sample.jpg', (t) => {
+    await t.test('/content-type/sample.jpg', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'image/jpeg')
-
-        resolve()
-      })
-
-      return promise
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
     })
 
-    await t.test('/content-type/test.txt', (t) => {
+    await t.test('/content-type/test.txt', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/test.txt'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
-
-        resolve()
-      })
-
-      return promise
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
     })
 
-    await t.test('/content-type/binary', (t) => {
+    await t.test('/content-type/binary', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/binary'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'application/octet-stream')
-
-        resolve()
-      })
-
-      return promise
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
     })
 
     resolve()
@@ -144,109 +93,64 @@ test('register /content-type preCompressed', t => {
 
     fastify.server.unref()
 
-    await t.test('/content-type/index.html', (t) => {
+    await t.test('/content-type/index.html', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.html',
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html', {
         headers: {
           'accept-encoding': 'gzip, deflate, br'
         }
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-
-        resolve()
       })
-
-      return promise
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
     })
 
-    await t.test('/content-type/index.css', (t) => {
+    await t.test('/content-type/index.css', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/index.css',
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css', {
         headers: {
           'accept-encoding': 'gzip, deflate, br'
         }
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/css; charset=utf-8')
-
-        resolve()
       })
-
-      return promise
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
     })
 
-    await t.test('/content-type/sample.jpg', (t) => {
+    await t.test('/content-type/sample.jpg', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg',
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg', {
         headers: {
           'accept-encoding': 'gzip, deflate, br'
         }
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'image/jpeg')
-
-        resolve()
       })
-
-      return promise
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
     })
 
-    await t.test('/content-type/test.txt', (t) => {
+    await t.test('/content-type/test.txt', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/test.txt',
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt', {
         headers: {
           'accept-encoding': 'gzip, deflate, br'
         }
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'text/plain; charset=utf-8')
-
-        resolve()
       })
-
-      return promise
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
     })
 
-    await t.test('/content-type/binary', (t) => {
+    await t.test('/content-type/binary', async (t) => {
       t.plan(2)
 
-      const { resolve, promise } = Promise.withResolvers()
-
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/content-type/binary',
+      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary', {
         headers: {
           'accept-encoding': 'gzip, deflate, br'
         }
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.headers['content-type'], 'application/octet-stream')
-
-        resolve()
       })
-
-      return promise
+      t.assert.ok(response.ok)
+      t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
     })
 
     resolve()

From b76489c183b09fdfb923f9869057e68f56452eb7 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Wed, 1 Jan 2025 23:58:48 +0100
Subject: [PATCH 04/93] chore: listen as promise

---
 test/content-type.test.js | 178 +++++++++++++++++---------------------
 1 file changed, 81 insertions(+), 97 deletions(-)

diff --git a/test/content-type.test.js b/test/content-type.test.js
index a7157325..6607b7b6 100644
--- a/test/content-type.test.js
+++ b/test/content-type.test.js
@@ -8,8 +8,8 @@ const Fastify = require('fastify')
 
 const fastifyStatic = require('../')
 
-test('register /content-type', t => {
-  t.plan(6)
+test('register /content-type', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/content-type'),
@@ -20,61 +20,53 @@ test('register /content-type', t => {
 
   t.after(() => fastify.close())
 
-  const { resolve, promise } = Promise.withResolvers()
+  await fastify.listen({ port: 0 })
 
-  fastify.listen({ port: 0 }, async (err) => {
-    t.assert.ifError(err)
+  fastify.server.unref()
 
-    fastify.server.unref()
+  await t.test('/content-type/index.html', async (t) => {
+    t.plan(2)
 
-    await t.test('/content-type/index.html', async (t) => {
-      t.plan(2)
-
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html')
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  })
 
-    await t.test('/content-type/index.css', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/index.css', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css')
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
+  })
 
-    await t.test('/content-type/sample.jpg', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/sample.jpg', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg')
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
+  })
 
-    await t.test('/content-type/test.txt', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/test.txt', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt')
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
+  })
 
-    await t.test('/content-type/binary', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/binary', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary')
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
-    })
-
-    resolve()
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
   })
-
-  return promise
 })
 
-test('register /content-type preCompressed', t => {
-  t.plan(6)
+test('register /content-type preCompressed', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/content-type'),
@@ -86,75 +78,67 @@ test('register /content-type preCompressed', t => {
 
   t.after(() => fastify.close())
 
-  const { resolve, promise } = Promise.withResolvers()
-
-  fastify.listen({ port: 0 }, async (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    await t.test('/content-type/index.html', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/index.html', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html', {
-        headers: {
-          'accept-encoding': 'gzip, deflate, br'
-        }
-      })
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html', {
+      headers: {
+        'accept-encoding': 'gzip, deflate, br'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  })
 
-    await t.test('/content-type/index.css', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/index.css', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css', {
-        headers: {
-          'accept-encoding': 'gzip, deflate, br'
-        }
-      })
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css', {
+      headers: {
+        'accept-encoding': 'gzip, deflate, br'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
+  })
 
-    await t.test('/content-type/sample.jpg', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/sample.jpg', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg', {
-        headers: {
-          'accept-encoding': 'gzip, deflate, br'
-        }
-      })
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg', {
+      headers: {
+        'accept-encoding': 'gzip, deflate, br'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
+  })
 
-    await t.test('/content-type/test.txt', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/test.txt', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt', {
-        headers: {
-          'accept-encoding': 'gzip, deflate, br'
-        }
-      })
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt', {
+      headers: {
+        'accept-encoding': 'gzip, deflate, br'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
+  })
 
-    await t.test('/content-type/binary', async (t) => {
-      t.plan(2)
+  await t.test('/content-type/binary', async (t) => {
+    t.plan(2)
 
-      const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary', {
-        headers: {
-          'accept-encoding': 'gzip, deflate, br'
-        }
-      })
-      t.assert.ok(response.ok)
-      t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary', {
+      headers: {
+        'accept-encoding': 'gzip, deflate, br'
+      }
     })
-
-    resolve()
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
   })
-
-  return promise
 })

From 04b4905f573d732d2edf873933500aaf15d91351 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Thu, 2 Jan 2025 21:48:53 +0100
Subject: [PATCH 05/93] chore: prefixAvoidTrailingSlash

---
 test/static.test.js | 249 +++++++++++++++++++-------------------------
 1 file changed, 108 insertions(+), 141 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index e51dea68..7abfc836 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -58,21 +58,21 @@ const jsonHiddenContent = fs.readFileSync('./test/static-hidden/.hidden/sample.j
 
 const GENERIC_RESPONSE_CHECK_COUNT = 5
 function genericResponseChecks (t, response) {
-  t.assert.ok(/text\/(html|css)/.test(response.headers['content-type']))
-  t.assert.ok(response.headers.etag)
-  t.assert.ok(response.headers['last-modified'])
-  t.assert.ok(response.headers.date)
-  t.assert.ok(response.headers['cache-control'])
+  t.assert.ok(/text\/(html|css)/.test(response.headers.get('content-type')))
+  t.assert.ok(response.headers.get('etag'))
+  t.assert.ok(response.headers.get('last-modified'))
+  t.assert.ok(response.headers.get('date'))
+  t.assert.ok(response.headers.get('cache-control'))
 }
 
 const GENERIC_ERROR_RESPONSE_CHECK_COUNT = 2
 function genericErrorResponseChecks (t, response) {
-  t.assert.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-  t.assert.ok(response.headers.date)
+  t.assert.equal(response.headers.get('content-type'), 'application/json; charset=utf-8')
+  t.assert.ok(response.headers.get('date'))
 }
 
-test('register /static prefixAvoidTrailingSlash', t => {
-  t.plan(12)
+test('register /static prefixAvoidTrailingSlash', async t => {
+  t.plan(11)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -84,151 +84,118 @@ test('register /static prefixAvoidTrailingSlash', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
 
-    test('/static/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
 
-    test('/static', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
 
-    test('/static/this/path/for/test', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/this/path/doesnt/exist.html', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/../index.js', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('file not exposed outside of the plugin', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        // foobar is in static
-        url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+  await t.test('/static', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('file not exposed outside of the plugin', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/for/test', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/doesnt/exist.html', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/../index.js', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404) // FIXME: should be 403
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('file not exposed outside of the plugin', async (t) => {
+    t.plan(2)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
+
+  await t.test('file retrieve with HEAD method', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      method: 'HEAD'
     })
+
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
   })
 })
 

From d5f8d38f97f3366d7b23bbbf5aca19d33c2ff1ad Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Thu, 2 Jan 2025 21:56:38 +0100
Subject: [PATCH 06/93] fix: register /static

---
 test/static.test.js | 206 ++++++++++++++++++--------------------------
 1 file changed, 86 insertions(+), 120 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 7abfc836..94008ea4 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -199,8 +199,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
   })
 })
 
-test('register /static', (t) => {
-  t.plan(11)
+test('register /static', async (t) => {
+  t.plan(10)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -211,136 +211,102 @@ test('register /static', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/this/path/for/test', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static', async (t) => {
+    t.plan(2)
 
-    test('/static/this/path/doesnt/exist.html', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
 
-    test('/static/../index.js', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('file not exposed outside of the plugin', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        // foobar is in static
-        url: 'http://localhost:' + fastify.server.address().port + '/foobar.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/for/test', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/doesnt/exist.html', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/../index.js', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js', {
+      redirect: 'error'
     })
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404) // FIXME should be 403
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('file not exposed outside of the plugin', async (t) => {
+    t.plan(2)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
   })
 })
 

From 72468c13712c19f11a4bdc1810ba05a024acbe30 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 18:47:55 +0100
Subject: [PATCH 07/93] feat: static

---
 test/static.test.js | 251 +++++++++++++++++++-------------------------
 1 file changed, 106 insertions(+), 145 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 94008ea4..80c1f63c 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -173,7 +173,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404) // FIXME: should be 403
+    t.assert.equal(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -297,7 +297,7 @@ test('register /static', async (t) => {
       redirect: 'error'
     })
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404) // FIXME should be 403
+    t.assert.equal(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -310,8 +310,8 @@ test('register /static', async (t) => {
   })
 })
 
-test('register /static/', t => {
-  t.plan(12)
+test('register /static/', async t => {
+  t.plan(11)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -322,162 +322,123 @@ test('register /static/', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/index.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      method: 'HEAD'
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
 
-    test('/static', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+  await t.test('/static/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/this/path/for/test', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/for/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/this/path/doesnt/exist.html', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static', async (t) => {
+    t.plan(2)
 
-    test('/static/../index.js', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
 
-    test('304', t => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        const etag = response.headers.etag
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
+  await t.test('/static/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-        simple.concat({
-          method: 'GET',
-          url: 'http://localhost:' + fastify.server.address().port + '/static/index.html',
-          headers: {
-            'if-none-match': etag
-          }
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.equal(response.statusCode, 304)
-        })
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/for/test', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/doesnt/exist.html', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/../index.js', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('304', async t => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+
+    const response2 = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      headers: {
+        'if-none-match': response.headers.get('etag')
+      },
+      cache: 'no-cache'
     })
+    t.assert.ok(!response2.ok)
+    t.assert.equal(response2.status, 304)
   })
 })
 

From edeece6ce0775f41e7fe27d90b3601aa6350fc22 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 18:51:46 +0100
Subject: [PATCH 08/93] feat: static static2

---
 test/static.test.js | 95 +++++++++++++++++++--------------------------
 1 file changed, 41 insertions(+), 54 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 80c1f63c..0850b313 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -442,8 +442,8 @@ test('register /static/', async t => {
   })
 })
 
-test('register /static and /static2', (t) => {
-  t.plan(5)
+test('register /static and /static2', async (t) => {
+  t.plan(4)
 
   const pluginOptions = {
     root: [path.join(__dirname, '/static'), path.join(__dirname, '/static2')],
@@ -462,63 +462,50 @@ test('register /static and /static2', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.not(body.toString(), index2Content)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/bar.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/bar.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), barContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    const responseText = await response.text()
+    t.assert.equal(responseText, indexContent)
+    t.assert.notEqual(responseText, index2Content)
+    genericResponseChecks(t, response)
+  })
 
-    test('sendFile foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), fooContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/bar.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('sendFile bar.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/bar'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), barContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/bar.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), barContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('sendFile foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), fooContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('sendFile bar.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), barContent)
+    genericResponseChecks(t, response)
   })
 })
 

From b4e1ca1930b60b13c60f56308ecf233062fe1ad6 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:01:34 +0100
Subject: [PATCH 09/93] chore: constraints

---
 test/static.test.js | 59 ++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 33 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 0850b313..3f49f874 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -509,14 +509,14 @@ test('register /static and /static2', async (t) => {
   })
 })
 
-test('register /static with constraints', (t) => {
-  t.plan(3)
+test('register /static with constraints', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
     prefix: '/static',
     constraints: {
-      host: 'example.com'
+      version: '1.2.0'
     }
   }
   const fastify = Fastify()
@@ -524,41 +524,34 @@ test('register /static with constraints', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    fastify.server.unref()
+  await t.test('example.com/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('example.com/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html',
-        headers: {
-          host: 'example.com'
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      headers: {
+        'accept-version': '1.x'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('not-example.com/static/index.html', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html',
-        headers: {
-          host: 'not-example.com'
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
+  await t.test('not-example.com/static/index.html', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      headers: {
+        'accept-version': '2.x'
+      }
     })
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
   })
 })
 

From 80f65fb0b4109655495feadab8f202d4f60eb463 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:04:14 +0100
Subject: [PATCH 10/93] chore: payload path

---
 test/static.test.js | 55 +++++++++++++++++++--------------------------
 1 file changed, 23 insertions(+), 32 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 3f49f874..f10a0073 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -555,8 +555,8 @@ test('register /static with constraints', async (t) => {
   })
 })
 
-test('payload.path is set', (t) => {
-  t.plan(3)
+test('payload.path is set', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -572,39 +572,30 @@ test('payload.path is set', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        t.assert.equal(typeof gotFilename, 'string')
-        t.assert.equal(gotFilename, path.join(pluginOptions.root, 'index.html'))
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/this/path/doesnt/exist.html', (t) => {
-      t.plan(3 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        t.assert.equal(typeof gotFilename, 'undefined')
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    t.assert.equal(typeof gotFilename, 'string')
+    t.assert.equal(gotFilename, path.join(pluginOptions.root, 'index.html'))
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/this/path/doesnt/exist.html', async (t) => {
+    t.plan(3 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    t.assert.equal(typeof gotFilename, 'undefined')
+    genericErrorResponseChecks(t, response)
   })
 })
 

From d34908cab11de5d025ee6a809db3c73ce0243e52 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:12:05 +0100
Subject: [PATCH 11/93] chore: error handler

---
 test/static.test.js | 35 ++++++++++++++++-------------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index f10a0073..4473be2d 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -599,8 +599,8 @@ test('payload.path is set', async (t) => {
   })
 })
 
-test('error responses can be customized with fastify.setErrorHandler()', t => {
-  t.plan(2)
+test('error responses can be customized with fastify.setErrorHandler()', async t => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -608,32 +608,29 @@ test('error responses can be customized with fastify.setErrorHandler()', t => {
   const fastify = Fastify()
 
   fastify.setErrorHandler(function errorHandler (err, request, reply) {
-    reply.code(403).type('text/plain').send(err.status + ' Custom error message')
+    reply.code(403).type('text/plain').send(`${err.statusCode} Custom error message`)
+  })
+
+  fastify.get('/index.js', (_, reply) => {
+    return reply.type('text/html').sendFile('foo.js')
   })
 
   fastify.register(fastifyStatic, pluginOptions)
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/../index.js', t => {
-      t.plan(4)
+  await t.test('/../index.js', async t => {
+    t.plan(4)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-        t.assert.equal(response.headers['content-type'], 'text/plain')
-        t.assert.equal(body.toString(), '403 Custom error message')
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.js')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 403)
+    t.assert.equal(response.headers.get('content-type'), 'text/plain')
+    t.assert.equal(await response.text(), '500 Custom error message')
   })
 })
 

From 27fa33d0eb98dda464c4725e888087476bd18dd8 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:13:25 +0100
Subject: [PATCH 12/93] fix: not found

---
 test/static.test.js | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 4473be2d..ed305734 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -634,8 +634,8 @@ test('error responses can be customized with fastify.setErrorHandler()', async t
   })
 })
 
-test('not found responses can be customized with fastify.setNotFoundHandler()', t => {
-  t.plan(2)
+test('not found responses can be customized with fastify.setNotFoundHandler()', async t => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -650,25 +650,18 @@ test('not found responses can be customized with fastify.setNotFoundHandler()',
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/path/does/not/exist.html', t => {
-      t.plan(4)
+  await t.test('/path/does/not/exist.html', async t => {
+    t.plan(4)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        t.assert.equal(response.headers['content-type'], 'text/plain')
-        t.assert.equal(body.toString(), '/path/does/not/exist.html Not Found')
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/path/does/not/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    t.assert.equal(response.headers.get('content-type'), 'text/plain')
+    t.assert.equal(await response.text(), '/path/does/not/exist.html Not Found')
   })
 })
 

From af454c27803f1846e03c06356be686bceba27fc0 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:19:59 +0100
Subject: [PATCH 13/93] chore: not foundhandler

---
 test/static.test.js | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index ed305734..f4c9e700 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -665,8 +665,8 @@ test('not found responses can be customized with fastify.setNotFoundHandler()',
   })
 })
 
-test('fastify.setNotFoundHandler() is called for dotfiles when when send is configured to ignore dotfiles', t => {
-  t.plan(2)
+test('fastify.setNotFoundHandler() is called for dotfiles when send is configured to ignore dotfiles', async t => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -684,27 +684,20 @@ test('fastify.setNotFoundHandler() is called for dotfiles when when send is conf
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    // Requesting files with a leading dot doesn't follow the same code path as
-    // other 404 errors
-    test('/path/does/not/.exist.html', t => {
-      t.plan(4)
+  // Requesting files with a leading dot doesn't follow the same code path as
+  // other 404 errors
+  await t.test('/path/does/not/.exist.html', async t => {
+    t.plan(4)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/path/does/not/.exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        t.assert.equal(response.headers['content-type'], 'text/plain')
-        t.assert.equal(body.toString(), '/path/does/not/.exist.html Not Found')
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/path/does/not/.exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    t.assert.equal(response.headers.get('content-type'), 'text/plain')
+    t.assert.equal(await response.text(), '/path/does/not/.exist.html Not Found')
   })
 })
 

From 073effcee2596533ae1287dbf348fa3d8f597394 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:51:35 +0100
Subject: [PATCH 14/93] chore: serving disabled

---
 test/static.test.js | 46 +++++++++++++++++++--------------------------
 1 file changed, 19 insertions(+), 27 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index f4c9e700..0401ebec 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -701,8 +701,8 @@ test('fastify.setNotFoundHandler() is called for dotfiles when send is configure
   })
 })
 
-test('serving disabled', (t) => {
-  t.plan(3)
+test('serving disabled', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -718,34 +718,26 @@ test('serving disabled', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html not found', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+  await t.test('/static/index.html not found', async (t) => {
+    t.plan(2)
 
-    test('/static/index.html via sendFile found', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
+
+  await t.test('/static/index.html via sendFile found', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
   })
 })
 

From be4b33b0c0f0137f24c40e362819dc3f6f8dc1f9 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 19:59:26 +0100
Subject: [PATCH 15/93] chore: sendFile

---
 test/static.test.js | 96 ++++++++++++++++++---------------------------
 1 file changed, 38 insertions(+), 58 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 0401ebec..edb90d93 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -741,8 +741,8 @@ test('serving disabled', async (t) => {
   })
 })
 
-test('sendFile', (t) => {
-  t.plan(5)
+test('sendFile', async (t) => {
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -767,67 +767,47 @@ test('sendFile', (t) => {
     reply.sendFile('/index.html', { maxAge })
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    fastify.server.unref()
+  await t.test('reply.sendFile()', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('reply.sendFile()', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('reply.sendFile() with rootPath', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('reply.sendFile() with rootPath', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('reply.sendFile() again without root path', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('reply.sendFile() again without root path', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('reply.sendFile() with options', (t) => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/options/override/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['cache-control'], `public, max-age=${maxAge / 1000}`)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('reply.sendFile() with options', async (t) => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/options/override/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    t.assert.equal(response.headers.get('cache-control'), `public, max-age=${maxAge / 1000}`)
+    genericResponseChecks(t, response)
   })
 })
 

From 12243117af15e957e99529d6df3d0bde8e1d0026 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:03:30 +0100
Subject: [PATCH 16/93] chore: sendFile disabled

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index edb90d93..799e046a 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -811,8 +811,8 @@ test('sendFile', async (t) => {
   })
 })
 
-test('sendFile disabled', (t) => {
-  t.plan(2)
+test('sendFile disabled', async (t) => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -830,23 +830,17 @@ test('sendFile disabled', (t) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('reply.sendFile undefined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), 'pass')
-      })
-    })
+  await t.test('reply.sendFile undefined', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), 'pass')
   })
 })
 

From dd9751f8991d4c6c455bd366b90c10fb9488d8f3 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:04:55 +0100
Subject: [PATCH 17/93] chore: allowedPath

---
 test/static.test.js | 46 ++++++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 28 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 799e046a..4ce092bf 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -844,8 +844,8 @@ test('sendFile disabled', async (t) => {
   })
 })
 
-test('allowedPath option - pathname', (t) => {
-  t.plan(3)
+test('allowedPath option - pathname', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -853,35 +853,25 @@ test('allowedPath option - pathname', (t) => {
   }
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
 
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    test('/foobar.html not found', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/foobar.html not found', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
-    test('/index.css found', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/index.css found', async (t) => {
+    t.plan(2)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
   })
 })
 

From 30cff993d832875a550c7dd60a2afaada36d8851 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:06:26 +0100
Subject: [PATCH 18/93] chore: allowed path request

---
 test/static.test.js | 46 ++++++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 28 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 4ce092bf..2a07fbfd 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -875,8 +875,8 @@ test('allowedPath option - pathname', async (t) => {
   })
 })
 
-test('allowedPath option - request', (t) => {
-  t.plan(3)
+test('allowedPath option - request', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -884,35 +884,25 @@ test('allowedPath option - request', (t) => {
   }
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/foobar.html not found', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foobar.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/foobar.html not found', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
-    test('/index.css found', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css?key=temporaryKey',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/index.css found', async (t) => {
+    t.plan(2)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css?key=temporaryKey')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
   })
 })
 

From d66ff12c409f3a740965b7286c3f9e0088b4b2bb Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:15:26 +0100
Subject: [PATCH 19/93] chore: download

---
 test/static.test.js | 156 ++++++++++++++++++--------------------------
 1 file changed, 65 insertions(+), 91 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 2a07fbfd..95077851 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -906,8 +906,8 @@ test('allowedPath option - request', async (t) => {
   })
 })
 
-test('download', (t) => {
-  t.plan(7)
+test('download', async (t) => {
+  t.plan(6)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -963,102 +963,76 @@ test('download', (t) => {
     })
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('reply.download()', (t) => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('reply.download()', async (t) => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('reply.download() with fileName', t => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/change',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('reply.download() with fileName', (t) => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="foo.html"')
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('reply.download() with fileName', async t => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('reply.download() with custom opts', (t) => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.assert.equal(response.headers['cache-control'], 'public, max-age=7200, immutable')
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/change')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('reply.download() with custom opts (2)', (t) => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar/override/2',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="index.html"')
-        t.assert.equal(response.headers['accept-ranges'], undefined)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('reply.download() with fileName - override', async (t) => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('reply.download() with rootPath and fileName', (t) => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/root/path/override/test/change',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-disposition'], 'attachment; filename="hello-world.html"')
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="foo.html"')
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('reply.download() with custom opts', async (t) => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/override')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.equal(response.headers.get('cache-control'), 'public, max-age=7200, immutable')
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('reply.download() with custom opts (2)', async (t) => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/override/2')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
+    t.assert.equal(response.headers.get('accept-ranges'), undefined)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('reply.download() with rootPath and fileName', async (t) => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test/change')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
   })
 })
 

From a50045f6ebcb5588a3ed7fb587444e6d7f1a2f5a Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:18:52 +0100
Subject: [PATCH 20/93] chore: sendFile

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 95077851..055ffc8d 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1036,8 +1036,8 @@ test('download', async (t) => {
   })
 })
 
-test('sendFile disabled', (t) => {
-  t.plan(2)
+test('sendFile disabled', async (t) => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1055,23 +1055,17 @@ test('sendFile disabled', (t) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('reply.sendFile undefined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), 'pass')
-      })
-    })
+  await t.test('reply.sendFile undefined', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), 'pass')
   })
 })
 

From c7cd35889cda6f286c4615cf84dcb0bf95800aee Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:19:44 +0100
Subject: [PATCH 21/93] chore: removed duplicated test

---
 test/static.test.js | 33 ---------------------------------
 1 file changed, 33 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 055ffc8d..a0b0ae78 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1036,39 +1036,6 @@ test('download', async (t) => {
   })
 })
 
-test('sendFile disabled', async (t) => {
-  t.plan(1)
-
-  const pluginOptions = {
-    root: path.join(__dirname, '/static'),
-    prefix: '/static',
-    decorateReply: false
-  }
-  const fastify = Fastify()
-  fastify.register(fastifyStatic, pluginOptions)
-
-  fastify.get('/foo/bar', function (req, reply) {
-    if (reply.sendFile === undefined) {
-      reply.send('pass')
-    } else {
-      reply.send('fail')
-    }
-  })
-
-  await fastify.listen({ port: 0 })
-
-  fastify.server.unref()
-
-  await t.test('reply.sendFile undefined', async (t) => {
-    t.plan(3)
-
-    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
-    t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), 'pass')
-  })
-})
-
 test('download disabled', (t) => {
   t.plan(3)
 

From 2dccee5f43932a52248b51abbe4c92cb8051c1e3 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:22:30 +0100
Subject: [PATCH 22/93] chore: download disabled

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index a0b0ae78..b0c3bf0b 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1036,8 +1036,8 @@ test('download', async (t) => {
   })
 })
 
-test('download disabled', (t) => {
-  t.plan(3)
+test('download disabled', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1056,23 +1056,17 @@ test('download disabled', (t) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('reply.sendFile undefined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/foo/bar',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), 'pass')
-      })
-    })
+  await t.test('reply.sendFile undefined', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), 'pass')
   })
 })
 

From 4544b3b8e5ed064a26894a41b5cad9d488dbdbf7 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:23:21 +0100
Subject: [PATCH 23/93] chore: tests

---
 test/static.test.js | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index b0c3bf0b..d0d907df 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1077,8 +1077,8 @@ test('prefix default', (t) => {
   t.assert.doesNotThrow(() => fastify.register(fastifyStatic, pluginOptions))
 })
 
-test('root not found warning', (t) => {
-  t.plan(2)
+test('root not found warning', async (t) => {
+  t.plan(1)
   const rootPath = path.join(__dirname, 'does-not-exist')
   const pluginOptions = { root: rootPath }
   const destination = concat((data) => {
@@ -1092,11 +1092,10 @@ test('root not found warning', (t) => {
   )
   const fastify = Fastify({ loggerInstance })
   fastify.register(fastifyStatic, pluginOptions)
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    fastify.server.unref()
-    destination.end()
-  })
+
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
+  destination.end()
 })
 
 test('send options', (t) => {

From 11eee2968fc38ad6edf064a07c7824e9ed3f319a Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:24:32 +0100
Subject: [PATCH 24/93] chore: send options

---
 test/static.test.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/static.test.js b/test/static.test.js
index d0d907df..581fa411 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1114,6 +1114,7 @@ test('send options', (t) => {
     maxAge: 'maxAge'
   }
   const fastify = Fastify({ logger: false })
+  const { resolve, promise } = Promise.withResolvers()
   const fastifyStatic = require('proxyquire')('../', {
     '@fastify/send': function sendStub (req, pathName, options) {
       t.assert.equal(pathName, '/index.html')
@@ -1128,11 +1129,14 @@ test('send options', (t) => {
       t.assert.equal(options.index, 'index')
       t.assert.equal(options.lastModified, 'lastModified')
       t.assert.equal(options.maxAge, 'maxAge')
+      resolve()
       return { on: () => { }, pipe: () => { } }
     }
   })
   fastify.register(fastifyStatic, pluginOptions)
   fastify.inject({ url: '/index.html' })
+
+  return promise
 })
 
 test('setHeaders option', (t) => {

From e8e5dc83a2cb0e440930fc5042aced9e7e1aba51 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:25:54 +0100
Subject: [PATCH 25/93] chore: setHeaders option

---
 test/static.test.js | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 581fa411..68cd845b 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1139,8 +1139,8 @@ test('send options', (t) => {
   return promise
 })
 
-test('setHeaders option', (t) => {
-  t.plan(6 + GENERIC_RESPONSE_CHECK_COUNT)
+test('setHeaders option', async (t) => {
+  t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
   const pluginOptions = {
     root: path.join(__dirname, 'static'),
@@ -1154,23 +1154,16 @@ test('setHeaders option', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/index.html',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(response.headers['x-test-header'], 'test')
-      t.assert.equal(body.toString(), indexContent)
-      genericResponseChecks(t, response)
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(response.headers.get('x-test-header'), 'test')
+  t.assert.equal(await response.text(), indexContent)
+  genericResponseChecks(t, response)
 })
 
 test('maxAge option', (t) => {

From 41a153a75354889affcce8a5372b186b78d22971 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:28:27 +0100
Subject: [PATCH 26/93] chore: maxAge

---
 test/static.test.js | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 68cd845b..6dbba867 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1166,8 +1166,8 @@ test('setHeaders option', async (t) => {
   genericResponseChecks(t, response)
 })
 
-test('maxAge option', (t) => {
-  t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+test('maxAge option', async (t) => {
+  t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
   const pluginOptions = {
     root: path.join(__dirname, 'static'),
@@ -1178,23 +1178,15 @@ test('maxAge option', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/index.html',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(response.headers['cache-control'], 'public, max-age=3600')
-      t.assert.equal(body.toString(), indexContent)
-      genericResponseChecks(t, response)
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(response.headers.get('cache-control'), 'public, max-age=3600')
+  t.assert.equal(await response.text(), indexContent)
+  genericResponseChecks(t, response)
 })
 
 test('errors', (t) => {

From ae8c5fc123a6a7f6e57aee91776ba01520d42e2d Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:30:49 +0100
Subject: [PATCH 27/93] chore: errors

---
 test/static.test.js | 68 +++++++++++++++------------------------------
 1 file changed, 23 insertions(+), 45 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 6dbba867..1f1b185d 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1189,108 +1189,86 @@ test('maxAge option', async (t) => {
   genericResponseChecks(t, response)
 })
 
-test('errors', (t) => {
+test('errors', async (t) => {
   t.plan(11)
 
-  test('no root', (t) => {
+  await t.test('no root', (t) => {
     t.plan(1)
     const pluginOptions = {}
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root is not a string', (t) => {
+  await t.test('root is not a string', (t) => {
     t.plan(1)
     const pluginOptions = { root: 42 }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root is not an absolute path', (t) => {
+  await t.test('root is not an absolute path', (t) => {
     t.plan(1)
     const pluginOptions = { root: './my/path' }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root is not a directory', (t) => {
+  await t.test('root is not a directory', (t) => {
     t.plan(1)
     const pluginOptions = { root: __filename }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root is an empty array', (t) => {
+  await t.test('root is an empty array', (t) => {
     t.plan(1)
     const pluginOptions = { root: [] }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root array does not contain strings', (t) => {
+  await t.test('root array does not contain strings', (t) => {
     t.plan(1)
     const pluginOptions = { root: [1] }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root array does not contain an absolute path', (t) => {
+  await t.test('root array does not contain an absolute path', (t) => {
     t.plan(1)
     const pluginOptions = { root: ['./my/path'] }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('root array path is not a directory', (t) => {
+  await t.test('root array path is not a directory', (t) => {
     t.plan(1)
     const pluginOptions = { root: [__filename] }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('all root array paths must be valid', (t) => {
+  await t.test('all root array paths must be valid', (t) => {
     t.plan(1)
     const pluginOptions = { root: [path.join(__dirname, '/static'), 1] }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('duplicate root paths are not allowed', (t) => {
+  await t.test('duplicate root paths are not allowed', (t) => {
     t.plan(1)
     const pluginOptions = {
       root: [path.join(__dirname, '/static'), path.join(__dirname, '/static')]
     }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, Error)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 
-  test('setHeaders is not a function', (t) => {
+  await t.test('setHeaders is not a function', (t) => {
     t.plan(1)
     const pluginOptions = { root: __dirname, setHeaders: 'headers' }
     const fastify = Fastify({ logger: false })
-    fastify.register(fastifyStatic, pluginOptions).ready((err) => {
-      t.assert.equal(err.constructor, TypeError)
-    })
+    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
   })
 })
 

From 0059a7cf7730b6adfb58637c3bf271cc6b9a7c6f Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:35:29 +0100
Subject: [PATCH 28/93] chore: register no prefix

---
 test/static.test.js | 149 ++++++++++++++++++--------------------------
 1 file changed, 62 insertions(+), 87 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 1f1b185d..195b00c5 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1272,8 +1272,8 @@ test('errors', async (t) => {
   })
 })
 
-test('register no prefix', (t) => {
-  t.plan(8)
+test('register no prefix', async (t) => {
+  t.plan(7)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -1287,99 +1287,74 @@ test('register no prefix', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+  await t.test('/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/', async (t) => {
+    t.plan(3)
 
-    test('/this/path/doesnt/exist.html', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/this/path/doesnt/exist.html',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
 
-    test('/../index.js', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/this/path/doesnt/exist.html', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/this/path/doesnt/exist.html')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/../index.js', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
   })
 })
 

From e8e0ff70f6f9670bc8842647715f36feedc4a47d Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:40:20 +0100
Subject: [PATCH 29/93] chore: compress

---
 test/static.test.js | 51 +++++++++++++++++++--------------------------
 1 file changed, 21 insertions(+), 30 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 195b00c5..8f4c6d8a 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1358,8 +1358,8 @@ test('register no prefix', async (t) => {
   })
 })
 
-test('with fastify-compress', t => {
-  t.plan(3)
+test('with fastify-compress', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -1370,39 +1370,30 @@ test('with fastify-compress', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    test('deflate', function (t) {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('deflate', async function (t) {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html',
-        headers: {
-          'accept-encoding': ['deflate']
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-encoding'], 'deflate')
-        genericResponseChecks(t, response)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', {
+      headers: {
+        'accept-encoding': ['deflate']
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-encoding'), 'deflate')
+    genericResponseChecks(t, response)
+  })
 
-    test('gzip', function (t) {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('gzip', async function (t) {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(response.headers['content-encoding'], 'gzip')
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-encoding'), 'gzip')
+    genericResponseChecks(t, response)
   })
 })
 test('register /static/ with schemaHide true', t => {

From c6660e9047c85c1541f9152f1f75cd40ab6d4e11 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:41:43 +0100
Subject: [PATCH 30/93] chore: register static schema hide

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 8f4c6d8a..82b40fe2 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1396,8 +1396,8 @@ test('with fastify-compress', async t => {
     genericResponseChecks(t, response)
   })
 })
-test('register /static/ with schemaHide true', t => {
-  t.plan(3)
+test('register /static/ with schemaHide true', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1415,24 +1415,18 @@ test('register /static/ with schemaHide true', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    genericResponseChecks(t, response)
   })
 })
 

From 98bc63663352c54decfb09b23e43f6d97f57a911 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:42:49 +0100
Subject: [PATCH 31/93] chore: register static schema hide

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 82b40fe2..916c9d55 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1430,8 +1430,8 @@ test('register /static/ with schemaHide true', async t => {
   })
 })
 
-test('register /static/ with schemaHide false', t => {
-  t.plan(3)
+test('register /static/ with schemaHide false', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1449,24 +1449,18 @@ test('register /static/ with schemaHide false', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    genericResponseChecks(t, response)
   })
 })
 

From 9a782e3ec60eac52bbca9a30cf56a570fad9ba49 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:43:52 +0100
Subject: [PATCH 32/93] chore: register static without schema hide

---
 test/static.test.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 916c9d55..a53ae5c5 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1464,8 +1464,8 @@ test('register /static/ with schemaHide false', async t => {
   })
 })
 
-test('register /static/ without schemaHide', t => {
-  t.plan(3)
+test('register /static/ without schemaHide', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1482,24 +1482,18 @@ test('register /static/ without schemaHide', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    genericResponseChecks(t, response)
   })
 })
 

From 8045459a3e732fcbbe6750e7ad550970de1629a3 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:50:56 +0100
Subject: [PATCH 33/93] chore: exposeHeadRoutes

---
 test/static.test.js | 29 ++++++++++++-----------------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index a53ae5c5..3fcca0af 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1497,8 +1497,8 @@ test('register /static/ without schemaHide', async t => {
   })
 })
 
-test('fastify with exposeHeadRoutes', t => {
-  t.plan(2)
+test('fastify with exposeHeadRoutes', async t => {
+  t.plan(1)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1509,23 +1509,18 @@ test('fastify with exposeHeadRoutes', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/index.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
   })
 })
 

From e195a5bad7a39819a8f28d497892a5fe7a14a661 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:55:06 +0100
Subject: [PATCH 34/93] chore: wildcard false

---
 test/static.test.js | 171 +++++++++++++++++++-------------------------
 1 file changed, 72 insertions(+), 99 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 3fcca0af..8cbe0698 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1524,8 +1524,8 @@ test('fastify with exposeHeadRoutes', async t => {
   })
 })
 
-test('register with wildcard false', t => {
-  t.plan(9)
+test('register with wildcard false', async t => {
+  t.plan(8)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1540,112 +1540,85 @@ test('register with wildcard false', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/index.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/not-defined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/../index.js', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+  await t.test('/not-defined', async (t) => {
+    t.plan(3)
 
-    test('/index.css', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/not-defined')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
+
+  await t.test('/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/../index.js', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
+
+  await t.test('/index.css', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
   })
 })
 

From fc2cb360b0bdefc897bc29eb78b5d93a9680e41e Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 20:59:33 +0100
Subject: [PATCH 35/93] chore: wildcard + trailing slash

---
 test/static.test.js | 108 ++++++++++++++++++--------------------------
 1 file changed, 45 insertions(+), 63 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 8cbe0698..83ad63f6 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1622,8 +1622,8 @@ test('register with wildcard false', async t => {
   })
 })
 
-test('register with wildcard false (trailing slash in the root)', t => {
-  t.plan(6)
+test('register with wildcard false (trailing slash in the root)', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static/'),
@@ -1642,73 +1642,55 @@ test('register with wildcard false (trailing slash in the root)', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/not-defined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/assets/not-defined'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/deep/path/for/test/purpose/foo.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/not-defined', async (t) => {
+    t.plan(3)
 
-    test('/../index.js', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/assets/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/not-defined')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
 
-    test('/index.css', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/deep/path/for/test/purpose/foo.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/../index.js', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/../index.js')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
+
+  await t.test('/index.css', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
   })
 })
 

From a03f0ea9e912d375ec0f673b5e58262f290faa62 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 21:06:38 +0100
Subject: [PATCH 36/93] chore: deps

---
 test/static.test.js | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 83ad63f6..36c65d88 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1694,7 +1694,7 @@ test('register with wildcard false (trailing slash in the root)', async t => {
   })
 })
 
-test('register with wildcard string', (t) => {
+test('register with wildcard string', async (t) => {
   t.plan(1)
 
   const pluginOptions = {
@@ -1708,12 +1708,10 @@ test('register with wildcard string', (t) => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.ready(function (err) {
-    t.assert.ok(err)
-  })
+  await t.assert.rejects(fastify.ready())
 })
 
-test('register with wildcard string on multiple root paths', (t) => {
+test('register with wildcard string on multiple root paths', async (t) => {
   t.plan(1)
 
   const pluginOptions = {
@@ -1729,11 +1727,7 @@ test('register with wildcard string on multiple root paths', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ok(err)
-
-    fastify.server.unref()
-  })
+  await t.assert.rejects(fastify.listen({ port: 0 }))
 })
 
 test('register with wildcard false and alternative index', t => {

From 35072dd31c48d985f69498dc5132baac2fb987a3 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 3 Jan 2025 21:12:19 +0100
Subject: [PATCH 37/93] chore: register with wildcard

---
 test/static.test.js | 213 +++++++++++++++++++-------------------------
 1 file changed, 92 insertions(+), 121 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 36c65d88..4c572f1e 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1730,8 +1730,8 @@ test('register with wildcard string on multiple root paths', async (t) => {
   await t.assert.rejects(fastify.listen({ port: 0 }))
 })
 
-test('register with wildcard false and alternative index', t => {
-  t.plan(11)
+test('register with wildcard false and alternative index', async t => {
+  t.plan(10)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1747,138 +1747,109 @@ test('register with wildcard false and alternative index', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/index.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/?a=b', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), foobarContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
 
-    test('/?a=b', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/not-defined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/not-defined'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/deep/path/for/test/purpose/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/?a=b', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), foobarContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/deep/path/for/test/', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
+  await t.test('/?a=b', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port, {
+      method: 'HEAD'
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
 
-    test('/../index.js', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+  await t.test('/not-defined', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/not-defined')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
+
+  await t.test('/deep/path/for/test/purpose/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/deep/path/for/test/', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/', {
+      method: 'HEAD'
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/../index.js', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 })
 

From 8e053f18df5dbf634ac2bb8e433ef81e008ad131 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 12:33:43 +0100
Subject: [PATCH 38/93] chore: static with wildcard alternative index

---
 test/static.test.js | 229 ++++++++++++++++++++------------------------
 1 file changed, 104 insertions(+), 125 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 4c572f1e..f213b0ab 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1853,8 +1853,8 @@ test('register with wildcard false and alternative index', async t => {
   })
 })
 
-test('register /static with wildcard false and alternative index', t => {
-  t.plan(11)
+test('register /static with wildcard false and alternative index', async t => {
+  t.plan(10)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1871,145 +1871,124 @@ test('register /static with wildcard false and alternative index', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/index.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/index.css', (t) => {
-      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.css'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        genericResponseChecks(t, response)
-      })
+  await t.test('/static/index.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
+      method: 'HEAD'
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
 
-    test('/static', (t) => {
-      t.plan(2)
+  await t.test('/static/index.css', async (t) => {
+    t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      // to verify we do not get a redirect when not requested
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 200)
-        let body = ''
-        res.on('data', (chunk) => {
-          body += chunk.toString()
-        })
-        res.on('end', () => {
-          t.assert.deepStrictEqual(JSON.parse(body.toString()), { hello: 'world' })
-        })
-      })
-      req.on('error', (err) => console.error(err))
-      req.end()
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), foobarContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static', (t) => {
+    t.plan(2)
 
-    test('/static/', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+    const { promise, resolve } = Promise.withResolvers()
 
-    test('/static/not-defined', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/not-defined'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+    // simple-get doesn't tell us about redirects so use http.request directly
+    // to verify we do not get a redirect when not requested
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 200)
+      let body = ''
+      res.on('data', (chunk) => {
+        body += chunk.toString()
       })
-    })
-
-    test('/static/deep/path/for/test/purpose/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), deepContent)
-        genericResponseChecks(t, response)
+      res.on('end', () => {
+        t.assert.deepStrictEqual(JSON.parse(body.toString()), { hello: 'world' })
+        resolve()
       })
     })
+    req.on('error', (err) => console.error(err))
+    req.end()
 
-    test('/static/deep/path/for/test/', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    return promise
+  })
 
-    test('/static/../index.js', (t) => {
-      t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/../index.js',
-        followRedirect: false
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+  await t.test('/static/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), foobarContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/', {
+      method: 'HEAD'
     })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/not-defined', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/not-defined')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+  })
+
+  await t.test('/static/deep/path/for/test/purpose/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), deepContent)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test/', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/../index.js', async (t) => {
+    t.plan(3)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 })
 

From c1f0ae72aec370a0b2b92b896b8d2c69a95d5d3e Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 12:45:17 +0100
Subject: [PATCH 39/93] chore: static with redirect

---
 test/static.test.js | 172 +++++++++++++++++++++-----------------------
 1 file changed, 83 insertions(+), 89 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index f213b0ab..16d4879e 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1992,8 +1992,8 @@ test('register /static with wildcard false and alternative index', async t => {
   })
 })
 
-test('register /static with redirect true', t => {
-  t.plan(7)
+test('register /static with redirect true', async t => {
+  t.plan(6)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2008,111 +2008,105 @@ test('register /static with redirect true', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static?a=b', (t) => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static?a=b', async (t) => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 301)
-        t.assert.equal(res.headers.location, '/static/?a=b')
-      })
-      req.on('error', (err) => console.error(err))
-      req.end()
+    const { promise, resolve } = Promise.withResolvers()
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
+    // simple-get doesn't tell us about redirects so use http.request directly
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 301)
+      t.assert.equal(res.headers.location, '/static/?a=b')
+      resolve()
     })
+    req.on('error', (err) => console.error(err))
+    req.end()
 
-    test('/static', t => {
-      t.plan(2)
+    await promise
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 301)
-        t.assert.equal(res.headers.location, '/static/')
-      })
-      req.on('error', err => console.error(err))
-      req.end()
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static?a=b')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static', t => {
+    t.plan(2)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const { promise, resolve } = Promise.withResolvers()
 
-    test('/static/deep', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+    // simple-get doesn't tell us about redirects so use http.request directly
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 301)
+      t.assert.equal(res.headers.location, '/static/')
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
+      resolve()
     })
+    req.on('error', err => console.error(err))
+    req.end()
 
-    test('/static/deep/path/for/test?a=b', (t) => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+    return promise
+  })
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 301)
-        t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
-      })
-      req.on('error', (err) => console.error(err))
-      req.end()
+  await t.test('/static/', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      // verify the redirect with query parameters works
-      simple.concat({
-        method: 'GET',
-        url: testurl
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/deep/path/for/test', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static/deep', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test?a=b', async (t) => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const { promise, resolve } = Promise.withResolvers()
+
+    // simple-get doesn't tell us about redirects so use http.request directly
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 301)
+      t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+      resolve()
     })
+    req.on('error', (err) => console.error(err))
+    req.end()
+
+    await promise
+
+    // verify the redirect with query parameters works
+    const response = await fetch(testurl)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
+
+  await t.test('/static/deep/path/for/test', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
   })
 })
 

From 3b82e1e8c8886d70229d134567480e372b3fde93 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:03:25 +0100
Subject: [PATCH 40/93] feat: static with redirect and not wildcard

---
 test/static.test.js | 183 +++++++++++++++++++-------------------------
 1 file changed, 80 insertions(+), 103 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 16d4879e..39a85cb6 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2110,8 +2110,8 @@ test('register /static with redirect true', async t => {
   })
 })
 
-test('register /static with redirect true and wildcard false', t => {
-  t.plan(8)
+test('register /static with redirect true and wildcard false', async t => {
+  t.plan(7)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2127,126 +2127,103 @@ test('register /static with redirect true and wildcard false', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    fastify.server.unref()
+  fastify.server.unref()
 
-    test('/static?a=b', t => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+  await t.test('/static?a=b', async t => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 301)
-        t.assert.equal(res.headers.location, '/static/?a=b')
-      })
-      req.on('error', err => console.error(err))
-      req.end()
+    const { promise, resolve } = Promise.withResolvers()
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static?a=b'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
+    // simple-get doesn't tell us about redirects so use http.request directly
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 301)
+      t.assert.equal(res.headers.location, '/static/?a=b')
+      resolve()
     })
+    req.on('error', err => console.error(err))
+    req.end()
+    await promise
 
-    test('/static/?a=b', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static?a=b')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/?a=b', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/?a=b', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/?a=b')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/?a=b'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/?a=b - HEAD', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep', t => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/?a=b', { method: 'HEAD' })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
+  })
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/deep', async t => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep/path/for/test?a=b', t => {
-      t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
+  })
 
-      // simple-get doesn't tell us about redirects so use http.request directly
-      const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
-      const req = http.request(url.parse(testurl), res => {
-        t.assert.equal(res.statusCode, 301)
-        t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
-      })
-      req.on('error', err => console.error(err))
-      req.end()
+  await t.test('/static/deep/path/for/test?a=b', async t => {
+    t.plan(5 + GENERIC_RESPONSE_CHECK_COUNT)
 
-      // verify the redirect with query parameters works
-      simple.concat({
-        method: 'GET',
-        url: testurl
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
+    const { promise, resolve } = Promise.withResolvers()
+
+    // simple-get doesn't tell us about redirects so use http.request directly
+    const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
+    const req = http.request(url.parse(testurl), res => {
+      t.assert.equal(res.statusCode, 301)
+      t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+      resolve()
     })
+    req.on('error', err => console.error(err))
+    req.end()
+    await promise
 
-    test('/static/deep/path/for/test', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch(testurl)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), innerIndex)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/deep/path/for/test', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/deep/path/for/test', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), innerIndex)
+    genericResponseChecks(t, response)
+  })
 
-      simple.concat({
-        method: 'HEAD',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '')
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/deep/path/for/test', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test', { method: 'HEAD' })
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), '')
+    genericResponseChecks(t, response)
   })
 })
 

From fb3f99ccb2dc244334cfcbceefdbf1b2ac48c18a Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:05:42 +0100
Subject: [PATCH 41/93] chore: trailing slash behaviour

---
 test/static.test.js | 95 +++++++++++++++++++--------------------------
 1 file changed, 40 insertions(+), 55 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 39a85cb6..7b51e8ad 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2227,8 +2227,8 @@ test('register /static with redirect true and wildcard false', async t => {
   })
 })
 
-test('trailing slash behavior with redirect = false', (t) => {
-  t.plan(6)
+test('trailing slash behavior with redirect = false', async (t) => {
+  t.plan(5)
 
   const fastify = Fastify()
   fastify.register(fastifyStatic, {
@@ -2240,65 +2240,50 @@ test('trailing slash behavior with redirect = false', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    const host = 'http://localhost:' + fastify.server.address().port
+  fastify.server.unref()
 
-    test('prefix with no trailing slash => 404', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: host + '/static'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+  const host = 'http://localhost:' + fastify.server.address().port
 
-    test('prefix with trailing trailing slash => 200', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: host + '/static/'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-      })
-    })
+  await t.test('prefix with no trailing slash => 404', async (t) => {
+    t.plan(2)
 
-    test('deep path with no index.html or trailing slash => 404', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: host + '/static/deep/path'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+    const response = await fetch(host + '/static')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
 
-    test('deep path with index.html but no trailing slash => 200', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: host + '/static/deep/path/for/test'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-      })
-    })
+  await t.test('prefix with trailing trailing slash => 200', async (t) => {
+    t.plan(2)
 
-    test('deep path with index.html and trailing slash => 200', (t) => {
-      t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: host + '/static/deep/path/for/test/'
-      }, (err, response) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-      })
-    })
+    const response = await fetch(host + '/static/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+  })
+
+  await t.test('deep path with no index.html or trailing slash => 404', async (t) => {
+    t.plan(2)
+
+    const response = await fetch(host + '/static/deep/path')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+  })
+
+  await t.test('deep path with index.html but no trailing slash => 200', async (t) => {
+    t.plan(2)
+
+    const response = await fetch(host + '/static/deep/path/for/test')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+  })
+
+  await t.test('deep path with index.html and trailing slash => 200', async (t) => {
+    t.plan(2)
+
+    const response = await fetch(host + '/static/deep/path/for/test/')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
   })
 })
 

From 340893cd4a9b496d8562fcab9f8069f8c8d759dc Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:13:41 +0100
Subject: [PATCH 42/93] chore: dotfiles

---
 test/static.test.js | 62 ++++++++++++++++++---------------------------
 1 file changed, 24 insertions(+), 38 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 7b51e8ad..53eb3116 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2287,7 +2287,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
   })
 })
 
-test('if dotfiles are properly served according to plugin options', (t) => {
+test('if dotfiles are properly served according to plugin options', async (t) => {
   t.plan(3)
   const exampleContents = fs
     .readFileSync(path.join(__dirname, 'static', '.example'), {
@@ -2295,8 +2295,8 @@ test('if dotfiles are properly served according to plugin options', (t) => {
     })
     .toString()
 
-  test('freely serve dotfiles', (t) => {
-    t.plan(4)
+  await t.test('freely serve dotfiles', async (t) => {
+    t.plan(3)
     const fastify = Fastify()
 
     const pluginOptions = {
@@ -2308,22 +2308,18 @@ test('if dotfiles are properly served according to plugin options', (t) => {
     fastify.register(fastifyStatic, pluginOptions)
 
     t.after(() => fastify.close())
-    fastify.listen({ port: 0 }, (err) => {
-      t.assert.ifError(err)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), exampleContents)
-      })
-    })
+    await fastify.listen({ port: 0 })
+    fastify.server.unref()
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), exampleContents)
   })
 
-  test('ignore dotfiles', (t) => {
-    t.plan(3)
+  await t.test('ignore dotfiles', async (t) => {
+    t.plan(2)
     const fastify = Fastify()
 
     const pluginOptions = {
@@ -2335,21 +2331,17 @@ test('if dotfiles are properly served according to plugin options', (t) => {
     fastify.register(fastifyStatic, pluginOptions)
 
     t.after(() => fastify.close())
-    fastify.listen({ port: 0 }, (err) => {
-      t.assert.ifError(err)
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
-    })
+    await fastify.listen({ port: 0 })
+    fastify.server.unref()
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
   })
 
-  test('deny requests to serve a dotfile', (t) => {
-    t.plan(3)
+  await t.test('deny requests to serve a dotfile', async (t) => {
+    t.plan(2)
     const fastify = Fastify()
 
     const pluginOptions = {
@@ -2361,17 +2353,11 @@ test('if dotfiles are properly served according to plugin options', (t) => {
     fastify.register(fastifyStatic, pluginOptions)
 
     t.after(() => fastify.close())
-    fastify.listen({ port: 0 }, (err) => {
-      t.assert.ifError(err)
+    await fastify.listen({ port: 0 })
 
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/.example'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 403)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 403)
   })
 })
 

From 4fdce1d1dd9fdd917d667b337f14cd6a870b7deb Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:15:27 +0100
Subject: [PATCH 43/93] chore: fail glob

---
 test/static.test.js | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 53eb3116..6d7fd807 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2361,7 +2361,7 @@ test('if dotfiles are properly served according to plugin options', async (t) =>
   })
 })
 
-test('register with failing glob handler', (t) => {
+test('register with failing glob handler', async (t) => {
   const fastifyStatic = proxyquire.noCallThru()('../', {
     glob: function globStub (pattern, options, cb) {
       process.nextTick(function () {
@@ -2380,10 +2380,7 @@ test('register with failing glob handler', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    fastify.server.unref()
-    t.assert.ok(err)
-  })
+  await t.assert.rejects(fastify.listen({ port: 0 }))
 })
 
 test(

From d25a37ab0683d9bbf051bc4a6f280420df1b8625 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:15:54 +0100
Subject: [PATCH 44/93] chore: enoent

---
 test/static.test.js | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 6d7fd807..c057bdc7 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2385,7 +2385,7 @@ test('register with failing glob handler', async (t) => {
 
 test(
   'register with rootpath that causes statSync to fail with non-ENOENT code',
-  (t) => {
+  async (t) => {
     const fastifyStatic = proxyquire('../', {
       'node:fs': {
         statSync: function statSyncStub (path) {
@@ -2402,10 +2402,8 @@ test(
     fastify.register(fastifyStatic, pluginOptions)
 
     t.after(() => fastify.close())
-    fastify.listen({ port: 0 }, (err) => {
-      fastify.server.unref()
-      t.assert.ok(err)
-    })
+
+    await t.assert.rejects(fastify.listen({ port: 0 }))
   }
 )
 

From c47b1849b7342b37e65ff35e76735fc0fe98a8a6 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:19:34 +0100
Subject: [PATCH 45/93] chore: premature stream close

---
 test/static.test.js | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index c057bdc7..e32f046f 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2424,8 +2424,8 @@ test('inject support', async (t) => {
   t.assert.equal(response.body.toString(), indexContent)
 })
 
-test('routes should use custom errorHandler premature stream close', t => {
-  t.plan(3)
+test('routes should use custom errorHandler premature stream close', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2447,16 +2447,7 @@ test('routes should use custom errorHandler premature stream close', t => {
   fastify.register(fastifyStatic, pluginOptions)
   t.after(() => fastify.close())
 
-  fastify.inject(
-    {
-      method: 'GET',
-      url: '/static/index.html'
-    },
-    (err, response) => {
-      t.assert.ifError(err)
-      t.assert.equal(response, null)
-    }
-  )
+  await t.assert.rejects(fastify.inject({ method: 'GET', url: '/static/index.html' }))
 })
 
 test('routes should fallback to default errorHandler', t => {

From 0df6a0d9673401a66e8a305eacc749a85a814189 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:22:08 +0100
Subject: [PATCH 46/93] chore: .br

---
 test/static.test.js | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index e32f046f..4da6cbcd 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2450,7 +2450,7 @@ test('routes should use custom errorHandler premature stream close', async t =>
   await t.assert.rejects(fastify.inject({ method: 'GET', url: '/static/index.html' }))
 })
 
-test('routes should fallback to default errorHandler', t => {
+test('routes should fallback to default errorHandler', async t => {
   t.plan(3)
 
   const pluginOptions = {
@@ -2473,17 +2473,13 @@ test('routes should fallback to default errorHandler', t => {
   fastify.register(fastifyStatic, pluginOptions)
   t.after(() => fastify.close())
 
-  fastify.inject({
-    method: 'GET',
-    url: '/static/index.html'
-  }, (err, response) => {
-    t.assert.ifError(err)
-    t.assert.deepStrictEqual(JSON.parse(response.payload), {
-      statusCode: 500,
-      code: 'SOMETHING_ELSE',
-      error: 'Internal Server Error',
-      message: ''
-    })
+  const response = await fastify.inject({ method: 'GET', url: '/static/index.html' })
+  t.assert.equal(response.statusCode, 500)
+  t.assert.deepStrictEqual(await response.json(), {
+    statusCode: 500,
+    code: 'SOMETHING_ELSE',
+    error: 'Internal Server Error',
+    message: ''
   })
 })
 

From d0bd3484b11b70d83b90dcec2eb215993731f489 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:24:18 +0100
Subject: [PATCH 47/93] chore: percent encoded

---
 test/static.test.js | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 4da6cbcd..61b816b4 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2483,8 +2483,8 @@ test('routes should fallback to default errorHandler', async t => {
   })
 })
 
-test('percent encoded URLs in glob mode', (t) => {
-  t.plan(4)
+test('percent encoded URLs in glob mode', async (t) => {
+  t.plan(3)
 
   const fastify = Fastify({})
 
@@ -2496,23 +2496,16 @@ test('percent encoded URLs in glob mode', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/static/a .md',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(
-        fs.readFileSync(path.join(__dirname, 'static', 'a .md'), 'utf-8'),
-        body.toString()
-      )
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/a .md')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(
+    fs.readFileSync(path.join(__dirname, 'static', 'a .md'), 'utf-8'),
+    await response.text()
+  )
 })
 
 test('register /static and /static2 without wildcard', t => {
@@ -2584,7 +2577,7 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
+    t.assert.equal(response.headers.get('content-encoding'), 'br')
     t.assert.equal(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
@@ -2613,7 +2606,7 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
+    t.assert.equal(response.headers.get('content-encoding'), 'gzip')
     t.assert.equal(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }

From df4dc1276366e074fbabba3637f33a3d3d7e2f24 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:26:08 +0100
Subject: [PATCH 48/93] chore: static and static2 wildcard

---
 test/static.test.js | 52 +++++++++++++++++++--------------------------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 61b816b4..e43d7321 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2508,8 +2508,8 @@ test('percent encoded URLs in glob mode', async (t) => {
   )
 })
 
-test('register /static and /static2 without wildcard', t => {
-  t.plan(3)
+test('register /static and /static2 without wildcard', async t => {
+  t.plan(2)
 
   const pluginOptions = {
     root: [path.join(__dirname, '/static'), path.join(__dirname, '/static2')],
@@ -2520,37 +2520,29 @@ test('register /static and /static2 without wildcard', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    fastify.server.unref()
+  await t.test('/index.html', async t => {
+    t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/index.html', t => {
-      t.plan(4 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.not(body.toString(), index2Content)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    const responseContent = await response.text()
+    t.assert.notEqual(responseContent, index2Content)
+    t.assert.equal(responseContent, indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static/bar.html', t => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/bar.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), barContent)
-        genericResponseChecks(t, response)
-      })
-    })
+  await t.test('/static/bar.html', async t => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/bar.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), barContent)
+    genericResponseChecks(t, response)
   })
 })
 

From 8b233af5d62a3d8786a840998da20aa8065c0603 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:29:33 +0100
Subject: [PATCH 49/93] chore: headers get

---
 test/static.test.js | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index e43d7321..7a427bbd 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -58,11 +58,11 @@ const jsonHiddenContent = fs.readFileSync('./test/static-hidden/.hidden/sample.j
 
 const GENERIC_RESPONSE_CHECK_COUNT = 5
 function genericResponseChecks (t, response) {
-  t.assert.ok(/text\/(html|css)/.test(response.headers.get('content-type')))
-  t.assert.ok(response.headers.get('etag'))
-  t.assert.ok(response.headers.get('last-modified'))
-  t.assert.ok(response.headers.get('date'))
-  t.assert.ok(response.headers.get('cache-control'))
+  t.assert.ok(/text\/(html|css)/.test(response.headers.get?.('content-type') ?? response.headers['content-type']))
+  t.assert.ok(response.headers.get?.('etag') ?? response.headers.etag)
+  t.assert.ok(response.headers.get?.('last-modified') ?? response.headers['last-modified'])
+  t.assert.ok(response.headers.get?.('date') ?? response.headers.date)
+  t.assert.ok(response.headers.get?.('cache-control') ?? response.headers['cache-control'])
 }
 
 const GENERIC_ERROR_RESPONSE_CHECK_COUNT = 2
@@ -2569,7 +2569,7 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers.get('content-encoding'), 'br')
+    t.assert.equal(response.headers['content-encoding'], 'br')
     t.assert.equal(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
@@ -2598,7 +2598,7 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers.get('content-encoding'), 'gzip')
+    t.assert.equal(response.headers['content-encoding'], 'gzip')
     t.assert.equal(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }

From 31709cacd0f97acb6a0b176d2f985c01d0d55d3c Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:31:23 +0100
Subject: [PATCH 50/93] chore: erorr headers get

---
 test/static.test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 7a427bbd..1755c03e 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -67,8 +67,8 @@ function genericResponseChecks (t, response) {
 
 const GENERIC_ERROR_RESPONSE_CHECK_COUNT = 2
 function genericErrorResponseChecks (t, response) {
-  t.assert.equal(response.headers.get('content-type'), 'application/json; charset=utf-8')
-  t.assert.ok(response.headers.get('date'))
+  t.assert.equal(response.headers.get?.('content-type') ?? response.headers['content-type'], 'application/json; charset=utf-8')
+  t.assert.ok(response.headers.get?.('date') ?? response.headers.date)
 }
 
 test('register /static prefixAvoidTrailingSlash', async t => {

From 08a7d7a88dc956a8c4a45ddece5744d7b23e487c Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:46:43 +0100
Subject: [PATCH 51/93] chore: redirect

---
 test/static.test.js | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 1755c03e..406192e0 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3039,7 +3039,7 @@ test(
   }
 )
 
-test('should not redirect to protocol-relative locations', (t) => {
+test('should not redirect to protocol-relative locations', async (t) => {
   const urls = [
     ['//^/..', '/', 301],
     ['//^/.', null, 404], // it is NOT recognized as a directory by pillarjs/send
@@ -3053,29 +3053,37 @@ test('should not redirect to protocol-relative locations', (t) => {
     ['///deep/path//for//test//index.html', null, 200]
   ]
 
-  t.plan(1 + urls.length * 2)
+  t.plan(urls.length * 2)
   const fastify = Fastify()
   fastify.register(fastifyStatic, {
     root: path.join(__dirname, '/static'),
     redirect: true
   })
   t.after(() => fastify.close())
-  fastify.listen({ port: 0 }, (err, address) => {
-    t.assert.ifError(err)
-    urls.forEach(([testUrl, expected, status]) => {
-      const req = http.request(url.parse(address + testUrl), res => {
-        t.assert.equal(res.statusCode, status, `status ${testUrl}`)
-
-        if (expected) {
-          t.assert.equal(res.headers.location, expected)
-        } else {
-          t.notOk(res.headers.location)
-        }
-      })
-      req.on('error', t.error)
-      req.end()
+
+  const address = await fastify.listen({ port: 0 })
+  fastify.server.unref()
+
+  const promises = urls.map(([testUrl, expected, status]) => {
+    const { promise, resolve } = Promise.withResolvers()
+
+    const req = http.request(url.parse(address + testUrl), res => {
+      t.assert.equal(res.statusCode, status, `status ${testUrl}`)
+
+      if (expected) {
+        t.assert.equal(res.headers.location, expected)
+      } else {
+        t.assert.ok(!res.headers.location)
+      }
+
+      resolve()
     })
+    req.on('error', t.assert.fail)
+    req.end()
+    return promise
   })
+
+  await Promise.all(promises)
 })
 
 test('should not serve index if option is `false`', (t) => {

From 8ec06f51774c7746200cd860cb7d4c7d70efa15e Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:48:24 +0100
Subject: [PATCH 52/93] chore: serve index false

---
 test/static.test.js | 47 ++++++++++++++++++---------------------------
 1 file changed, 19 insertions(+), 28 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 406192e0..1b676440 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3086,8 +3086,8 @@ test('should not redirect to protocol-relative locations', async (t) => {
   await Promise.all(promises)
 })
 
-test('should not serve index if option is `false`', (t) => {
-  t.plan(3)
+test('should not serve index if option is `false`', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -3099,35 +3099,26 @@ test('should not serve index if option is `false`', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    fastify.server.unref()
+  await t.test('/static/index.html', async (t) => {
+    t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
 
-    test('/static/index.html', (t) => {
-      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static/index.html'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), indexContent)
-        genericResponseChecks(t, response)
-      })
-    })
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), indexContent)
+    genericResponseChecks(t, response)
+  })
 
-    test('/static', (t) => {
-      t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
-      simple.concat({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port + '/static'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-        genericErrorResponseChecks(t, response)
-      })
-    })
+  await t.test('/static', async (t) => {
+    t.plan(2 + GENERIC_ERROR_RESPONSE_CHECK_COUNT)
+
+    const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
+    t.assert.ok(!response.ok)
+    t.assert.equal(response.status, 404)
+    genericErrorResponseChecks(t, response)
   })
 })
 

From 7d1a483e7f08714627e6a2339df7e2f04fda12b5 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 13:49:30 +0100
Subject: [PATCH 53/93] chore: symbolik link

---
 test/static.test.js | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 1b676440..e4ade59a 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3122,33 +3122,25 @@ test('should not serve index if option is `false`', async (t) => {
   })
 })
 
-test('should follow symbolic link without wildcard', (t) => {
-  t.plan(5)
+test('should follow symbolic link without wildcard', async (t) => {
+  t.plan(4)
   const fastify = Fastify()
   fastify.register(fastifyStatic, {
     root: path.join(__dirname, '/static-symbolic-link'),
     wildcard: false
   })
   t.after(() => fastify.close())
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/origin/subdir/subdir/index.html'
-    }, (err, response) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-    })
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/dir/symlink/subdir/subdir/index.html'
-    }, (err, response) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/origin/subdir/subdir/index.html')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+
+  const response2 = await fetch('http://localhost:' + fastify.server.address().port + '/dir/symlink/subdir/subdir/index.html')
+  t.assert.ok(response2.ok)
+  t.assert.equal(response2.status, 200)
 })
 
 test('should serve files into hidden dir with wildcard `false`', (t) => {

From 7363f6f73cc3d04ba39a4c9c00ffbf01253e7e27 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:05:06 +0100
Subject: [PATCH 54/93] chore: serve hidden dir with false wildcard

---
 test/static.test.js | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index e4ade59a..c17bcdbc 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3143,8 +3143,8 @@ test('should follow symbolic link without wildcard', async (t) => {
   t.assert.equal(response2.status, 200)
 })
 
-test('should serve files into hidden dir with wildcard `false`', (t) => {
-  t.plan(9)
+test('should serve files into hidden dir with wildcard `false`', async (t) => {
+  t.plan(8)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static-hidden'),
@@ -3156,25 +3156,18 @@ test('should serve files into hidden dir with wildcard `false`', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), jsonHiddenContent)
-      t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
-      t.assert.ok(response.headers.etag)
-      t.assert.ok(response.headers['last-modified'])
-      t.assert.ok(response.headers.date)
-      t.assert.ok(response.headers['cache-control'])
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(await response.text(), jsonHiddenContent)
+  t.assert.ok(/application\/(json)/.test(response.headers.get('content-type')))
+  t.assert.ok(response.headers.get('etag'))
+  t.assert.ok(response.headers.get('last-modified'))
+  t.assert.ok(response.headers.get('date'))
+  t.assert.ok(response.headers.get('cache-control'))
 })
 
 test('should not found hidden file with wildcard is `false`', (t) => {

From fb00a028992bf3573d6ea04c5abf5ddbba19f6d5 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:05:58 +0100
Subject: [PATCH 55/93] chore: not found hidden

---
 test/static.test.js | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index c17bcdbc..ff145892 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3170,8 +3170,8 @@ test('should serve files into hidden dir with wildcard `false`', async (t) => {
   t.assert.ok(response.headers.get('cache-control'))
 })
 
-test('should not found hidden file with wildcard is `false`', (t) => {
-  t.plan(3)
+test('should not found hidden file with wildcard is `false`', async (t) => {
+  t.plan(2)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static-hidden'),
@@ -3181,20 +3181,12 @@ test('should not found hidden file with wildcard is `false`', (t) => {
   fastify.register(fastifyStatic, pluginOptions)
 
   t.after(() => fastify.close())
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
-
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 404)
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
+  t.assert.ok(!response.ok)
+  t.assert.equal(response.status, 404)
 })
 
 test('should serve files into hidden dir without wildcard option', (t) => {

From 0c06baf948a5ecfa5188350866f52fc7c56afc15 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:06:50 +0100
Subject: [PATCH 56/93] chore: wildcard

---
 test/static.test.js | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index ff145892..b91cb651 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3189,8 +3189,8 @@ test('should not found hidden file with wildcard is `false`', async (t) => {
   t.assert.equal(response.status, 404)
 })
 
-test('should serve files into hidden dir without wildcard option', (t) => {
-  t.plan(9)
+test('should serve files into hidden dir without wildcard option', async (t) => {
+  t.plan(8)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static-hidden')
@@ -3200,25 +3200,18 @@ test('should serve files into hidden dir without wildcard option', (t) => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/.hidden/sample.json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), jsonHiddenContent)
-      t.assert.ok(/application\/(json)/.test(response.headers['content-type']))
-      t.assert.ok(response.headers.etag)
-      t.assert.ok(response.headers['last-modified'])
-      t.assert.ok(response.headers.date)
-      t.assert.ok(response.headers['cache-control'])
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(await response.text(), jsonHiddenContent)
+  t.assert.ok(/application\/(json)/.test(response.headers.get('content-type')))
+  t.assert.ok(response.headers.get('etag'))
+  t.assert.ok(response.headers.get('last-modified'))
+  t.assert.ok(response.headers.get('date'))
+  t.assert.ok(response.headers.get('cache-control'))
 })
 
 test(

From 1ee373cab26f1403b8db8eda047254cf12cd7078 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:08:35 +0100
Subject: [PATCH 57/93] chore: content length

---
 test/static.test.js | 32 ++++++++++++--------------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index b91cb651..a8492f30 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3380,8 +3380,8 @@ test(
   }
 )
 
-test('content-length in head route should not return zero when using wildcard', t => {
-  t.plan(6)
+test('content-length in head route should not return zero when using wildcard', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -3392,26 +3392,18 @@ test('content-length in head route should not return zero when using wildcard',
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    const file = fs.readFileSync(path.join(__dirname, '/static/index.html'))
-    const contentLength = Buffer.byteLength(file).toString()
+  const file = fs.readFileSync(path.join(__dirname, '/static/index.html'))
+  const contentLength = Buffer.byteLength(file).toString()
 
-    simple.concat({
-      method: 'HEAD',
-      url: 'http://localhost:' + fastify.server.address().port + '/index.html',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-      t.assert.equal(response.headers['content-length'], contentLength)
-      t.assert.equal(body.toString(), '')
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  t.assert.equal(response.headers.get('content-length'), contentLength)
+  t.assert.equal(await response.text(), '')
 })
 
 test('respect the .code when using with sendFile', t => {

From 81fb6d76a80b61f4492af4ddaf8a7738e2a27877 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:10:07 +0100
Subject: [PATCH 58/93] chore: respect .code

---
 test/static.test.js | 32 ++++++++++++--------------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index a8492f30..639a532e 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3406,8 +3406,8 @@ test('content-length in head route should not return zero when using wildcard',
   t.assert.equal(await response.text(), '')
 })
 
-test('respect the .code when using with sendFile', t => {
-  t.plan(6)
+test('respect the .code when using with sendFile', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static')
@@ -3422,26 +3422,18 @@ test('respect the .code when using with sendFile', t => {
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    const file = fs.readFileSync(path.join(__dirname, '/static/foo.html'))
-    const contentLength = Buffer.byteLength(file).toString()
+  const file = fs.readFileSync(path.join(__dirname, '/static/foo.html'))
+  const contentLength = Buffer.byteLength(file).toString()
 
-    simple.concat({
-      method: 'HEAD',
-      url: 'http://localhost:' + fastify.server.address().port + '/custom',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 404)
-      t.assert.equal(response.headers['content-type'], 'text/html; charset=utf-8')
-      t.assert.equal(response.headers['content-length'], contentLength)
-      t.assert.equal(body.toString(), '')
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/custom', { method: 'HEAD' })
+  t.assert.ok(!response.ok)
+  t.assert.equal(response.status, 404)
+  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  t.assert.equal(response.headers.get('content-length'), contentLength)
+  t.assert.equal(await response.text(), '')
 })
 
 test('respect the .type when using with sendFile with contentType disabled', t => {

From bc3b49b6c3a252543655c6cf0c44997c9883f62f Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:11:13 +0100
Subject: [PATCH 59/93] chore: respect .type

---
 test/static.test.js | 32 ++++++++++++--------------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index 639a532e..0c99f1b9 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -3436,8 +3436,8 @@ test('respect the .code when using with sendFile', async t => {
   t.assert.equal(await response.text(), '')
 })
 
-test('respect the .type when using with sendFile with contentType disabled', t => {
-  t.plan(6)
+test('respect the .type when using with sendFile with contentType disabled', async t => {
+  t.plan(5)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -3453,24 +3453,16 @@ test('respect the .type when using with sendFile with contentType disabled', t =
 
   t.after(() => fastify.close())
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    fastify.server.unref()
+  await fastify.listen({ port: 0 })
+  fastify.server.unref()
 
-    const file = fs.readFileSync(path.join(__dirname, '/static/foo.html'))
-    const contentLength = Buffer.byteLength(file).toString()
+  const file = fs.readFileSync(path.join(__dirname, '/static/foo.html'))
+  const contentLength = Buffer.byteLength(file).toString()
 
-    simple.concat({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/custom',
-      followRedirect: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(response.headers['content-type'], 'text/html; charset=windows-1252')
-      t.assert.equal(response.headers['content-length'], contentLength)
-      t.assert.equal(body.toString(), fooContent)
-    })
-  })
+  const response = await fetch('http://localhost:' + fastify.server.address().port + '/custom')
+  t.assert.ok(response.ok)
+  t.assert.equal(response.status, 200)
+  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=windows-1252')
+  t.assert.equal(response.headers.get('content-length'), contentLength)
+  t.assert.equal(await response.text(), fooContent)
 })

From 4903e02b8cf237bc5d10b79034496657cbd3987c Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:13:49 +0100
Subject: [PATCH 60/93] chore: removed simple

---
 test/static.test.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/static.test.js b/test/static.test.js
index 0c99f1b9..720f062c 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -7,7 +7,6 @@ const fs = require('node:fs')
 const url = require('node:url')
 const http = require('node:http')
 const { test } = require('node:test')
-const simple = require('simple-get')
 const Fastify = require('fastify')
 const compress = require('@fastify/compress')
 const concat = require('concat-stream')

From a74add68a60856a553284a3438c4ea47232ee87e Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:16:04 +0100
Subject: [PATCH 61/93] chore: dir list wrong

---
 test/dir-list.test.js | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 21487fa2..0a51afa8 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -5,7 +5,6 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { test } = require('node:test')
-const simple = require('simple-get')
 const Fastify = require('fastify')
 
 const fastifyStatic = require('..')
@@ -72,7 +71,7 @@ test('throws when `list.format` is html and `list render` is not a function', t
   t.assert.equal(err.message, 'The `list.render` option must be a function and is required with html format')
 })
 
-test('dir list wrong options', t => {
+test('dir list wrong options', async t => {
   t.plan(3)
 
   const cases = [
@@ -110,10 +109,8 @@ test('dir list wrong options', t => {
   for (const case_ of cases) {
     const fastify = Fastify()
     fastify.register(fastifyStatic, case_.options)
-    fastify.listen({ port: 0 }, err => {
-      t.assert.equal(err.message, case_.error.message)
-      fastify.server.unref()
-    })
+    await t.assert.rejects(fastify.listen({ port: 0 }), new TypeError(case_.error.message))
+    fastify.server.unref()
   }
 })
 

From f39769b4319d30918698efa7f9318f928197760d Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:23:54 +0100
Subject: [PATCH 62/93] fix: dir list

---
 test/dir-list.test.js | 53 ++++++++++++++++++-------------------------
 1 file changed, 22 insertions(+), 31 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 0a51afa8..7b5bc844 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -14,16 +14,13 @@ const helper = {
   arrange: function (t, options, f) {
     return helper.arrangeModule(t, options, fastifyStatic, f)
   },
-  arrangeModule: function (t, options, mock, f) {
+  arrangeModule: async function (t, options, mock, f) {
     const fastify = Fastify()
     fastify.register(mock, options)
     t.after(() => fastify.close())
-    fastify.listen({ port: 0 }, err => {
-      t.assert.ifError(err)
-      fastify.server.unref()
-      f('http://localhost:' + fastify.server.address().port)
-    })
-    return f
+    await fastify.listen({ port: 0 })
+    fastify.server.unref()
+    await f('http://localhost:' + fastify.server.address().port)
   }
 }
 
@@ -114,8 +111,8 @@ test('dir list wrong options', async t => {
   }
 })
 
-test('dir list default options', t => {
-  t.plan(2)
+test('dir list default options', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -125,23 +122,20 @@ test('dir list default options', t => {
   const route = '/public/shallow'
   const content = { dirs: ['empty'], files: ['sample.jpg'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })
 
-test('dir list, custom options', t => {
-  t.plan(2)
+test('dir list, custom options', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -153,17 +147,14 @@ test('dir list, custom options', t => {
   const route = '/public/'
   const content = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })

From d444970a1c01ff5dd694a2b0d342a82988e3d1d2 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:25:07 +0100
Subject: [PATCH 63/93] fix: dir list custom options

---
 test/dir-list.test.js | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 7b5bc844..3766089b 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -159,8 +159,8 @@ test('dir list, custom options', async t => {
   })
 })
 
-test('dir list, custom options with empty array index', t => {
-  t.plan(2)
+test('dir list, custom options with empty array index', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -172,17 +172,14 @@ test('dir list, custom options with empty array index', t => {
   const route = '/public/'
   const content = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })

From aaa8917a19a5a5bc9cc52e08645439889427814f Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:26:50 +0100
Subject: [PATCH 64/93] chore: html format

---
 test/dir-list.test.js | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 3766089b..25dc56dd 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -184,8 +184,8 @@ test('dir list, custom options with empty array index', async t => {
   })
 })
 
-test('dir list html format', t => {
-  t.plan(3)
+test('dir list html format', async t => {
+  t.plan(2)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -212,17 +212,15 @@ test('dir list html format', t => {
 
   // check all routes by names
 
-  helper.arrange(t, options, (url) => {
+  await helper.arrange(t, options, async (url) => {
     for (const route of routes) {
-      test(route, t => {
+      await t.test(route, async t => {
         t.plan(3)
-        simple.concat({
-          method: 'GET',
-          url: url + route
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.equal(response.statusCode, 200)
-          t.assert.equal(body.toString(), `
+
+        const response = await fetch(url + route)
+        t.assert.ok(response.ok)
+        t.assert.equal(response.status, 200)
+        t.assert.equal(await response.text(), `
 <html><body>
 <ul>
   <li><a href="/public/deep">deep</a></li>
@@ -239,7 +237,6 @@ test('dir list html format', t => {
 </ul>
 </body></html>
 `)
-        })
       })
     }
   })

From 3621d24fe3cdee615fbc8d7590a1ef59648ce375 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:30:22 +0100
Subject: [PATCH 65/93] chore: dir list

---
 test/dir-list.test.js | 33 ++++++++++++++-------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 25dc56dd..7100a0f6 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -242,8 +242,8 @@ test('dir list html format', async t => {
   })
 })
 
-test('dir list href nested structure', t => {
-  t.plan(6)
+test('dir list href nested structure', async t => {
+  t.plan(5)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -265,25 +265,20 @@ test('dir list href nested structure', t => {
     { path: '/public/deep/index.htm', response: '/public/deep/path' },
     { path: '/public/deep/path/', response: '/public/deep/path/for' }
   ]
-  helper.arrange(t, options, (url) => {
+  await helper.arrange(t, options, async (url) => {
     for (const route of routes) {
-      test(route.path, t => {
+      await t.test(route.path, async t => {
         t.plan(5)
-        simple.concat({
-          method: 'GET',
-          url: url + route.path
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.equal(response.statusCode, 200)
-          t.assert.equal(body.toString(), route.response)
-          simple.concat({
-            method: 'GET',
-            url: url + body.toString()
-          }, (err, response, body) => {
-            t.assert.ifError(err)
-            t.assert.equal(response.statusCode, 200)
-          })
-        })
+
+        const response = await fetch(url + route.path)
+        t.assert.ok(response.ok)
+        t.assert.equal(response.status, 200)
+        const responseContent = await response.text()
+        t.assert.equal(responseContent, route.response)
+
+        const response2 = await fetch(url + responseContent)
+        t.assert.ok(response2.ok)
+        t.assert.equal(response2.status, 200)
       })
     }
   })

From 8f7256ae4021e9231df819608ec70161501b339d Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:32:38 +0100
Subject: [PATCH 66/93] dir list html format

---
 test/dir-list.test.js | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 7100a0f6..11d999fe 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -284,8 +284,8 @@ test('dir list href nested structure', async t => {
   })
 })
 
-test('dir list html format - stats', t => {
-  t.plan(7)
+test('dir list html format - stats', async t => {
+  t.plan(6)
 
   const options1 = {
     root: path.join(__dirname, '/static'),
@@ -294,11 +294,11 @@ test('dir list html format - stats', t => {
     list: {
       format: 'html',
       render (dirs, files) {
-        t.ok(dirs.length > 0)
-        t.ok(files.length > 0)
+        t.assert.ok(dirs.length > 0)
+        t.assert.ok(files.length > 0)
 
-        t.ok(dirs.every(every))
-        t.ok(files.every(every))
+        t.assert.ok(dirs.every(every))
+        t.assert.ok(files.every(every))
 
         function every (value) {
           return value.stats &&
@@ -311,14 +311,10 @@ test('dir list html format - stats', t => {
 
   const route = '/public/'
 
-  helper.arrange(t, options1, (url) => {
-    simple.concat({
-      method: 'GET',
-      url: url + route
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-    })
+  await helper.arrange(t, options1, async (url) => {
+    const response = await fetch(url + route)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
   })
 })
 

From fcf52fbf6a26e8694a1df0d43a7f34a001e5b294 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:34:57 +0100
Subject: [PATCH 67/93] chore: dir list

---
 test/dir-list.test.js | 39 ++++++++++++++++-----------------------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 11d999fe..5c3d7a2f 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -318,8 +318,8 @@ test('dir list html format - stats', async t => {
   })
 })
 
-test('dir list html format - extended info', t => {
-  t.plan(4)
+test('dir list html format - extended info', async t => {
+  t.plan(2)
 
   const route = '/public/'
 
@@ -335,7 +335,7 @@ test('dir list html format - extended info', t => {
           t.plan(dirs.length * 7)
 
           for (const value of dirs) {
-            t.ok(value.extendedInfo)
+            t.assert.ok(value.extendedInfo)
 
             t.assert.equal(typeof value.extendedInfo.fileCount, 'number')
             t.assert.equal(typeof value.extendedInfo.totalFileCount, 'number')
@@ -349,19 +349,15 @@ test('dir list html format - extended info', t => {
     }
   }
 
-  helper.arrange(t, options, (url) => {
-    simple.concat({
-      method: 'GET',
-      url: url + route
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-    })
+  await helper.arrange(t, options, async (url) => {
+    const response = await fetch(url + route)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
   })
 })
 
-test('dir list json format', t => {
-  t.plan(2)
+test('dir list json format', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -375,18 +371,15 @@ test('dir list json format', t => {
   const routes = ['/public/shallow/']
   const content = { dirs: ['empty'], files: ['sample.jpg'] }
 
-  helper.arrange(t, options, (url) => {
+  await helper.arrange(t, options, async (url) => {
     for (const route of routes) {
-      test(route, t => {
+      await t.test(route, async t => {
         t.plan(3)
-        simple.concat({
-          method: 'GET',
-          url: url + route
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.equal(response.statusCode, 200)
-          t.assert.equal(body.toString(), JSON.stringify(content))
-        })
+
+        const response = await fetch(url + route)
+        t.assert.ok(response.ok)
+        t.assert.equal(response.status, 200)
+        t.assert.deepStrictEqual(await response.json(), content)
       })
     }
   })

From b8ef3c76e700b9b00629e0563ddb49b2643f141b Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:36:09 +0100
Subject: [PATCH 68/93] chore: dir list json

---
 test/dir-list.test.js | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 5c3d7a2f..cd20bf5f 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -385,8 +385,8 @@ test('dir list json format', async t => {
   })
 })
 
-test('dir list json format - extended info', t => {
-  t.plan(2)
+test('dir list json format - extended info', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -402,21 +402,18 @@ test('dir list json format - extended info', t => {
   }
   const routes = ['/public/shallow/']
 
-  helper.arrange(t, options, (url) => {
+  await helper.arrange(t, options, async (url) => {
     for (const route of routes) {
-      test(route, t => {
+      await t.test(route, async t => {
         t.plan(5)
-        simple.concat({
-          method: 'GET',
-          url: url + route
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.equal(response.statusCode, 200)
-          const bodyObject = JSON.parse(body.toString())
-          t.assert.equal(bodyObject.dirs[0].name, 'empty')
-          t.assert.equal(typeof bodyObject.dirs[0].stats.atimeMs, 'number')
-          t.assert.equal(typeof bodyObject.dirs[0].extendedInfo.totalSize, 'number')
-        })
+
+        const response = await fetch(url + route)
+        t.assert.ok(response.ok)
+        t.assert.equal(response.status, 200)
+        const responseContent = await response.json()
+        t.assert.equal(responseContent.dirs[0].name, 'empty')
+        t.assert.equal(typeof responseContent.dirs[0].stats.atimeMs, 'number')
+        t.assert.equal(typeof responseContent.dirs[0].extendedInfo.totalSize, 'number')
       })
     }
   })

From f1020a71b6bc4cddc27d05377d153061053e86a6 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:40:07 +0100
Subject: [PATCH 69/93] chore: json format

---
 test/dir-list.test.js | 52 +++++++++++++++++--------------------------
 1 file changed, 20 insertions(+), 32 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index cd20bf5f..df401fad 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -419,8 +419,8 @@ test('dir list json format - extended info', async t => {
   })
 })
 
-test('json format with url parameter format', t => {
-  t.plan(13)
+test('json format with url parameter format', async t => {
+  t.plan(12)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -436,36 +436,24 @@ test('json format with url parameter format', t => {
   const route = '/public/'
   const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
-  helper.arrange(t, options, (url) => {
-    simple.concat({
-      method: 'GET',
-      url: url + route
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
-      t.ok(response.headers['content-type'].includes('application/json'))
-    })
-
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=html'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), 'html')
-      t.ok(response.headers['content-type'].includes('text/html'))
-    })
-
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
-      t.ok(response.headers['content-type'].includes('application/json'))
-    })
+  await helper.arrange(t, options, async (url) => {
+    const response = await fetch(url + route)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), jsonContent)
+    t.assert.ok(response.headers.get('content-type').includes('application/json'))
+
+    const response2 = await fetch(url + route + '?format=html')
+    t.assert.ok(response2.ok)
+    t.assert.equal(response2.status, 200)
+    t.assert.equal(await response2.text(), 'html')
+    t.assert.ok(response2.headers.get('content-type').includes('text/html'))
+
+    const response3 = await fetch(url + route + '?format=json')
+    t.assert.ok(response3.ok)
+    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(await response3.json(), jsonContent)
+    t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
 })
 

From 264bc94ad48d03c88aaf7596278c5d8f5d84e6d8 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:41:48 +0100
Subject: [PATCH 70/93] chore: json format

---
 test/dir-list.test.js | 46 ++++++++++++++++---------------------------
 1 file changed, 17 insertions(+), 29 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index df401fad..17d617f2 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -457,8 +457,8 @@ test('json format with url parameter format', async t => {
   })
 })
 
-test('json format with url parameter format and without render option', t => {
-  t.plan(12)
+test('json format with url parameter format and without render option', async t => {
+  t.plan(11)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -471,35 +471,23 @@ test('json format with url parameter format and without render option', t => {
   const route = '/public/'
   const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
-  helper.arrange(t, options, (url) => {
-    simple.concat({
-      method: 'GET',
-      url: url + route
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
-      t.ok(response.headers['content-type'].includes('application/json'))
-    })
+  await helper.arrange(t, options, async (url) => {
+    const response = await fetch(url + route)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), jsonContent)
+    t.assert.ok(response.headers.get('content-type').includes('application/json'))
 
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=html'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 500)
-      t.assert.equal(JSON.parse(body.toString()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
-    })
+    const response2 = await fetch(url + route + '?format=html')
+    t.assert.ok(!response2.ok)
+    t.assert.equal(response2.status, 500)
+    t.assert.equal((await response2.json()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
 
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
-      t.ok(response.headers['content-type'].includes('application/json'))
-    })
+    const response3 = await fetch(url + route + '?format=json')
+    t.assert.ok(response3.ok)
+    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(await response3.json(), jsonContent)
+    t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
 })
 

From 03b3d8c31d6e369818615fcccfb1d89a43059d63 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:48:57 +0100
Subject: [PATCH 71/93] chore: html format

---
 test/dir-list.test.js | 48 ++++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 30 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 17d617f2..a4f74252 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -491,8 +491,8 @@ test('json format with url parameter format and without render option', async t
   })
 })
 
-test('html format with url parameter format', t => {
-  t.plan(13)
+test('html format with url parameter format', async t => {
+  t.plan(12)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -508,36 +508,24 @@ test('html format with url parameter format', t => {
   const route = '/public/'
   const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', '100%.txt', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
-  helper.arrange(t, options, (url) => {
-    simple.concat({
-      method: 'GET',
-      url: url + route
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), 'html')
-      t.ok(response.headers['content-type'].includes('text/html'))
-    })
+  await helper.arrange(t, options, async (url) => {
+    const response = await fetch(url + route)
+    t.assert.ok(response.ok)
+    t.assert.equal(response.status, 200)
+    t.assert.equal(await response.text(), 'html')
+    t.assert.ok(response.headers.get('content-type').includes('text/html'))
 
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=html'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), 'html')
-      t.ok(response.headers['content-type'].includes('text/html'))
-    })
+    const response2 = await fetch(url + route + '?format=html')
+    t.assert.ok(response2.ok)
+    t.assert.equal(response2.status, 200)
+    t.assert.equal(await response2.text(), 'html')
+    t.assert.ok(response2.headers.get('content-type').includes('text/html'))
 
-    simple.concat({
-      method: 'GET',
-      url: url + route + '?format=json'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.equal(response.statusCode, 200)
-      t.assert.equal(body.toString(), JSON.stringify(jsonContent))
-      t.ok(response.headers['content-type'].includes('application/json'))
-    })
+    const response3 = await fetch(url + route + '?format=json')
+    t.assert.ok(response3.ok)
+    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(await response3.json(), jsonContent)
+    t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
 })
 

From c02e5f236a987be204c92d3450d995a4c73bd7a4 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:51:42 +0100
Subject: [PATCH 72/93] chore: list html

---
 test/dir-list.test.js | 56 ++++++++++++++++---------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index a4f74252..4b34f7c4 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -529,8 +529,8 @@ test('html format with url parameter format', async t => {
   })
 })
 
-test('dir list on empty dir', t => {
-  t.plan(2)
+test('dir list on empty dir', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -540,23 +540,20 @@ test('dir list on empty dir', t => {
   const route = '/public/shallow/empty'
   const content = { dirs: [], files: [] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })
 
-test('dir list serve index.html on index option', t => {
-  t.plan(2)
+test('dir list serve index.html on index option', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -569,30 +566,19 @@ test('dir list serve index.html on index option', t => {
     }
   }
 
-  helper.arrange(t, options, (url) => {
-    test('serve index.html from fs', t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test('serve index.html from fs', async t => {
       t.plan(6)
 
-      let route = '/public/index.html'
-
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
-      })
+      const response = await fetch(url + '/public/index.html')
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.equal(await response.text(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
 
-      route = '/public/index'
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), 'dir list index')
-      })
+      const response2 = await fetch(url + '/public/index')
+      t.assert.ok(response2.ok)
+      t.assert.equal(response2.status, 200)
+      t.assert.equal(await response2.text(), 'dir list index')
     })
   })
 })

From b379ab9fa8562bfde1012bf9ca04244c2977b194 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:53:06 +0100
Subject: [PATCH 73/93] chore: not existing dirs

---
 test/dir-list.test.js | 38 ++++++++++++++++----------------------
 1 file changed, 16 insertions(+), 22 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 4b34f7c4..4a0db803 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -583,8 +583,8 @@ test('dir list serve index.html on index option', async t => {
   })
 })
 
-test('serve a non existent dir and get error', t => {
-  t.plan(2)
+test('serve a non existent dir and get error', async t => {
+  t.plan(1)
 
   const options = {
     root: '/none',
@@ -593,22 +593,19 @@ test('serve a non existent dir and get error', t => {
   }
   const route = '/public/'
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(!response.ok)
+      t.assert.equal(response.status, 404)
     })
   })
 })
 
-test('serve a non existent dir and get error', t => {
-  t.plan(2)
+test('serve a non existent dir and get error', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -619,16 +616,13 @@ test('serve a non existent dir and get error', t => {
   }
   const route = '/public/none/index'
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(2)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 404)
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(!response.ok)
+      t.assert.equal(response.status, 404)
     })
   })
 })

From e3aff0ae4f21180d32c23662e5486ca8ba1109ff Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:53:58 +0100
Subject: [PATCH 74/93] chore: dir with dotfiles

---
 test/dir-list.test.js | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 4a0db803..950b3cac 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -627,8 +627,8 @@ test('serve a non existent dir and get error', async t => {
   })
 })
 
-test('dir list with dotfiles allow option', t => {
-  t.plan(2)
+test('dir list with dotfiles allow option', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static-dotfiles'),
@@ -640,17 +640,14 @@ test('dir list with dotfiles allow option', t => {
   const route = '/public/'
   const content = { dirs: ['dir'], files: ['.aaa', 'test.txt'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })

From b8f11159a20bbf3375a210d7c90d7b53473ef508 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 14:55:21 +0100
Subject: [PATCH 75/93] chore: dir with dotfiles

---
 test/dir-list.test.js | 42 ++++++++++++++++++------------------------
 1 file changed, 18 insertions(+), 24 deletions(-)

diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 950b3cac..178c0248 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -652,8 +652,8 @@ test('dir list with dotfiles allow option', async t => {
   })
 })
 
-test('dir list with dotfiles deny option', t => {
-  t.plan(2)
+test('dir list with dotfiles deny option', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static-dotfiles'),
@@ -665,23 +665,20 @@ test('dir list with dotfiles deny option', t => {
   const route = '/public/'
   const content = { dirs: ['dir'], files: ['test.txt'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })
 
-test('dir list with dotfiles ignore option', t => {
-  t.plan(2)
+test('dir list with dotfiles ignore option', async t => {
+  t.plan(1)
 
   const options = {
     root: path.join(__dirname, '/static-dotfiles'),
@@ -693,17 +690,14 @@ test('dir list with dotfiles ignore option', t => {
   const route = '/public/'
   const content = { dirs: ['dir'], files: ['test.txt'] }
 
-  helper.arrange(t, options, (url) => {
-    test(route, t => {
+  await helper.arrange(t, options, async (url) => {
+    await t.test(route, async t => {
       t.plan(3)
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(response.statusCode, 200)
-        t.assert.equal(body.toString(), JSON.stringify(content))
-      })
+
+      const response = await fetch(url + route)
+      t.assert.ok(response.ok)
+      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(await response.json(), content)
     })
   })
 })

From 7fb1789e64aca3cd75fa1f05c6ebcc770887aa37 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 15:04:44 +0100
Subject: [PATCH 76/93] chore: arrange

---
 package.json          |  2 +-
 test/dir-list.test.js | 29 +++++++++++------------------
 2 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/package.json b/package.json
index 8b54cfcd..38abce58 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "node --test",
+    "test:unit": "node --test --experimental-test-module-mocks",
     "example": "node example/server.js"
   },
   "repository": {
diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 178c0248..16faf589 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -11,12 +11,9 @@ const fastifyStatic = require('..')
 const dirList = require('../lib/dirList')
 
 const helper = {
-  arrange: function (t, options, f) {
-    return helper.arrangeModule(t, options, fastifyStatic, f)
-  },
-  arrangeModule: async function (t, options, mock, f) {
+  arrange: async function (t, options, f) {
     const fastify = Fastify()
-    fastify.register(mock, options)
+    fastify.register(fastifyStatic, options)
     t.after(() => fastify.close())
     await fastify.listen({ port: 0 })
     fastify.server.unref()
@@ -702,8 +699,8 @@ test('dir list with dotfiles ignore option', async t => {
   })
 })
 
-test('dir list error', t => {
-  t.plan(7)
+test('dir list error', async t => {
+  t.plan(6)
 
   const options = {
     root: path.join(__dirname, '/static'),
@@ -720,22 +717,18 @@ test('dir list error', t => {
   const errorMessage = 'mocking send'
   dirList.send = async () => { throw new Error(errorMessage) }
 
-  const mock = t.mockRequire('..', {
-    '../lib/dirList.js': dirList
+  t.mock.module('../lib/dirList.js', {
+    defaultExport: dirList
   })
 
   const routes = ['/public/', '/public/index.htm']
 
-  helper.arrangeModule(t, options, mock, (url) => {
+  await helper.arrange(t, options, async (url) => {
     for (const route of routes) {
-      simple.concat({
-        method: 'GET',
-        url: url + route
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.equal(JSON.parse(body.toString()).message, errorMessage)
-        t.assert.equal(response.statusCode, 500)
-      })
+      const response = await fetch(url + route)
+      t.assert.ok(!response.ok)
+      t.assert.equal(response.status, 500)
+      t.assert.equal((await response.json()).message, errorMessage)
     }
   })
 })

From b92c4451a93ab7aa57cfeaa54c3b2b02772b169e Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 15:07:03 +0100
Subject: [PATCH 77/93] chore: static

---
 test/static.test.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/static.test.js b/test/static.test.js
index 720f062c..0023de9a 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2353,6 +2353,7 @@ test('if dotfiles are properly served according to plugin options', async (t) =>
 
     t.after(() => fastify.close())
     await fastify.listen({ port: 0 })
+    fastify.server.unref()
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
     t.assert.ok(!response.ok)

From 3aff483378779d26fa5f1e13a08b080a0d494653 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 15:11:02 +0100
Subject: [PATCH 78/93] chore: close

---
 test/static.test.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/static.test.js b/test/static.test.js
index 0023de9a..b0747fb7 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -711,6 +711,8 @@ test('serving disabled', async (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
+  t.after(() => fastify.close())
+
   fastify.get('/foo/bar', (request, reply) => {
     reply.sendFile('index.html')
   })
@@ -751,6 +753,8 @@ test('sendFile', async (t) => {
   const maxAge = Math.round(Math.random() * 10) * 10000
   fastify.register(fastifyStatic, pluginOptions)
 
+  t.after(() => fastify.close())
+
   fastify.get('/foo/bar', function (req, reply) {
     reply.sendFile('/index.html')
   })
@@ -821,6 +825,8 @@ test('sendFile disabled', async (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
+  t.after(() => fastify.close())
+
   fastify.get('/foo/bar', function (req, reply) {
     if (reply.sendFile === undefined) {
       reply.send('pass')
@@ -853,6 +859,8 @@ test('allowedPath option - pathname', async (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
+  t.after(() => fastify.close())
+
   await fastify.listen({ port: 0 })
   fastify.server.unref()
 
@@ -883,6 +891,9 @@ test('allowedPath option - request', async (t) => {
   }
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
+
+  t.after(() => fastify.close())
+
   await fastify.listen({ port: 0 })
 
   fastify.server.unref()
@@ -915,6 +926,8 @@ test('download', async (t) => {
   const fastify = Fastify()
   fastify.register(fastifyStatic, pluginOptions)
 
+  t.after(() => fastify.close())
+
   fastify.get('/foo/bar', function (req, reply) {
     reply.download('/index.html')
   })
@@ -1055,6 +1068,8 @@ test('download disabled', async (t) => {
     }
   })
 
+  t.after(() => fastify.close())
+
   await fastify.listen({ port: 0 })
 
   fastify.server.unref()

From ca53b1dde56605809bb99e9e5e14a6ba99ca9cd7 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 15:13:48 +0100
Subject: [PATCH 79/93] chore: rejects

---
 test/static.test.js | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index b0747fb7..aaea5d19 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -1206,83 +1206,83 @@ test('maxAge option', async (t) => {
 test('errors', async (t) => {
   t.plan(11)
 
-  await t.test('no root', (t) => {
+  await t.test('no root', async (t) => {
     t.plan(1)
     const pluginOptions = {}
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root is not a string', (t) => {
+  await t.test('root is not a string', async (t) => {
     t.plan(1)
     const pluginOptions = { root: 42 }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root is not an absolute path', (t) => {
+  await t.test('root is not an absolute path', async (t) => {
     t.plan(1)
     const pluginOptions = { root: './my/path' }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root is not a directory', (t) => {
+  await t.test('root is not a directory', async (t) => {
     t.plan(1)
     const pluginOptions = { root: __filename }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root is an empty array', (t) => {
+  await t.test('root is an empty array', async (t) => {
     t.plan(1)
     const pluginOptions = { root: [] }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root array does not contain strings', (t) => {
+  await t.test('root array does not contain strings', async (t) => {
     t.plan(1)
     const pluginOptions = { root: [1] }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root array does not contain an absolute path', (t) => {
+  await t.test('root array does not contain an absolute path', async (t) => {
     t.plan(1)
     const pluginOptions = { root: ['./my/path'] }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('root array path is not a directory', (t) => {
+  await t.test('root array path is not a directory', async (t) => {
     t.plan(1)
     const pluginOptions = { root: [__filename] }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('all root array paths must be valid', (t) => {
+  await t.test('all root array paths must be valid', async (t) => {
     t.plan(1)
     const pluginOptions = { root: [path.join(__dirname, '/static'), 1] }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('duplicate root paths are not allowed', (t) => {
+  await t.test('duplicate root paths are not allowed', async (t) => {
     t.plan(1)
     const pluginOptions = {
       root: [path.join(__dirname, '/static'), path.join(__dirname, '/static')]
     }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 
-  await t.test('setHeaders is not a function', (t) => {
+  await t.test('setHeaders is not a function', async (t) => {
     t.plan(1)
     const pluginOptions = { root: __dirname, setHeaders: 'headers' }
     const fastify = Fastify({ logger: false })
-    t.assert.rejects(fastify.register(fastifyStatic, pluginOptions))
+    await t.assert.rejects(async () => await fastify.register(fastifyStatic, pluginOptions))
   })
 })
 

From b5ed7f94741a5a6c39bf601f3f7f37c735f147df Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sat, 4 Jan 2025 15:14:20 +0100
Subject: [PATCH 80/93] chore: removed simple-get

---
 package.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/package.json b/package.json
index 38abce58..9ecb48c9 100644
--- a/package.json
+++ b/package.json
@@ -75,7 +75,6 @@
     "neostandard": "^0.12.0",
     "pino": "^9.1.0",
     "proxyquire": "^2.1.3",
-    "simple-get": "^4.0.1",
     "tsd": "^0.31.0"
   },
   "tsd": {

From edef0cf1d20ad083c21124f14c7e860db7e54a3c Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 10:34:52 +0100
Subject: [PATCH 81/93] chore: deepStrictEqual

---
 test/content-type.test.js |  20 +-
 test/dir-list.test.js     | 102 +++---
 test/static.test.js       | 662 +++++++++++++++++++-------------------
 3 files changed, 392 insertions(+), 392 deletions(-)

diff --git a/test/content-type.test.js b/test/content-type.test.js
index 6607b7b6..6712eead 100644
--- a/test/content-type.test.js
+++ b/test/content-type.test.js
@@ -29,7 +29,7 @@ test('register /content-type', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
   })
 
   await t.test('/content-type/index.css', async (t) => {
@@ -37,7 +37,7 @@ test('register /content-type', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/css; charset=utf-8')
   })
 
   await t.test('/content-type/sample.jpg', async (t) => {
@@ -45,7 +45,7 @@ test('register /content-type', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/sample.jpg')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'image/jpeg')
   })
 
   await t.test('/content-type/test.txt', async (t) => {
@@ -53,7 +53,7 @@ test('register /content-type', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/test.txt')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/plain; charset=utf-8')
   })
 
   await t.test('/content-type/binary', async (t) => {
@@ -61,7 +61,7 @@ test('register /content-type', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/content-type/binary')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'application/octet-stream')
   })
 })
 
@@ -91,7 +91,7 @@ test('register /content-type preCompressed', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
   })
 
   await t.test('/content-type/index.css', async (t) => {
@@ -103,7 +103,7 @@ test('register /content-type preCompressed', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/css; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/css; charset=utf-8')
   })
 
   await t.test('/content-type/sample.jpg', async (t) => {
@@ -115,7 +115,7 @@ test('register /content-type preCompressed', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'image/jpeg')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'image/jpeg')
   })
 
   await t.test('/content-type/test.txt', async (t) => {
@@ -127,7 +127,7 @@ test('register /content-type preCompressed', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'text/plain; charset=utf-8')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/plain; charset=utf-8')
   })
 
   await t.test('/content-type/binary', async (t) => {
@@ -139,6 +139,6 @@ test('register /content-type preCompressed', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-type'), 'application/octet-stream')
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'application/octet-stream')
   })
 })
diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 16faf589..3bba8c4f 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -30,7 +30,7 @@ test('throws when `root` is an array', t => {
 
   const err = dirList.validateOptions({ root: ['hello', 'world'], list: true })
   t.assert.ok(err instanceof TypeError)
-  t.assert.equal(err.message, 'multi-root with list option is not supported')
+  t.assert.deepStrictEqual(err.message, 'multi-root with list option is not supported')
 })
 
 test('throws when `list.format` option is invalid', t => {
@@ -38,7 +38,7 @@ test('throws when `list.format` option is invalid', t => {
 
   const err = dirList.validateOptions({ list: { format: 'hello' } })
   t.assert.ok(err instanceof TypeError)
-  t.assert.equal(err.message, 'The `list.format` option must be json or html')
+  t.assert.deepStrictEqual(err.message, 'The `list.format` option must be json or html')
 })
 
 test('throws when `list.names option` is not an array', t => {
@@ -46,7 +46,7 @@ test('throws when `list.names option` is not an array', t => {
 
   const err = dirList.validateOptions({ list: { names: 'hello' } })
   t.assert.ok(err instanceof TypeError)
-  t.assert.equal(err.message, 'The `list.names` option must be an array')
+  t.assert.deepStrictEqual(err.message, 'The `list.names` option must be an array')
 })
 
 test('throws when `list.jsonFormat` option is invalid', t => {
@@ -54,7 +54,7 @@ test('throws when `list.jsonFormat` option is invalid', t => {
 
   const err = dirList.validateOptions({ list: { jsonFormat: 'hello' } })
   t.assert.ok(err instanceof TypeError)
-  t.assert.equal(err.message, 'The `list.jsonFormat` option must be name or extended')
+  t.assert.deepStrictEqual(err.message, 'The `list.jsonFormat` option must be name or extended')
 })
 
 test('throws when `list.format` is html and `list render` is not a function', t => {
@@ -62,7 +62,7 @@ test('throws when `list.format` is html and `list render` is not a function', t
 
   const err = dirList.validateOptions({ list: { format: 'html', render: 'hello' } })
   t.assert.ok(err instanceof TypeError)
-  t.assert.equal(err.message, 'The `list.render` option must be a function and is required with html format')
+  t.assert.deepStrictEqual(err.message, 'The `list.render` option must be a function and is required with html format')
 })
 
 test('dir list wrong options', async t => {
@@ -125,7 +125,7 @@ test('dir list default options', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -150,7 +150,7 @@ test('dir list, custom options', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -175,7 +175,7 @@ test('dir list, custom options with empty array index', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -216,8 +216,8 @@ test('dir list html format', async t => {
 
         const response = await fetch(url + route)
         t.assert.ok(response.ok)
-        t.assert.equal(response.status, 200)
-        t.assert.equal(await response.text(), `
+        t.assert.deepStrictEqual(response.status, 200)
+        t.assert.deepStrictEqual(await response.text(), `
 <html><body>
 <ul>
   <li><a href="/public/deep">deep</a></li>
@@ -269,13 +269,13 @@ test('dir list href nested structure', async t => {
 
         const response = await fetch(url + route.path)
         t.assert.ok(response.ok)
-        t.assert.equal(response.status, 200)
+        t.assert.deepStrictEqual(response.status, 200)
         const responseContent = await response.text()
-        t.assert.equal(responseContent, route.response)
+        t.assert.deepStrictEqual(responseContent, route.response)
 
         const response2 = await fetch(url + responseContent)
         t.assert.ok(response2.ok)
-        t.assert.equal(response2.status, 200)
+        t.assert.deepStrictEqual(response2.status, 200)
       })
     }
   })
@@ -311,7 +311,7 @@ test('dir list html format - stats', async t => {
   await helper.arrange(t, options1, async (url) => {
     const response = await fetch(url + route)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 })
 
@@ -334,12 +334,12 @@ test('dir list html format - extended info', async t => {
           for (const value of dirs) {
             t.assert.ok(value.extendedInfo)
 
-            t.assert.equal(typeof value.extendedInfo.fileCount, 'number')
-            t.assert.equal(typeof value.extendedInfo.totalFileCount, 'number')
-            t.assert.equal(typeof value.extendedInfo.folderCount, 'number')
-            t.assert.equal(typeof value.extendedInfo.totalFolderCount, 'number')
-            t.assert.equal(typeof value.extendedInfo.totalSize, 'number')
-            t.assert.equal(typeof value.extendedInfo.lastModified, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.fileCount, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.totalFileCount, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.folderCount, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.totalFolderCount, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.totalSize, 'number')
+            t.assert.deepStrictEqual(typeof value.extendedInfo.lastModified, 'number')
           }
         })
       }
@@ -349,7 +349,7 @@ test('dir list html format - extended info', async t => {
   await helper.arrange(t, options, async (url) => {
     const response = await fetch(url + route)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 })
 
@@ -375,7 +375,7 @@ test('dir list json format', async t => {
 
         const response = await fetch(url + route)
         t.assert.ok(response.ok)
-        t.assert.equal(response.status, 200)
+        t.assert.deepStrictEqual(response.status, 200)
         t.assert.deepStrictEqual(await response.json(), content)
       })
     }
@@ -406,11 +406,11 @@ test('dir list json format - extended info', async t => {
 
         const response = await fetch(url + route)
         t.assert.ok(response.ok)
-        t.assert.equal(response.status, 200)
+        t.assert.deepStrictEqual(response.status, 200)
         const responseContent = await response.json()
-        t.assert.equal(responseContent.dirs[0].name, 'empty')
-        t.assert.equal(typeof responseContent.dirs[0].stats.atimeMs, 'number')
-        t.assert.equal(typeof responseContent.dirs[0].extendedInfo.totalSize, 'number')
+        t.assert.deepStrictEqual(responseContent.dirs[0].name, 'empty')
+        t.assert.deepStrictEqual(typeof responseContent.dirs[0].stats.atimeMs, 'number')
+        t.assert.deepStrictEqual(typeof responseContent.dirs[0].extendedInfo.totalSize, 'number')
       })
     }
   })
@@ -436,19 +436,19 @@ test('json format with url parameter format', async t => {
   await helper.arrange(t, options, async (url) => {
     const response = await fetch(url + route)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), jsonContent)
     t.assert.ok(response.headers.get('content-type').includes('application/json'))
 
     const response2 = await fetch(url + route + '?format=html')
     t.assert.ok(response2.ok)
-    t.assert.equal(response2.status, 200)
-    t.assert.equal(await response2.text(), 'html')
+    t.assert.deepStrictEqual(response2.status, 200)
+    t.assert.deepStrictEqual(await response2.text(), 'html')
     t.assert.ok(response2.headers.get('content-type').includes('text/html'))
 
     const response3 = await fetch(url + route + '?format=json')
     t.assert.ok(response3.ok)
-    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(response3.status, 200)
     t.assert.deepStrictEqual(await response3.json(), jsonContent)
     t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
@@ -471,18 +471,18 @@ test('json format with url parameter format and without render option', async t
   await helper.arrange(t, options, async (url) => {
     const response = await fetch(url + route)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), jsonContent)
     t.assert.ok(response.headers.get('content-type').includes('application/json'))
 
     const response2 = await fetch(url + route + '?format=html')
     t.assert.ok(!response2.ok)
-    t.assert.equal(response2.status, 500)
-    t.assert.equal((await response2.json()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
+    t.assert.deepStrictEqual(response2.status, 500)
+    t.assert.deepStrictEqual((await response2.json()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
 
     const response3 = await fetch(url + route + '?format=json')
     t.assert.ok(response3.ok)
-    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(response3.status, 200)
     t.assert.deepStrictEqual(await response3.json(), jsonContent)
     t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
@@ -508,19 +508,19 @@ test('html format with url parameter format', async t => {
   await helper.arrange(t, options, async (url) => {
     const response = await fetch(url + route)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), 'html')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), 'html')
     t.assert.ok(response.headers.get('content-type').includes('text/html'))
 
     const response2 = await fetch(url + route + '?format=html')
     t.assert.ok(response2.ok)
-    t.assert.equal(response2.status, 200)
-    t.assert.equal(await response2.text(), 'html')
+    t.assert.deepStrictEqual(response2.status, 200)
+    t.assert.deepStrictEqual(await response2.text(), 'html')
     t.assert.ok(response2.headers.get('content-type').includes('text/html'))
 
     const response3 = await fetch(url + route + '?format=json')
     t.assert.ok(response3.ok)
-    t.assert.equal(response3.status, 200)
+    t.assert.deepStrictEqual(response3.status, 200)
     t.assert.deepStrictEqual(await response3.json(), jsonContent)
     t.assert.ok(response3.headers.get('content-type').includes('application/json'))
   })
@@ -543,7 +543,7 @@ test('dir list on empty dir', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -569,13 +569,13 @@ test('dir list serve index.html on index option', async t => {
 
       const response = await fetch(url + '/public/index.html')
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
-      t.assert.equal(await response.text(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
+      t.assert.deepStrictEqual(response.status, 200)
+      t.assert.deepStrictEqual(await response.text(), '<html>\n  <body>\n    the body\n  </body>\n</html>\n')
 
       const response2 = await fetch(url + '/public/index')
       t.assert.ok(response2.ok)
-      t.assert.equal(response2.status, 200)
-      t.assert.equal(await response2.text(), 'dir list index')
+      t.assert.deepStrictEqual(response2.status, 200)
+      t.assert.deepStrictEqual(await response2.text(), 'dir list index')
     })
   })
 })
@@ -596,7 +596,7 @@ test('serve a non existent dir and get error', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(!response.ok)
-      t.assert.equal(response.status, 404)
+      t.assert.deepStrictEqual(response.status, 404)
     })
   })
 })
@@ -619,7 +619,7 @@ test('serve a non existent dir and get error', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(!response.ok)
-      t.assert.equal(response.status, 404)
+      t.assert.deepStrictEqual(response.status, 404)
     })
   })
 })
@@ -643,7 +643,7 @@ test('dir list with dotfiles allow option', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -668,7 +668,7 @@ test('dir list with dotfiles deny option', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -693,7 +693,7 @@ test('dir list with dotfiles ignore option', async t => {
 
       const response = await fetch(url + route)
       t.assert.ok(response.ok)
-      t.assert.equal(response.status, 200)
+      t.assert.deepStrictEqual(response.status, 200)
       t.assert.deepStrictEqual(await response.json(), content)
     })
   })
@@ -727,8 +727,8 @@ test('dir list error', async t => {
     for (const route of routes) {
       const response = await fetch(url + route)
       t.assert.ok(!response.ok)
-      t.assert.equal(response.status, 500)
-      t.assert.equal((await response.json()).message, errorMessage)
+      t.assert.deepStrictEqual(response.status, 500)
+      t.assert.deepStrictEqual((await response.json()).message, errorMessage)
     }
   })
 })
diff --git a/test/static.test.js b/test/static.test.js
index aaea5d19..5b043ae5 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -66,7 +66,7 @@ function genericResponseChecks (t, response) {
 
 const GENERIC_ERROR_RESPONSE_CHECK_COUNT = 2
 function genericErrorResponseChecks (t, response) {
-  t.assert.equal(response.headers.get?.('content-type') ?? response.headers['content-type'], 'application/json; charset=utf-8')
+  t.assert.deepStrictEqual(response.headers.get?.('content-type') ?? response.headers['content-type'], 'application/json; charset=utf-8')
   t.assert.ok(response.headers.get?.('date') ?? response.headers.date)
 }
 
@@ -93,8 +93,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
 
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
 
     genericResponseChecks(t, response)
   })
@@ -105,7 +105,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
 
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -114,8 +114,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -124,8 +124,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -134,8 +134,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -144,8 +144,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -154,7 +154,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -163,7 +163,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -172,7 +172,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -181,7 +181,7 @@ test('register /static prefixAvoidTrailingSlash', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('file retrieve with HEAD method', async t => {
@@ -192,8 +192,8 @@ test('register /static prefixAvoidTrailingSlash', async t => {
     })
 
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 })
@@ -219,8 +219,8 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -229,7 +229,7 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -238,8 +238,8 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -248,7 +248,7 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('/static/deep/path/for/test/purpose/foo.html', async (t) => {
@@ -256,8 +256,8 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -266,8 +266,8 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -276,7 +276,7 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -285,7 +285,7 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -296,7 +296,7 @@ test('register /static', async (t) => {
       redirect: 'error'
     })
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -305,7 +305,7 @@ test('register /static', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 })
 
@@ -330,8 +330,8 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -342,8 +342,8 @@ test('register /static/', async t => {
       method: 'HEAD'
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -352,7 +352,7 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -361,8 +361,8 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -371,7 +371,7 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('/static/deep/path/for/test/purpose/foo.html', async (t) => {
@@ -379,8 +379,8 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -389,8 +389,8 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -399,7 +399,7 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/for/test')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -408,7 +408,7 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -417,7 +417,7 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -426,8 +426,8 @@ test('register /static/', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
 
     const response2 = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html', {
@@ -437,7 +437,7 @@ test('register /static/', async t => {
       cache: 'no-cache'
     })
     t.assert.ok(!response2.ok)
-    t.assert.equal(response2.status, 304)
+    t.assert.deepStrictEqual(response2.status, 304)
   })
 })
 
@@ -470,9 +470,9 @@ test('register /static and /static2', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     const responseText = await response.text()
-    t.assert.equal(responseText, indexContent)
+    t.assert.deepStrictEqual(responseText, indexContent)
     t.assert.notEqual(responseText, index2Content)
     genericResponseChecks(t, response)
   })
@@ -482,8 +482,8 @@ test('register /static and /static2', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/bar.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), barContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), barContent)
     genericResponseChecks(t, response)
   })
 
@@ -492,8 +492,8 @@ test('register /static and /static2', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), fooContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), fooContent)
     genericResponseChecks(t, response)
   })
 
@@ -502,8 +502,8 @@ test('register /static and /static2', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), barContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), barContent)
     genericResponseChecks(t, response)
   })
 })
@@ -535,8 +535,8 @@ test('register /static with constraints', async (t) => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -549,7 +549,7 @@ test('register /static with constraints', async (t) => {
       }
     })
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 })
@@ -580,10 +580,10 @@ test('payload.path is set', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
-    t.assert.equal(typeof gotFilename, 'string')
-    t.assert.equal(gotFilename, path.join(pluginOptions.root, 'index.html'))
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
+    t.assert.deepStrictEqual(typeof gotFilename, 'string')
+    t.assert.deepStrictEqual(gotFilename, path.join(pluginOptions.root, 'index.html'))
     genericResponseChecks(t, response)
   })
 
@@ -592,8 +592,8 @@ test('payload.path is set', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/this/path/doesnt/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
-    t.assert.equal(typeof gotFilename, 'undefined')
+    t.assert.deepStrictEqual(response.status, 404)
+    t.assert.deepStrictEqual(typeof gotFilename, 'undefined')
     genericErrorResponseChecks(t, response)
   })
 })
@@ -627,9 +627,9 @@ test('error responses can be customized with fastify.setErrorHandler()', async t
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.js')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 403)
-    t.assert.equal(response.headers.get('content-type'), 'text/plain')
-    t.assert.equal(await response.text(), '500 Custom error message')
+    t.assert.deepStrictEqual(response.status, 403)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/plain')
+    t.assert.deepStrictEqual(await response.text(), '500 Custom error message')
   })
 })
 
@@ -658,9 +658,9 @@ test('not found responses can be customized with fastify.setNotFoundHandler()',
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/path/does/not/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
-    t.assert.equal(response.headers.get('content-type'), 'text/plain')
-    t.assert.equal(await response.text(), '/path/does/not/exist.html Not Found')
+    t.assert.deepStrictEqual(response.status, 404)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/plain')
+    t.assert.deepStrictEqual(await response.text(), '/path/does/not/exist.html Not Found')
   })
 })
 
@@ -694,9 +694,9 @@ test('fastify.setNotFoundHandler() is called for dotfiles when send is configure
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/path/does/not/.exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
-    t.assert.equal(response.headers.get('content-type'), 'text/plain')
-    t.assert.equal(await response.text(), '/path/does/not/.exist.html Not Found')
+    t.assert.deepStrictEqual(response.status, 404)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/plain')
+    t.assert.deepStrictEqual(await response.text(), '/path/does/not/.exist.html Not Found')
   })
 })
 
@@ -728,7 +728,7 @@ test('serving disabled', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('/static/index.html via sendFile found', async (t) => {
@@ -736,8 +736,8 @@ test('serving disabled', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 })
@@ -777,8 +777,8 @@ test('sendFile', async (t) => {
     t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -787,8 +787,8 @@ test('sendFile', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -797,8 +797,8 @@ test('sendFile', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -807,9 +807,9 @@ test('sendFile', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/options/override/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
-    t.assert.equal(response.headers.get('cache-control'), `public, max-age=${maxAge / 1000}`)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.headers.get('cache-control'), `public, max-age=${maxAge / 1000}`)
     genericResponseChecks(t, response)
   })
 })
@@ -844,8 +844,8 @@ test('sendFile disabled', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), 'pass')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), 'pass')
   })
 })
 
@@ -869,7 +869,7 @@ test('allowedPath option - pathname', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -878,7 +878,7 @@ test('allowedPath option - pathname', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 })
 
@@ -903,7 +903,7 @@ test('allowedPath option - request', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foobar.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -912,7 +912,7 @@ test('allowedPath option - request', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css?key=temporaryKey')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 })
 
@@ -984,9 +984,9 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -995,9 +995,9 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/change')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1006,9 +1006,9 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="foo.html"')
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="foo.html"')
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1017,10 +1017,10 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/override')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
-    t.assert.equal(response.headers.get('cache-control'), 'public, max-age=7200, immutable')
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.deepStrictEqual(response.headers.get('cache-control'), 'public, max-age=7200, immutable')
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1029,10 +1029,10 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar/override/2')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
-    t.assert.equal(response.headers.get('accept-ranges'), undefined)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="index.html"')
+    t.assert.deepStrictEqual(response.headers.get('accept-ranges'), null)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1041,9 +1041,9 @@ test('download', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/root/path/override/test/change')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-disposition'), 'attachment; filename="hello-world.html"')
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 })
@@ -1061,7 +1061,7 @@ test('download disabled', async (t) => {
 
   fastify.get('/foo/bar', function (req, reply) {
     if (reply.download === undefined) {
-      t.assert.equal(reply.download, undefined)
+      t.assert.deepStrictEqual(reply.download, undefined)
       reply.send('pass')
     } else {
       reply.send('fail')
@@ -1079,8 +1079,8 @@ test('download disabled', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/foo/bar')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), 'pass')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), 'pass')
   })
 })
 
@@ -1096,7 +1096,7 @@ test('root not found warning', async (t) => {
   const rootPath = path.join(__dirname, 'does-not-exist')
   const pluginOptions = { root: rootPath }
   const destination = concat((data) => {
-    t.assert.equal(JSON.parse(data).msg, `"root" path "${rootPath}" must exist`)
+    t.assert.deepStrictEqual(JSON.parse(data).msg, `"root" path "${rootPath}" must exist`)
   })
   const loggerInstance = pino(
     {
@@ -1131,18 +1131,18 @@ test('send options', (t) => {
   const { resolve, promise } = Promise.withResolvers()
   const fastifyStatic = require('proxyquire')('../', {
     '@fastify/send': function sendStub (req, pathName, options) {
-      t.assert.equal(pathName, '/index.html')
-      t.assert.equal(options.root, path.join(__dirname, '/static'))
-      t.assert.equal(options.acceptRanges, 'acceptRanges')
-      t.assert.equal(options.contentType, 'contentType')
-      t.assert.equal(options.cacheControl, 'cacheControl')
-      t.assert.equal(options.dotfiles, 'dotfiles')
-      t.assert.equal(options.etag, 'etag')
-      t.assert.equal(options.extensions, 'extensions')
-      t.assert.equal(options.immutable, 'immutable')
-      t.assert.equal(options.index, 'index')
-      t.assert.equal(options.lastModified, 'lastModified')
-      t.assert.equal(options.maxAge, 'maxAge')
+      t.assert.deepStrictEqual(pathName, '/index.html')
+      t.assert.deepStrictEqual(options.root, path.join(__dirname, '/static'))
+      t.assert.deepStrictEqual(options.acceptRanges, 'acceptRanges')
+      t.assert.deepStrictEqual(options.contentType, 'contentType')
+      t.assert.deepStrictEqual(options.cacheControl, 'cacheControl')
+      t.assert.deepStrictEqual(options.dotfiles, 'dotfiles')
+      t.assert.deepStrictEqual(options.etag, 'etag')
+      t.assert.deepStrictEqual(options.extensions, 'extensions')
+      t.assert.deepStrictEqual(options.immutable, 'immutable')
+      t.assert.deepStrictEqual(options.index, 'index')
+      t.assert.deepStrictEqual(options.lastModified, 'lastModified')
+      t.assert.deepStrictEqual(options.maxAge, 'maxAge')
       resolve()
       return { on: () => { }, pipe: () => { } }
     }
@@ -1159,7 +1159,7 @@ test('setHeaders option', async (t) => {
   const pluginOptions = {
     root: path.join(__dirname, 'static'),
     setHeaders: function (res, pathName) {
-      t.assert.equal(pathName, path.join(__dirname, 'static/index.html'))
+      t.assert.deepStrictEqual(pathName, path.join(__dirname, 'static/index.html'))
       res.setHeader('X-Test-Header', 'test')
     }
   }
@@ -1174,9 +1174,9 @@ test('setHeaders option', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(response.headers.get('x-test-header'), 'test')
-  t.assert.equal(await response.text(), indexContent)
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(response.headers.get('x-test-header'), 'test')
+  t.assert.deepStrictEqual(await response.text(), indexContent)
   genericResponseChecks(t, response)
 })
 
@@ -1197,9 +1197,9 @@ test('maxAge option', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(response.headers.get('cache-control'), 'public, max-age=3600')
-  t.assert.equal(await response.text(), indexContent)
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(response.headers.get('cache-control'), 'public, max-age=3600')
+  t.assert.deepStrictEqual(await response.text(), indexContent)
   genericResponseChecks(t, response)
 })
 
@@ -1310,8 +1310,8 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1320,7 +1320,7 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -1329,7 +1329,7 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1338,8 +1338,8 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1348,8 +1348,8 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -1358,7 +1358,7 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/this/path/doesnt/exist.html')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -1367,7 +1367,7 @@ test('register no prefix', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 })
@@ -1395,8 +1395,8 @@ test('with fastify-compress', async t => {
       }
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-encoding'), 'deflate')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-encoding'), 'deflate')
     genericResponseChecks(t, response)
   })
 
@@ -1405,8 +1405,8 @@ test('with fastify-compress', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-encoding'), 'gzip')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-encoding'), 'gzip')
     genericResponseChecks(t, response)
   })
 })
@@ -1438,8 +1438,8 @@ test('register /static/ with schemaHide true', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
     genericResponseChecks(t, response)
   })
 })
@@ -1472,8 +1472,8 @@ test('register /static/ with schemaHide false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
     genericResponseChecks(t, response)
   })
 })
@@ -1505,8 +1505,8 @@ test('register /static/ without schemaHide', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
     genericResponseChecks(t, response)
   })
 })
@@ -1532,8 +1532,8 @@ test('fastify with exposeHeadRoutes', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 })
@@ -1563,8 +1563,8 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1573,7 +1573,7 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -1582,8 +1582,8 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1592,7 +1592,7 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/not-defined')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1601,8 +1601,8 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1611,8 +1611,8 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -1621,7 +1621,7 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1630,8 +1630,8 @@ test('register with wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 })
@@ -1665,7 +1665,7 @@ test('register with wildcard false (trailing slash in the root)', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -1674,7 +1674,7 @@ test('register with wildcard false (trailing slash in the root)', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/not-defined')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1683,8 +1683,8 @@ test('register with wildcard false (trailing slash in the root)', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1693,7 +1693,7 @@ test('register with wildcard false (trailing slash in the root)', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/../index.js')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1702,8 +1702,8 @@ test('register with wildcard false (trailing slash in the root)', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/assets/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 })
@@ -1770,8 +1770,8 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1780,8 +1780,8 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -1790,7 +1790,7 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -1799,8 +1799,8 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), foobarContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), foobarContent)
     genericResponseChecks(t, response)
   })
 
@@ -1811,8 +1811,8 @@ test('register with wildcard false and alternative index', async t => {
       method: 'HEAD'
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -1821,7 +1821,7 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/not-defined')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1830,8 +1830,8 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/purpose/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1840,8 +1840,8 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -1852,8 +1852,8 @@ test('register with wildcard false and alternative index', async t => {
       method: 'HEAD'
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -1862,7 +1862,7 @@ test('register with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/../index.js')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 })
@@ -1894,8 +1894,8 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -1906,8 +1906,8 @@ test('register /static with wildcard false and alternative index', async t => {
       method: 'HEAD'
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -1916,7 +1916,7 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.css')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     genericResponseChecks(t, response)
   })
 
@@ -1929,7 +1929,7 @@ test('register /static with wildcard false and alternative index', async t => {
     // to verify we do not get a redirect when not requested
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 200)
+      t.assert.deepStrictEqual(res.statusCode, 200)
       let body = ''
       res.on('data', (chunk) => {
         body += chunk.toString()
@@ -1950,8 +1950,8 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), foobarContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), foobarContent)
     genericResponseChecks(t, response)
   })
 
@@ -1962,8 +1962,8 @@ test('register /static with wildcard false and alternative index', async t => {
       method: 'HEAD'
     })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -1972,7 +1972,7 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/not-defined')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
@@ -1981,8 +1981,8 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/purpose/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), deepContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), deepContent)
     genericResponseChecks(t, response)
   })
 
@@ -1991,8 +1991,8 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -2001,7 +2001,7 @@ test('register /static with wildcard false and alternative index', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/../index.js')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 })
@@ -2034,8 +2034,8 @@ test('register /static with redirect true', async t => {
     // simple-get doesn't tell us about redirects so use http.request directly
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 301)
-      t.assert.equal(res.headers.location, '/static/?a=b')
+      t.assert.deepStrictEqual(res.statusCode, 301)
+      t.assert.deepStrictEqual(res.headers.location, '/static/?a=b')
       resolve()
     })
     req.on('error', (err) => console.error(err))
@@ -2045,8 +2045,8 @@ test('register /static with redirect true', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static?a=b')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -2058,8 +2058,8 @@ test('register /static with redirect true', async t => {
     // simple-get doesn't tell us about redirects so use http.request directly
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 301)
-      t.assert.equal(res.headers.location, '/static/')
+      t.assert.deepStrictEqual(res.statusCode, 301)
+      t.assert.deepStrictEqual(res.headers.location, '/static/')
 
       resolve()
     })
@@ -2074,8 +2074,8 @@ test('register /static with redirect true', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -2084,7 +2084,7 @@ test('register /static with redirect true', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -2096,8 +2096,8 @@ test('register /static with redirect true', async t => {
     // simple-get doesn't tell us about redirects so use http.request directly
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 301)
-      t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+      t.assert.deepStrictEqual(res.statusCode, 301)
+      t.assert.deepStrictEqual(res.headers.location, '/static/deep/path/for/test/?a=b')
       resolve()
     })
     req.on('error', (err) => console.error(err))
@@ -2108,8 +2108,8 @@ test('register /static with redirect true', async t => {
     // verify the redirect with query parameters works
     const response = await fetch(testurl)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -2118,8 +2118,8 @@ test('register /static with redirect true', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 })
@@ -2153,8 +2153,8 @@ test('register /static with redirect true and wildcard false', async t => {
     // simple-get doesn't tell us about redirects so use http.request directly
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static?a=b'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 301)
-      t.assert.equal(res.headers.location, '/static/?a=b')
+      t.assert.deepStrictEqual(res.statusCode, 301)
+      t.assert.deepStrictEqual(res.headers.location, '/static/?a=b')
       resolve()
     })
     req.on('error', err => console.error(err))
@@ -2163,8 +2163,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static?a=b')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -2173,8 +2173,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/?a=b')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -2183,8 +2183,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/?a=b', { method: 'HEAD' })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 
@@ -2193,7 +2193,7 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 
@@ -2205,8 +2205,8 @@ test('register /static with redirect true and wildcard false', async t => {
     // simple-get doesn't tell us about redirects so use http.request directly
     const testurl = 'http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test?a=b'
     const req = http.request(url.parse(testurl), res => {
-      t.assert.equal(res.statusCode, 301)
-      t.assert.equal(res.headers.location, '/static/deep/path/for/test/?a=b')
+      t.assert.deepStrictEqual(res.statusCode, 301)
+      t.assert.deepStrictEqual(res.headers.location, '/static/deep/path/for/test/?a=b')
       resolve()
     })
     req.on('error', err => console.error(err))
@@ -2215,8 +2215,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch(testurl)
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -2225,8 +2225,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), innerIndex)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), innerIndex)
     genericResponseChecks(t, response)
   })
 
@@ -2235,8 +2235,8 @@ test('register /static with redirect true and wildcard false', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/deep/path/for/test', { method: 'HEAD' })
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), '')
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), '')
     genericResponseChecks(t, response)
   })
 })
@@ -2265,7 +2265,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
 
     const response = await fetch(host + '/static')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('prefix with trailing trailing slash => 200', async (t) => {
@@ -2273,7 +2273,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
 
     const response = await fetch(host + '/static/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 
   await t.test('deep path with no index.html or trailing slash => 404', async (t) => {
@@ -2281,7 +2281,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
 
     const response = await fetch(host + '/static/deep/path')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('deep path with index.html but no trailing slash => 200', async (t) => {
@@ -2289,7 +2289,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
 
     const response = await fetch(host + '/static/deep/path/for/test')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 
   await t.test('deep path with index.html and trailing slash => 200', async (t) => {
@@ -2297,7 +2297,7 @@ test('trailing slash behavior with redirect = false', async (t) => {
 
     const response = await fetch(host + '/static/deep/path/for/test/')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
   })
 })
 
@@ -2328,8 +2328,8 @@ test('if dotfiles are properly served according to plugin options', async (t) =>
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), exampleContents)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), exampleContents)
   })
 
   await t.test('ignore dotfiles', async (t) => {
@@ -2351,7 +2351,7 @@ test('if dotfiles are properly served according to plugin options', async (t) =>
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
   })
 
   await t.test('deny requests to serve a dotfile', async (t) => {
@@ -2372,7 +2372,7 @@ test('if dotfiles are properly served according to plugin options', async (t) =>
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/.example')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 403)
+    t.assert.deepStrictEqual(response.status, 403)
   })
 })
 
@@ -2435,8 +2435,8 @@ test('inject support', async (t) => {
     method: 'GET',
     url: '/static/index.html'
   })
-  t.assert.equal(response.statusCode, 200)
-  t.assert.equal(response.body.toString(), indexContent)
+  t.assert.deepStrictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.body.toString(), indexContent)
 })
 
 test('routes should use custom errorHandler premature stream close', async t => {
@@ -2489,7 +2489,7 @@ test('routes should fallback to default errorHandler', async t => {
   t.after(() => fastify.close())
 
   const response = await fastify.inject({ method: 'GET', url: '/static/index.html' })
-  t.assert.equal(response.statusCode, 500)
+  t.assert.deepStrictEqual(response.statusCode, 500)
   t.assert.deepStrictEqual(await response.json(), {
     statusCode: 500,
     code: 'SOMETHING_ELSE',
@@ -2516,8 +2516,8 @@ test('percent encoded URLs in glob mode', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/a .md')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(
     fs.readFileSync(path.join(__dirname, 'static', 'a .md'), 'utf-8'),
     await response.text()
   )
@@ -2543,10 +2543,10 @@ test('register /static and /static2 without wildcard', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
+    t.assert.deepStrictEqual(response.status, 200)
     const responseContent = await response.text()
     t.assert.notEqual(responseContent, index2Content)
-    t.assert.equal(responseContent, indexContent)
+    t.assert.deepStrictEqual(responseContent, indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -2555,8 +2555,8 @@ test('register /static and /static2 without wildcard', async t => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/bar.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), barContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), barContent)
     genericResponseChecks(t, response)
   })
 })
@@ -2584,8 +2584,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
@@ -2613,8 +2613,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }
 )
@@ -2642,8 +2642,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
@@ -2671,8 +2671,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
@@ -2700,9 +2700,9 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], undefined)
-    t.assert.equal(response.statusCode, 200)
-    t.assert.equal(response.body, uncompressedStatic)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], undefined)
+    t.assert.deepStrictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, uncompressedStatic)
   }
 )
 
@@ -2730,8 +2730,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
@@ -2760,8 +2760,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, gzipOnly)
   }
 )
@@ -2790,8 +2790,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
@@ -2820,8 +2820,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
@@ -2850,9 +2850,9 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], undefined)
-    t.assert.equal(response.statusCode, 200)
-    t.assert.equal(response.body, uncompressedStatic)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], undefined)
+    t.assert.deepStrictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, uncompressedStatic)
   }
 )
 
@@ -2876,9 +2876,9 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], undefined)
-    t.assert.equal(response.statusCode, 200)
-    t.assert.equal(response.body, uncompressedStatic)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], undefined)
+    t.assert.deepStrictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.body, uncompressedStatic)
   }
 )
 
@@ -2905,8 +2905,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, indexBr)
   }
 )
@@ -2935,8 +2935,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, dirIndexBr)
   }
 )
@@ -2963,8 +2963,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, dirIndexGz)
   }
 )
@@ -2993,8 +2993,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeBr)
   }
 )
@@ -3021,9 +3021,9 @@ test(
       }
     })
 
-    t.assert.equal(response.headers['content-type'], 'image/jpeg')
-    t.assert.equal(response.headers['content-encoding'], 'br')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-type'], 'image/jpeg')
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'br')
+    t.assert.deepStrictEqual(response.statusCode, 200)
   }
 )
 
@@ -3049,7 +3049,7 @@ test(
       }
     })
 
-    t.assert.equal(response.statusCode, 404)
+    t.assert.deepStrictEqual(response.statusCode, 404)
     genericErrorResponseChecks(t, response)
   }
 )
@@ -3083,10 +3083,10 @@ test('should not redirect to protocol-relative locations', async (t) => {
     const { promise, resolve } = Promise.withResolvers()
 
     const req = http.request(url.parse(address + testUrl), res => {
-      t.assert.equal(res.statusCode, status, `status ${testUrl}`)
+      t.assert.deepStrictEqual(res.statusCode, status, `status ${testUrl}`)
 
       if (expected) {
-        t.assert.equal(res.headers.location, expected)
+        t.assert.deepStrictEqual(res.headers.location, expected)
       } else {
         t.assert.ok(!res.headers.location)
       }
@@ -3122,8 +3122,8 @@ test('should not serve index if option is `false`', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static/index.html')
     t.assert.ok(response.ok)
-    t.assert.equal(response.status, 200)
-    t.assert.equal(await response.text(), indexContent)
+    t.assert.deepStrictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), indexContent)
     genericResponseChecks(t, response)
   })
 
@@ -3132,7 +3132,7 @@ test('should not serve index if option is `false`', async (t) => {
 
     const response = await fetch('http://localhost:' + fastify.server.address().port + '/static')
     t.assert.ok(!response.ok)
-    t.assert.equal(response.status, 404)
+    t.assert.deepStrictEqual(response.status, 404)
     genericErrorResponseChecks(t, response)
   })
 })
@@ -3151,11 +3151,11 @@ test('should follow symbolic link without wildcard', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/origin/subdir/subdir/index.html')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
+  t.assert.deepStrictEqual(response.status, 200)
 
   const response2 = await fetch('http://localhost:' + fastify.server.address().port + '/dir/symlink/subdir/subdir/index.html')
   t.assert.ok(response2.ok)
-  t.assert.equal(response2.status, 200)
+  t.assert.deepStrictEqual(response2.status, 200)
 })
 
 test('should serve files into hidden dir with wildcard `false`', async (t) => {
@@ -3176,8 +3176,8 @@ test('should serve files into hidden dir with wildcard `false`', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(await response.text(), jsonHiddenContent)
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(await response.text(), jsonHiddenContent)
   t.assert.ok(/application\/(json)/.test(response.headers.get('content-type')))
   t.assert.ok(response.headers.get('etag'))
   t.assert.ok(response.headers.get('last-modified'))
@@ -3201,7 +3201,7 @@ test('should not found hidden file with wildcard is `false`', async (t) => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
   t.assert.ok(!response.ok)
-  t.assert.equal(response.status, 404)
+  t.assert.deepStrictEqual(response.status, 404)
 })
 
 test('should serve files into hidden dir without wildcard option', async (t) => {
@@ -3220,8 +3220,8 @@ test('should serve files into hidden dir without wildcard option', async (t) =>
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/.hidden/sample.json')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(await response.text(), jsonHiddenContent)
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(await response.text(), jsonHiddenContent)
   t.assert.ok(/application\/(json)/.test(response.headers.get('content-type')))
   t.assert.ok(response.headers.get('etag'))
   t.assert.ok(response.headers.get('last-modified'))
@@ -3251,8 +3251,8 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.headers['content-encoding'], 'gzip')
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.headers['content-encoding'], 'gzip')
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.rawPayload, allThreeGzip)
   }
 )
@@ -3279,7 +3279,7 @@ test(
     })
 
     genericResponseChecks(t, response)
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
@@ -3303,7 +3303,7 @@ test(
       }
     })
     genericResponseChecks(t, response)
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
@@ -3327,7 +3327,7 @@ test(
       }
     })
     genericResponseChecks(t, response)
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.body, foobarContent)
   }
 )
@@ -3353,7 +3353,7 @@ test(
         'accept-encoding': '*, *'
       }
     })
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.body, aContent)
 
     const response2 = await fastify.inject({
@@ -3363,7 +3363,7 @@ test(
         'accept-encoding': '*, *'
       }
     })
-    t.assert.equal(response2.statusCode, 200)
+    t.assert.deepStrictEqual(response2.statusCode, 200)
     t.assert.deepStrictEqual(response2.body, aContent)
   }
 )
@@ -3390,7 +3390,7 @@ test(
         'accept-encoding': '*, *'
       }
     })
-    t.assert.equal(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.statusCode, 200)
     t.assert.deepStrictEqual(response.body, txtContent)
   }
 )
@@ -3415,10 +3415,10 @@ test('content-length in head route should not return zero when using wildcard',
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/index.html', { method: 'HEAD' })
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
-  t.assert.equal(response.headers.get('content-length'), contentLength)
-  t.assert.equal(await response.text(), '')
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  t.assert.deepStrictEqual(response.headers.get('content-length'), contentLength)
+  t.assert.deepStrictEqual(await response.text(), '')
 })
 
 test('respect the .code when using with sendFile', async t => {
@@ -3445,10 +3445,10 @@ test('respect the .code when using with sendFile', async t => {
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/custom', { method: 'HEAD' })
   t.assert.ok(!response.ok)
-  t.assert.equal(response.status, 404)
-  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=utf-8')
-  t.assert.equal(response.headers.get('content-length'), contentLength)
-  t.assert.equal(await response.text(), '')
+  t.assert.deepStrictEqual(response.status, 404)
+  t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=utf-8')
+  t.assert.deepStrictEqual(response.headers.get('content-length'), contentLength)
+  t.assert.deepStrictEqual(await response.text(), '')
 })
 
 test('respect the .type when using with sendFile with contentType disabled', async t => {
@@ -3476,8 +3476,8 @@ test('respect the .type when using with sendFile with contentType disabled', asy
 
   const response = await fetch('http://localhost:' + fastify.server.address().port + '/custom')
   t.assert.ok(response.ok)
-  t.assert.equal(response.status, 200)
-  t.assert.equal(response.headers.get('content-type'), 'text/html; charset=windows-1252')
-  t.assert.equal(response.headers.get('content-length'), contentLength)
-  t.assert.equal(await response.text(), fooContent)
+  t.assert.deepStrictEqual(response.status, 200)
+  t.assert.deepStrictEqual(response.headers.get('content-type'), 'text/html; charset=windows-1252')
+  t.assert.deepStrictEqual(response.headers.get('content-length'), contentLength)
+  t.assert.deepStrictEqual(await response.text(), fooContent)
 })

From b1f2b751651c2b57773ce15426e5da57fd895632 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 10:43:37 +0100
Subject: [PATCH 82/93] chore: use c8

---
 package.json          | 5 +++--
 test/dir-list.test.js | 9 +++++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index 9ecb48c9..a5fc7450 100644
--- a/package.json
+++ b/package.json
@@ -6,12 +6,12 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "npm run test:unit -- --coverage-report=html",
+    "coverage": "c8 --100 --reporter=html node --test",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "node --test --experimental-test-module-mocks",
+    "test:unit": "c8 --100 node --test",
     "example": "node example/server.js"
   },
   "repository": {
@@ -69,6 +69,7 @@
     "@fastify/compress": "^8.0.0",
     "@fastify/pre-commit": "^2.1.0",
     "@types/node": "^22.0.0",
+    "c8": "^10.1.3",
     "concat-stream": "^2.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.1.0",
diff --git a/test/dir-list.test.js b/test/dir-list.test.js
index 3bba8c4f..5c4da834 100644
--- a/test/dir-list.test.js
+++ b/test/dir-list.test.js
@@ -717,8 +717,13 @@ test('dir list error', async t => {
   const errorMessage = 'mocking send'
   dirList.send = async () => { throw new Error(errorMessage) }
 
-  t.mock.module('../lib/dirList.js', {
-    defaultExport: dirList
+  t.beforeEach((ctx) => {
+    ctx['initialDirList'] = ctx['../lib/dirList.js']
+    ctx['../lib/dirList.js'] = dirList
+  })
+
+  t.afterEach((ctx) => {
+    ctx['../lib/dirList.js'] = ctx['initialDirList']
   })
 
   const routes = ['/public/', '/public/index.htm']

From cea275c1e6c101319fefe43a8131efd596dac813 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 10:47:46 +0100
Subject: [PATCH 83/93] chore: withResolvers polyfill

---
 test/static.test.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/static.test.js b/test/static.test.js
index 5b043ae5..255e2de6 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -70,6 +70,17 @@ function genericErrorResponseChecks (t, response) {
   t.assert.ok(response.headers.get?.('date') ?? response.headers.date)
 }
 
+if (typeof Promise.withResolvers === 'undefined') {
+  Promise.withResolvers = function () {
+    let promiseResolve, promiseReject
+    const promise = new Promise((resolve, reject) => {
+      promiseResolve = resolve
+      promiseReject = reject
+    })
+    return { promise, resolve: promiseResolve, reject: promiseReject }
+  }
+}
+
 test('register /static prefixAvoidTrailingSlash', async t => {
   t.plan(11)
 

From 28ad95dfa6918ee540c6267f7dc4e7fe9b1dbddd Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 10:57:09 +0100
Subject: [PATCH 84/93] fix: pattern

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index a5fc7450..24c23995 100644
--- a/package.json
+++ b/package.json
@@ -6,12 +6,12 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "c8 --100 --reporter=html node --test",
+    "coverage": "c8 --100 --reporter=html node --test --test **/*.test.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "c8 --100 node --test",
+    "test:unit": "c8 --100 node --test **/*.test.js",
     "example": "node example/server.js"
   },
   "repository": {

From 8ba0eb1762302d41db441b3b4b58d4d5b49ae323 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 16:38:08 +0100
Subject: [PATCH 85/93] Update test/static.test.js

Co-authored-by: Dan Castillo <dan.castillo@jasper.ai>
Signed-off-by: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
---
 test/static.test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/static.test.js b/test/static.test.js
index 255e2de6..e75f1b6d 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -2556,7 +2556,7 @@ test('register /static and /static2 without wildcard', async t => {
     t.assert.ok(response.ok)
     t.assert.deepStrictEqual(response.status, 200)
     const responseContent = await response.text()
-    t.assert.notEqual(responseContent, index2Content)
+    t.assert.notStrictEqual(responseContent, index2Content)
     t.assert.deepStrictEqual(responseContent, indexContent)
     genericResponseChecks(t, response)
   })

From bbb1b10c3493823ad8f49fd7b8709a03a3fed2e0 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 19:36:22 +0100
Subject: [PATCH 86/93] chore: equal

---
 test/static.test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/static.test.js b/test/static.test.js
index e75f1b6d..2e6a7254 100644
--- a/test/static.test.js
+++ b/test/static.test.js
@@ -484,7 +484,7 @@ test('register /static and /static2', async (t) => {
     t.assert.deepStrictEqual(response.status, 200)
     const responseText = await response.text()
     t.assert.deepStrictEqual(responseText, indexContent)
-    t.assert.notEqual(responseText, index2Content)
+    t.assert.notDeepStrictEqual(responseText, index2Content)
     genericResponseChecks(t, response)
   })
 
@@ -2556,7 +2556,7 @@ test('register /static and /static2 without wildcard', async t => {
     t.assert.ok(response.ok)
     t.assert.deepStrictEqual(response.status, 200)
     const responseContent = await response.text()
-    t.assert.notStrictEqual(responseContent, index2Content)
+    t.assert.notDeepStrictEqual(responseContent, index2Content)
     t.assert.deepStrictEqual(responseContent, indexContent)
     genericResponseChecks(t, response)
   })

From c751ab6c63382515b72947012d506aeb2e6cbee7 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Sun, 5 Jan 2025 19:37:48 +0100
Subject: [PATCH 87/93] fix: pattern test folder

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 24c23995..6056a2b6 100644
--- a/package.json
+++ b/package.json
@@ -6,12 +6,12 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "c8 --100 --reporter=html node --test --test **/*.test.js",
+    "coverage": "c8 --100 --reporter=html node --test --test test/*.test.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "c8 --100 node --test **/*.test.js",
+    "test:unit": "c8 --100 node --test test/*.test.js",
     "example": "node example/server.js"
   },
   "repository": {

From 099110cef5c754899a7fa16ff5a839a8deff9bf1 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Mon, 6 Jan 2025 19:49:39 +0100
Subject: [PATCH 88/93] chore: removed additional --test

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 6056a2b6..9648d9af 100644
--- a/package.json
+++ b/package.json
@@ -6,7 +6,7 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "c8 --100 --reporter=html node --test --test test/*.test.js",
+    "coverage": "c8 --100 --reporter=html node --test test/*.test.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",

From 03ad7c5793a4eb02ef04e20935bd6f3d04f6d0b6 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Mon, 6 Jan 2025 19:52:22 +0100
Subject: [PATCH 89/93] fix: pattern

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 9648d9af..48577a0a 100644
--- a/package.json
+++ b/package.json
@@ -6,12 +6,12 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "c8 --100 --reporter=html node --test test/*.test.js",
+    "coverage": "c8 --100 --reporter=html node --test test/static.test.js test/dir-list.test.js test/content-type.test.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "c8 --100 node --test test/*.test.js",
+    "test:unit": "c8 --100 node --test test/static.test.js test/dir-list.test.js test/content-type.test.js",
     "example": "node example/server.js"
   },
   "repository": {

From 5950937ec374a62d822514098fec430622596a21 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Thu, 9 Jan 2025 18:38:06 +0100
Subject: [PATCH 90/93] chore: switch to borp

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 48577a0a..3caeeba3 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "c8 --100 node --test test/static.test.js test/dir-list.test.js test/content-type.test.js",
+    "test:unit": "borp -C",
     "example": "node example/server.js"
   },
   "repository": {
@@ -69,7 +69,7 @@
     "@fastify/compress": "^8.0.0",
     "@fastify/pre-commit": "^2.1.0",
     "@types/node": "^22.0.0",
-    "c8": "^10.1.3",
+    "borp": "^0.19.0",
     "concat-stream": "^2.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.1.0",

From d1ec8d7d51dbfe3956322dba99a2cc61127a3722 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Thu, 9 Jan 2025 19:17:06 +0100
Subject: [PATCH 91/93] Update package.json

Co-authored-by: Dan Castillo <dan.castillo@jasper.ai>
Signed-off-by: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 3caeeba3..250113c6 100644
--- a/package.json
+++ b/package.json
@@ -6,7 +6,7 @@
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "coverage": "c8 --100 --reporter=html node --test test/static.test.js test/dir-list.test.js test/content-type.test.js",
+    "coverage": "c8 --reporter html borp --coverage --check-coverage --lines 100",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",

From 872c7f9b9d8b298ccf3fbde110b3d254e0acdc26 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Thu, 9 Jan 2025 19:17:16 +0100
Subject: [PATCH 92/93] Update package.json

Co-authored-by: Dan Castillo <dan.castillo@jasper.ai>
Signed-off-by: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 250113c6..2f82997f 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
-    "test:unit": "borp -C",
+    "test:unit": "borp -C --check-coverage --lines 100",
     "example": "node example/server.js"
   },
   "repository": {

From 0778ae2912d6748fcff9dcfc0aa503b765d14198 Mon Sep 17 00:00:00 2001
From: Matteo Pietro Dazzi <matteopietro.dazzi@gmail.com>
Date: Fri, 10 Jan 2025 12:55:21 +0100
Subject: [PATCH 93/93] chore: c8

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index 2f82997f..237869b0 100644
--- a/package.json
+++ b/package.json
@@ -70,6 +70,7 @@
     "@fastify/pre-commit": "^2.1.0",
     "@types/node": "^22.0.0",
     "borp": "^0.19.0",
+    "c8": "^10.1.3",
     "concat-stream": "^2.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.1.0",