@fastify/compress 8.0.0-pre.fv5.2 → 8.0.0

package/test/global-decompress.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test, describe } = require('node:test')
 const { createReadStream } = require('node:fs')
 const path = require('node:path')
 const zlib = require('node:zlib')
@@ -18,8 +18,8 @@ function createPayload (compressor) {
   return payload
 }
 
-test('It should decompress the request payload :', async (t) => {
-  t.test('using brotli algorithm when `Content-Encoding` request header value is set to `br`', async (t) => {
+describe('It should decompress the request payload :', async () => {
+  test('using brotli algorithm when `Content-Encoding` request header value is set to `br`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -38,11 +38,11 @@ test('It should decompress the request payload :', async (t) => {
       },
       payload: createPayload(zlib.createBrotliCompress)
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 
-  t.test('using deflate algorithm when `Content-Encoding` request header value is set to `deflate`', async (t) => {
+  test('using deflate algorithm when `Content-Encoding` request header value is set to `deflate`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -61,11 +61,11 @@ test('It should decompress the request payload :', async (t) => {
       },
       payload: createPayload(zlib.createDeflate)
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 
-  t.test('using gzip algorithm when `Content-Encoding` request header value is set to `gzip`', async (t) => {
+  test('using gzip algorithm when `Content-Encoding` request header value is set to `gzip`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -84,11 +84,11 @@ test('It should decompress the request payload :', async (t) => {
       },
       payload: createPayload(zlib.createGzip)
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 
-  t.test('using the `forceRequestEncoding` provided algorithm over the `Content-Encoding` request header value', async (t) => {
+  test('using the `forceRequestEncoding` provided algorithm over the `Content-Encoding` request header value', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -107,13 +107,13 @@ test('It should decompress the request payload :', async (t) => {
       },
       payload: createPayload(zlib.createGzip)
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 })
 
-test('It should not decompress :', async (t) => {
-  t.test('when `Content-Encoding` request header is missing', async (t) => {
+describe('It should not decompress :', async () => {
+  test('when `Content-Encoding` request header is missing', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -131,11 +131,11 @@ test('It should not decompress :', async (t) => {
       },
       payload: createPayload()
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 
-  t.test('when `Content-Encoding` request header value is set to `identity`', async (t) => {
+  test('when `Content-Encoding` request header value is set to `identity`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -154,13 +154,13 @@ test('It should not decompress :', async (t) => {
       },
       payload: createPayload()
     })
-    t.equal(response.statusCode, 200)
-    t.equal(response.body, '@fastify/compress')
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
   })
 })
 
-test('It should return an error :', async (t) => {
-  t.test('when `Content-Encoding` request header value is not supported', async (t) => {
+describe('It should return an error :', async () => {
+  test('when `Content-Encoding` request header value is not supported', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -179,8 +179,8 @@ test('It should return an error :', async (t) => {
       },
       payload: createPayload(zlib.createDeflate)
     })
-    t.equal(response.statusCode, 415)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 415)
+    t.assert.deepEqual(response.json(), {
       statusCode: 415,
       code: 'FST_CP_ERR_INVALID_CONTENT_ENCODING',
       error: 'Unsupported Media Type',
@@ -188,7 +188,7 @@ test('It should return an error :', async (t) => {
     })
   })
 
-  t.test('when `Content-Encoding` request header value is disabled by the `requestEncodings` option', async (t) => {
+  test('when `Content-Encoding` request header value is disabled by the `requestEncodings` option', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -207,8 +207,8 @@ test('It should return an error :', async (t) => {
       },
       payload: createPayload(zlib.createDeflate)
     })
-    t.equal(response.statusCode, 415)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 415)
+    t.assert.deepEqual(response.json(), {
       statusCode: 415,
       code: 'FST_CP_ERR_INVALID_CONTENT_ENCODING',
       error: 'Unsupported Media Type',
@@ -216,7 +216,7 @@ test('It should return an error :', async (t) => {
     })
   })
 
-  t.test('when the compressed payload is invalid according to `Content-Encoding` request header value', async (t) => {
+  test('when the compressed payload is invalid according to `Content-Encoding` request header value', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -235,8 +235,8 @@ test('It should return an error :', async (t) => {
       },
       payload: createPayload(zlib.createGzip)
     })
-    t.equal(response.statusCode, 400)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 400)
+    t.assert.deepEqual(response.json(), {
       statusCode: 400,
       code: 'FST_CP_ERR_INVALID_CONTENT',
       error: 'Bad Request',
@@ -245,8 +245,8 @@ test('It should return an error :', async (t) => {
   })
 })
 
-test('It should return the error returned by :', async (t) => {
-  t.test('`onUnsupportedRequestEncoding`', async (t) => {
+describe('It should return the error returned by :', async () => {
+  test('`onUnsupportedRequestEncoding`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -274,8 +274,8 @@ test('It should return the error returned by :', async (t) => {
       },
       payload: createPayload(zlib.createDeflate)
     })
-    t.equal(response.statusCode, 400)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 400)
+    t.assert.deepEqual(response.json(), {
       statusCode: 400,
       code: 'INVALID',
       error: 'Bad Request',
@@ -283,7 +283,7 @@ test('It should return the error returned by :', async (t) => {
     })
   })
 
-  t.test('`onInvalidRequestPayload`', async (t) => {
+  test('`onInvalidRequestPayload`', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -311,8 +311,8 @@ test('It should return the error returned by :', async (t) => {
       },
       payload: createPayload(zlib.createGzip)
     })
-    t.equal(response.statusCode, 400)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 400)
+    t.assert.deepEqual(response.json(), {
       statusCode: 400,
       code: 'INVALID',
       error: 'Bad Request',
@@ -321,8 +321,8 @@ test('It should return the error returned by :', async (t) => {
   })
 })
 
-test('It should return the default error :', async (t) => {
-  t.test('when `onUnsupportedRequestEncoding` throws', async (t) => {
+describe('It should return the default error :', async () => {
+  test('when `onUnsupportedRequestEncoding` throws', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -345,8 +345,8 @@ test('It should return the default error :', async (t) => {
       },
       payload: createPayload(zlib.createDeflate)
     })
-    t.equal(response.statusCode, 415)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 415)
+    t.assert.deepEqual(response.json(), {
       statusCode: 415,
       code: 'FST_CP_ERR_INVALID_CONTENT_ENCODING',
       error: 'Unsupported Media Type',
@@ -354,7 +354,7 @@ test('It should return the default error :', async (t) => {
     })
   })
 
-  t.test('when `onInvalidRequestPayload` throws', async (t) => {
+  test('when `onInvalidRequestPayload` throws', async (t) => {
     t.plan(2)
 
     const fastify = Fastify()
@@ -377,8 +377,8 @@ test('It should return the default error :', async (t) => {
       },
       payload: createPayload(zlib.createGzip)
     })
-    t.equal(response.statusCode, 400)
-    t.strictSame(response.json(), {
+    t.assert.equal(response.statusCode, 400)
+    t.assert.deepEqual(response.json(), {
       statusCode: 400,
       code: 'FST_CP_ERR_INVALID_CONTENT',
       error: 'Bad Request',
@@ -387,37 +387,47 @@ test('It should return the default error :', async (t) => {
   })
 })
 
-test('It should validate `requestEncodings` option', (t) => {
+test('It should validate `requestEncodings` option', async (t) => {
   t.plan(1)
 
   const fastify = Fastify()
   fastify.register(compressPlugin, { requestEncodings: [] })
-
-  fastify.ready((err) => {
-    t.equal(err.message, 'The `requestEncodings` option array must have at least 1 item.')
-  })
+  t.assert.rejects(
+    async () => fastify.ready(),
+    {
+      name: 'Error',
+      message: 'The `requestEncodings` option array must have at least 1 item.'
+    }
+  )
 })
 
-test('It should make sure that at least one encoding value is supported :', async (t) => {
-  t.test('when setting `requestEncodings`', (t) => {
+describe('It should make sure that at least one encoding value is supported :', async () => {
+  test('when setting `requestEncodings`', async (t) => {
     t.plan(1)
 
     const fastify = Fastify()
     fastify.register(compressPlugin, { requestEncodings: ['whatever'] })
 
-    fastify.ready((err) => {
-      t.equal(err.message, 'None of the passed `requestEncodings` were supported — request decompression not possible.')
-    })
+    t.assert.rejects(
+      async () => fastify.ready(),
+      {
+        name: 'Error',
+        message: 'None of the passed `requestEncodings` were supported — request decompression not possible.'
+      }
+    )
   })
 
-  t.test('when setting `forceRequestEncodings`', (t) => {
+  test('when setting `forceRequestEncodings`', async (t) => {
     t.plan(1)
 
     const fastify = Fastify()
     fastify.register(compressPlugin, { forceRequestEncoding: ['whatever'] })
-
-    fastify.ready((err) => {
-      t.equal(err.message, 'Unsupported decompression encoding whatever.')
-    })
+    t.assert.rejects(
+      async () => fastify.ready(),
+      {
+        name: 'Error',
+        message: 'Unsupported decompression encoding whatever.'
+      }
+    )
   })
 })

package/test/regression/issue-288.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const fastifyCompress = require('../..')
 const { request } = require('node:http')
@@ -35,7 +35,7 @@ test('should not corrupt the file content', async (t) => {
     })
     .join('\n')
   const fastify = new Fastify()
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.register(async (instance, opts) => {
     await fastify.register(fastifyCompress)
@@ -57,6 +57,6 @@ test('should not corrupt the file content', async (t) => {
     fetch(`${address}/no-compress`)
   ])
 
-  t.equal(body1, body2)
-  t.equal(body1, twoByteUnicodeContent)
+  t.assert.equal(body1, body2)
+  t.assert.equal(body1, twoByteUnicodeContent)
 })

package/test/routes-compress.test.js

@@ -1,14 +1,15 @@
 'use strict'
 
-const { test } = require('tap')
+const { test, describe } = require('node:test')
 const { createReadStream, readFile, readFileSync } = require('node:fs')
 const zlib = require('node:zlib')
 const Fastify = require('fastify')
 const compressPlugin = require('../index')
 
-test('When using routes `compress` settings :', async (t) => {
-  t.test('it should compress data using the route custom provided `createDeflate` method', async (t) => {
+describe('When using routes `compress` settings :', async (t) => {
+  test('it should compress data using the route custom provided `createDeflate` method', async (t) => {
     t.plan(12)
+    const equal = t.assert.equal
 
     let usedCustomGlobal = false
     let usedCustom = false
@@ -39,15 +40,15 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'deflate'
       }
     }).then((response) => {
-      t.equal(usedCustom, false)
-      t.equal(usedCustomGlobal, true)
+      equal(usedCustom, false)
+      equal(usedCustomGlobal, true)
 
       const file = readFileSync('./package.json', 'utf8')
       const payload = zlib.inflateSync(response.rawPayload)
-      t.equal(response.headers.vary, 'accept-encoding')
-      t.equal(response.headers['content-encoding'], 'deflate')
-      t.notOk(response.headers['content-length'], 'no content length')
-      t.equal(payload.toString('utf-8'), file)
+      equal(response.headers.vary, 'accept-encoding')
+      equal(response.headers['content-encoding'], 'deflate')
+      t.assert.ok(!response.headers['content-length'], 'no content length')
+      equal(payload.toString('utf-8'), file)
 
       usedCustom = false
       usedCustomGlobal = false
@@ -60,19 +61,20 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'deflate'
       }
     })
-    t.equal(usedCustom, true)
-    t.equal(usedCustomGlobal, false)
+    equal(usedCustom, true)
+    equal(usedCustomGlobal, false)
 
     const file = readFileSync('./package.json', 'utf8')
     const payload = zlib.inflateSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'deflate')
-    t.notOk(response.headers['content-length'], 'no content length')
-    t.equal(payload.toString('utf-8'), file)
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'deflate')
+    t.assert.ok(!response.headers['content-length'], 'no content length')
+    equal(payload.toString('utf-8'), file)
   })
 
-  t.test('it should compress data using the route custom provided `createGzip` method', async (t) => {
+  test('it should compress data using the route custom provided `createGzip` method', async (t) => {
     t.plan(10)
+    const equal = t.assert.equal
 
     let usedCustomGlobal = false
     let usedCustom = false
@@ -101,14 +103,14 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'gzip'
       }
     }).then((response) => {
-      t.equal(usedCustom, false)
-      t.equal(usedCustomGlobal, true)
+      equal(usedCustom, false)
+      equal(usedCustomGlobal, true)
 
       const file = readFileSync('./package.json', 'utf8')
       const payload = zlib.gunzipSync(response.rawPayload)
-      t.equal(response.headers.vary, 'accept-encoding')
-      t.equal(response.headers['content-encoding'], 'gzip')
-      t.equal(payload.toString('utf-8'), file)
+      equal(response.headers.vary, 'accept-encoding')
+      equal(response.headers['content-encoding'], 'gzip')
+      equal(payload.toString('utf-8'), file)
 
       usedCustom = false
       usedCustomGlobal = false
@@ -121,18 +123,19 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'gzip'
       }
     })
-    t.equal(usedCustom, true)
-    t.equal(usedCustomGlobal, false)
+    equal(usedCustom, true)
+    equal(usedCustomGlobal, false)
 
     const file = readFileSync('./package.json', 'utf8')
     const payload = zlib.gunzipSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(payload.toString('utf-8'), file)
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'gzip')
+    equal(payload.toString('utf-8'), file)
   })
 
-  t.test('it should not compress data when `global` is `false` unless `compress` routes settings have been set up', async (t) => {
+  test('it should not compress data when `global` is `false` unless `compress` routes settings have been set up', async (t) => {
     t.plan(12)
+    const equal = t.assert.equal
 
     let usedCustom = false
     const customZlib = { createGzip: () => (usedCustom = true) && zlib.createGzip() }
@@ -142,7 +145,7 @@ test('When using routes `compress` settings :', async (t) => {
 
     fastify.get('/', (request, reply) => {
       // compress function should still be available
-      t.type(reply.compress, 'function')
+      t.assert.ok(typeof reply.compress === 'function')
 
       reply.send({ foo: 1 })
     })
@@ -168,10 +171,10 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'gzip'
       }
     }).then((response) => {
-      t.equal(usedCustom, false)
-      t.notOk(response.headers.vary)
-      t.notOk(response.headers['content-encoding'])
-      t.equal(response.rawPayload.toString('utf-8'), JSON.stringify({ foo: 1 }))
+      t.assert.equal(usedCustom, false)
+      t.assert.ok(!response.headers.vary)
+      t.assert.ok(!response.headers['content-encoding'])
+      t.assert.equal(response.rawPayload.toString('utf-8'), JSON.stringify({ foo: 1 }))
 
       usedCustom = false
     })
@@ -183,13 +186,13 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'gzip'
       }
     }).then((response) => {
-      t.equal(usedCustom, true)
+      equal(usedCustom, true)
 
       const file = readFileSync('./package.json', 'utf8')
       const payload = zlib.gunzipSync(response.rawPayload)
-      t.equal(response.headers.vary, 'accept-encoding')
-      t.equal(response.headers['content-encoding'], 'gzip')
-      t.equal(payload.toString('utf-8'), file)
+      equal(response.headers.vary, 'accept-encoding')
+      equal(response.headers['content-encoding'], 'gzip')
+      equal(payload.toString('utf-8'), file)
     })
 
     const response = await fastify.inject({
@@ -200,14 +203,14 @@ test('When using routes `compress` settings :', async (t) => {
       }
     })
     const payload = zlib.gunzipSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(payload.toString('utf-8'), JSON.stringify({ foo: 1 }))
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'gzip')
+    equal(payload.toString('utf-8'), JSON.stringify({ foo: 1 }))
   })
 
-  t.test('it should not compress data when route `compress` option is set to `false`', async (t) => {
+  test('it should not compress data when route `compress` option is set to `false`', async (t) => {
     t.plan(3)
-
+    const equal = t.assert.equal
     const content = { message: 'Hello World!' }
 
     const fastify = Fastify()
@@ -226,13 +229,15 @@ test('When using routes `compress` settings :', async (t) => {
         'accept-encoding': 'gzip'
       }
     })
-    t.notOk(response.headers.vary)
-    t.notOk(response.headers['content-encoding'])
-    t.equal(response.rawPayload.toString('utf-8'), JSON.stringify(content))
+
+    t.assert.ok(!response.headers.vary)
+    t.assert.ok(!response.headers['content-encoding'])
+    equal(response.rawPayload.toString('utf-8'), JSON.stringify(content))
   })
 
-  t.test('it should throw an error on invalid route `compress` settings', async (t) => {
+  test('it should throw an error on invalid route `compress` settings', async (t) => {
     t.plan(1)
+    const equal = t.assert.equal
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
@@ -244,14 +249,15 @@ test('When using routes `compress` settings :', async (t) => {
         reply.send('')
       })
     } catch (err) {
-      t.equal(err.message, 'Unknown value for route compress configuration')
+      equal(err.message, 'Unknown value for route compress configuration')
     }
   })
 })
 
-test('When `compress.removeContentLengthHeader` is `false`, it should not remove `Content-Length` header :', async (t) => {
-  t.test('using `reply.compress()`', async (t) => {
+describe('When `compress.removeContentLengthHeader` is `false`, it should not remove `Content-Length` header :', async () => {
+  test('using `reply.compress()`', async (t) => {
     t.plan(4)
+    const equal = t.assert.equal
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: true })
@@ -280,14 +286,15 @@ test('When `compress.removeContentLengthHeader` is `false`, it should not remove
     })
     const file = readFileSync('./package.json', 'utf8')
     const payload = zlib.inflateSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'deflate')
-    t.equal(response.headers['content-length'], payload.length.toString())
-    t.equal(payload.toString('utf-8'), file)
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'deflate')
+    equal(response.headers['content-length'], payload.length.toString())
+    equal(payload.toString('utf-8'), file)
   })
 
-  t.test('using `onSend` hook', async (t) => {
+  test('using `onSend` hook', async (t) => {
     t.plan(4)
+    const equal = t.assert.equal
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: true })
@@ -316,16 +323,17 @@ test('When `compress.removeContentLengthHeader` is `false`, it should not remove
     })
     const file = readFileSync('./package.json', 'utf8')
     const payload = zlib.inflateSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'deflate')
-    t.equal(response.headers['content-length'], payload.length.toString())
-    t.equal(payload.toString('utf-8'), file)
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'deflate')
+    equal(response.headers['content-length'], payload.length.toString())
+    equal(payload.toString('utf-8'), file)
   })
 })
 
-test('When using the old routes `{ config: compress }` option :', async (t) => {
-  t.test('it should compress data using the route custom provided `createGzip` method', async (t) => {
+describe('When using the old routes `{ config: compress }` option :', async () => {
+  test('it should compress data using the route custom provided `createGzip` method', async (t) => {
     t.plan(10)
+    const equal = t.assert.equal
 
     let usedCustomGlobal = false
     let usedCustom = false
@@ -358,14 +366,14 @@ test('When using the old routes `{ config: compress }` option :', async (t) => {
         'accept-encoding': 'gzip'
       }
     }).then((response) => {
-      t.equal(usedCustom, false)
-      t.equal(usedCustomGlobal, true)
+      equal(usedCustom, false)
+      equal(usedCustomGlobal, true)
 
       const file = readFileSync('./package.json', 'utf8')
       const payload = zlib.gunzipSync(response.rawPayload)
-      t.equal(response.headers.vary, 'accept-encoding')
-      t.equal(response.headers['content-encoding'], 'gzip')
-      t.equal(payload.toString('utf-8'), file)
+      equal(response.headers.vary, 'accept-encoding')
+      equal(response.headers['content-encoding'], 'gzip')
+      equal(payload.toString('utf-8'), file)
 
       usedCustom = false
       usedCustomGlobal = false
@@ -378,17 +386,17 @@ test('When using the old routes `{ config: compress }` option :', async (t) => {
         'accept-encoding': 'gzip'
       }
     })
-    t.equal(usedCustom, true)
-    t.equal(usedCustomGlobal, false)
+    equal(usedCustom, true)
+    equal(usedCustomGlobal, false)
 
     const file = readFileSync('./package.json', 'utf8')
     const payload = zlib.gunzipSync(response.rawPayload)
-    t.equal(response.headers.vary, 'accept-encoding')
-    t.equal(response.headers['content-encoding'], 'gzip')
-    t.equal(payload.toString('utf-8'), file)
+    equal(response.headers.vary, 'accept-encoding')
+    equal(response.headers['content-encoding'], 'gzip')
+    equal(payload.toString('utf-8'), file)
   })
 
-  t.test('it should use the old routes `{ config: compress }` options over routes `compress` options', async (t) => {
+  test('it should use the old routes `{ config: compress }` options over routes `compress` options', async (t) => {
     t.plan(1)
 
     const fastify = Fastify()
@@ -406,7 +414,7 @@ test('When using the old routes `{ config: compress }` option :', async (t) => {
         reply.send('')
       })
     } catch (err) {
-      t.equal(err.message, 'Unknown value for route compress configuration')
+      t.assert.equal(err.message, 'Unknown value for route compress configuration')
     }
   })
 })
@@ -430,5 +438,5 @@ test('It should avoid to trigger `onSend` hook twice', async (t) => {
       'accept-encoding': 'br'
     }
   })
-  t.same(JSON.parse(zlib.brotliDecompressSync(response.rawPayload)), { hi: true })
+  t.assert.deepEqual(JSON.parse(zlib.brotliDecompressSync(response.rawPayload)), { hi: true })
 })