fastify 5.0.0 → 5.1.0

package/test/internals/hooks.test.js

@@ -1,54 +1,50 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
-
+const { test } = require('node:test')
 const { Hooks } = require('../../lib/hooks')
 const noop = () => {}
 
 test('hooks should have 4 array with the registered hooks', t => {
   const hooks = new Hooks()
-  t.equal(typeof hooks, 'object')
-  t.ok(Array.isArray(hooks.onRequest))
-  t.ok(Array.isArray(hooks.onSend))
-  t.ok(Array.isArray(hooks.preParsing))
-  t.ok(Array.isArray(hooks.preValidation))
-  t.ok(Array.isArray(hooks.preHandler))
-  t.ok(Array.isArray(hooks.onResponse))
-  t.ok(Array.isArray(hooks.onError))
-  t.end()
+  t.assert.strictEqual(typeof hooks, 'object')
+  t.assert.ok(Array.isArray(hooks.onRequest))
+  t.assert.ok(Array.isArray(hooks.onSend))
+  t.assert.ok(Array.isArray(hooks.preParsing))
+  t.assert.ok(Array.isArray(hooks.preValidation))
+  t.assert.ok(Array.isArray(hooks.preHandler))
+  t.assert.ok(Array.isArray(hooks.onResponse))
+  t.assert.ok(Array.isArray(hooks.onError))
 })
 
 test('hooks.add should add a hook to the given hook', t => {
   const hooks = new Hooks()
   hooks.add('onRequest', noop)
-  t.equal(hooks.onRequest.length, 1)
-  t.equal(typeof hooks.onRequest[0], 'function')
+  t.assert.strictEqual(hooks.onRequest.length, 1)
+  t.assert.strictEqual(typeof hooks.onRequest[0], 'function')
 
   hooks.add('preParsing', noop)
-  t.equal(hooks.preParsing.length, 1)
-  t.equal(typeof hooks.preParsing[0], 'function')
+  t.assert.strictEqual(hooks.preParsing.length, 1)
+  t.assert.strictEqual(typeof hooks.preParsing[0], 'function')
 
   hooks.add('preValidation', noop)
-  t.equal(hooks.preValidation.length, 1)
-  t.equal(typeof hooks.preValidation[0], 'function')
+  t.assert.strictEqual(hooks.preValidation.length, 1)
+  t.assert.strictEqual(typeof hooks.preValidation[0], 'function')
 
   hooks.add('preHandler', noop)
-  t.equal(hooks.preHandler.length, 1)
-  t.equal(typeof hooks.preHandler[0], 'function')
+  t.assert.strictEqual(hooks.preHandler.length, 1)
+  t.assert.strictEqual(typeof hooks.preHandler[0], 'function')
 
   hooks.add('onResponse', noop)
-  t.equal(hooks.onResponse.length, 1)
-  t.equal(typeof hooks.onResponse[0], 'function')
+  t.assert.strictEqual(hooks.onResponse.length, 1)
+  t.assert.strictEqual(typeof hooks.onResponse[0], 'function')
 
   hooks.add('onSend', noop)
-  t.equal(hooks.onSend.length, 1)
-  t.equal(typeof hooks.onSend[0], 'function')
+  t.assert.strictEqual(hooks.onSend.length, 1)
+  t.assert.strictEqual(typeof hooks.onSend[0], 'function')
 
   hooks.add('onError', noop)
-  t.equal(hooks.onError.length, 1)
-  t.equal(typeof hooks.onError[0], 'function')
-  t.end()
+  t.assert.strictEqual(hooks.onError.length, 1)
+  t.assert.strictEqual(typeof hooks.onError[0], 'function')
 })
 
 test('hooks should throw on unexisting handler', t => {
@@ -56,9 +52,9 @@ test('hooks should throw on unexisting handler', t => {
   const hooks = new Hooks()
   try {
     hooks.add('onUnexistingHook', noop)
-    t.fail()
+    t.assert.fail()
   } catch (e) {
-    t.pass()
+    t.assert.ok(true)
   }
 })
 
@@ -67,17 +63,17 @@ test('should throw on wrong parameters', t => {
   t.plan(4)
   try {
     hooks.add(null, () => {})
-    t.fail()
+    t.assert.fail()
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_HOOK_INVALID_TYPE')
-    t.equal(e.message, 'The hook name must be a string')
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_TYPE')
+    t.assert.strictEqual(e.message, 'The hook name must be a string')
   }
 
   try {
     hooks.add('onSend', null)
-    t.fail()
+    t.assert.fail()
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
-    t.equal(e.message, 'onSend hook should be a function, instead got [object Null]')
+    t.assert.strictEqual(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
+    t.assert.strictEqual(e.message, 'onSend hook should be a function, instead got [object Null]')
   }
 })

package/test/internals/initialConfig.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('../..')
 const helper = require('../helper')
 const http = require('node:http')
@@ -23,7 +23,7 @@ before(async function () {
 
 test('Fastify.initialConfig is an object', t => {
   t.plan(1)
-  t.type(Fastify().initialConfig, 'object')
+  t.assert.ok(typeof Fastify().initialConfig === 'object')
 })
 
 test('without options passed to Fastify, initialConfig should expose default values', t => {
@@ -51,7 +51,7 @@ test('without options passed to Fastify, initialConfig should expose default val
     useSemicolonDelimiter: false
   }
 
-  t.same(Fastify().initialConfig, fastifyDefaultOptions)
+  t.assert.deepStrictEqual(Fastify().initialConfig, fastifyDefaultOptions)
 })
 
 test('Fastify.initialConfig should expose all options', t => {
@@ -114,30 +114,30 @@ test('Fastify.initialConfig should expose all options', t => {
   }
 
   const fastify = Fastify(options)
-  t.equal(fastify.initialConfig.http2, true)
-  t.equal(fastify.initialConfig.https, true, 'for security reason the key cert is hidden')
-  t.equal(fastify.initialConfig.ignoreTrailingSlash, true)
-  t.equal(fastify.initialConfig.ignoreDuplicateSlashes, true)
-  t.equal(fastify.initialConfig.maxParamLength, 200)
-  t.equal(fastify.initialConfig.connectionTimeout, 0)
-  t.equal(fastify.initialConfig.keepAliveTimeout, 72000)
-  t.equal(fastify.initialConfig.bodyLimit, 1049600)
-  t.equal(fastify.initialConfig.onProtoPoisoning, 'remove')
-  t.equal(fastify.initialConfig.caseSensitive, true)
-  t.equal(fastify.initialConfig.useSemicolonDelimiter, false)
-  t.equal(fastify.initialConfig.allowUnsafeRegex, false)
-  t.equal(fastify.initialConfig.requestIdHeader, 'request-id-alt')
-  t.equal(fastify.initialConfig.pluginTimeout, 20000)
-  t.ok(fastify.initialConfig.constraints.version)
+  t.assert.strictEqual(fastify.initialConfig.http2, true)
+  t.assert.strictEqual(fastify.initialConfig.https, true, 'for security reason the key cert is hidden')
+  t.assert.strictEqual(fastify.initialConfig.ignoreTrailingSlash, true)
+  t.assert.strictEqual(fastify.initialConfig.ignoreDuplicateSlashes, true)
+  t.assert.strictEqual(fastify.initialConfig.maxParamLength, 200)
+  t.assert.strictEqual(fastify.initialConfig.connectionTimeout, 0)
+  t.assert.strictEqual(fastify.initialConfig.keepAliveTimeout, 72000)
+  t.assert.strictEqual(fastify.initialConfig.bodyLimit, 1049600)
+  t.assert.strictEqual(fastify.initialConfig.onProtoPoisoning, 'remove')
+  t.assert.strictEqual(fastify.initialConfig.caseSensitive, true)
+  t.assert.strictEqual(fastify.initialConfig.useSemicolonDelimiter, false)
+  t.assert.strictEqual(fastify.initialConfig.allowUnsafeRegex, false)
+  t.assert.strictEqual(fastify.initialConfig.requestIdHeader, 'request-id-alt')
+  t.assert.strictEqual(fastify.initialConfig.pluginTimeout, 20000)
+  t.assert.ok(fastify.initialConfig.constraints.version)
 
   // obfuscated options:
-  t.equal(fastify.initialConfig.serverFactory, undefined)
-  t.equal(fastify.initialConfig.trustProxy, undefined)
-  t.equal(fastify.initialConfig.genReqId, undefined)
-  t.equal(fastify.initialConfig.childLoggerFactory, undefined)
-  t.equal(fastify.initialConfig.querystringParser, undefined)
-  t.equal(fastify.initialConfig.logger, undefined)
-  t.equal(fastify.initialConfig.trustProxy, undefined)
+  t.assert.strictEqual(fastify.initialConfig.serverFactory, undefined)
+  t.assert.strictEqual(fastify.initialConfig.trustProxy, undefined)
+  t.assert.strictEqual(fastify.initialConfig.genReqId, undefined)
+  t.assert.strictEqual(fastify.initialConfig.childLoggerFactory, undefined)
+  t.assert.strictEqual(fastify.initialConfig.querystringParser, undefined)
+  t.assert.strictEqual(fastify.initialConfig.logger, undefined)
+  t.assert.strictEqual(fastify.initialConfig.trustProxy, undefined)
 })
 
 test('Should throw if you try to modify Fastify.initialConfig', t => {
@@ -146,12 +146,12 @@ test('Should throw if you try to modify Fastify.initialConfig', t => {
   const fastify = Fastify({ ignoreTrailingSlash: true })
   try {
     fastify.initialConfig.ignoreTrailingSlash = false
-    t.fail()
+    t.assert.fail()
   } catch (error) {
-    t.type(error, TypeError)
-    t.equal(error.message, "Cannot assign to read only property 'ignoreTrailingSlash' of object '#<Object>'")
-    t.ok(error.stack)
-    t.pass()
+    t.assert.ok(error instanceof TypeError)
+    t.assert.strictEqual(error.message, "Cannot assign to read only property 'ignoreTrailingSlash' of object '#<Object>'")
+    t.assert.ok(error.stack)
+    t.assert.ok(true)
   }
 })
 
@@ -168,12 +168,12 @@ test('We must avoid shallow freezing and ensure that the whole object is freezed
 
   try {
     fastify.initialConfig.https.allowHTTP1 = false
-    t.fail()
+    t.assert.fail()
   } catch (error) {
-    t.type(error, TypeError)
-    t.equal(error.message, "Cannot assign to read only property 'allowHTTP1' of object '#<Object>'")
-    t.ok(error.stack)
-    t.same(fastify.initialConfig.https, {
+    t.assert.ok(error instanceof TypeError)
+    t.assert.strictEqual(error.message, "Cannot assign to read only property 'allowHTTP1' of object '#<Object>'")
+    t.assert.ok(error.stack)
+    t.assert.deepStrictEqual(fastify.initialConfig.https, {
       allowHTTP1: true
     }, 'key cert removed')
   }
@@ -183,7 +183,7 @@ test('https value check', t => {
   t.plan(1)
 
   const fastify = Fastify({})
-  t.notOk(fastify.initialConfig.https)
+  t.assert.ok(!fastify.initialConfig.https)
 })
 
 test('Return an error if options do not match the validation schema', t => {
@@ -192,14 +192,14 @@ test('Return an error if options do not match the validation schema', t => {
   try {
     Fastify({ ignoreTrailingSlash: 'string instead of boolean' })
 
-    t.fail()
+    t.assert.fail()
   } catch (error) {
-    t.type(error, Error)
-    t.equal(error.name, 'FastifyError')
-    t.equal(error.message, 'Invalid initialization options: \'["must be boolean"]\'')
-    t.equal(error.code, 'FST_ERR_INIT_OPTS_INVALID')
-    t.ok(error.stack)
-    t.pass()
+    t.assert.ok(error instanceof Error)
+    t.assert.strictEqual(error.name, 'FastifyError')
+    t.assert.strictEqual(error.message, 'Invalid initialization options: \'["must be boolean"]\'')
+    t.assert.strictEqual(error.code, 'FST_ERR_INIT_OPTS_INVALID')
+    t.assert.ok(error.stack)
+    t.assert.ok(true)
   }
 })
 
@@ -216,10 +216,10 @@ test('Original options must not be frozen', t => {
 
   const fastify = Fastify(originalOptions)
 
-  t.equal(Object.isFrozen(originalOptions), false)
-  t.equal(Object.isFrozen(originalOptions.https), false)
-  t.equal(Object.isFrozen(fastify.initialConfig), true)
-  t.equal(Object.isFrozen(fastify.initialConfig.https), true)
+  t.assert.strictEqual(Object.isFrozen(originalOptions), false)
+  t.assert.strictEqual(Object.isFrozen(originalOptions.https), false)
+  t.assert.strictEqual(Object.isFrozen(fastify.initialConfig), true)
+  t.assert.strictEqual(Object.isFrozen(fastify.initialConfig.https), true)
 })
 
 test('Original options must not be altered (test deep cloning)', t => {
@@ -238,14 +238,14 @@ test('Original options must not be altered (test deep cloning)', t => {
   const fastify = Fastify(originalOptions)
 
   // initialConfig has been triggered
-  t.equal(Object.isFrozen(fastify.initialConfig), true)
+  t.assert.strictEqual(Object.isFrozen(fastify.initialConfig), true)
 
   // originalOptions must not have been altered
-  t.same(originalOptions.https.key, originalOptionsClone.https.key)
-  t.same(originalOptions.https.cert, originalOptionsClone.https.cert)
+  t.assert.deepStrictEqual(originalOptions.https.key, originalOptionsClone.https.key)
+  t.assert.deepStrictEqual(originalOptions.https.cert, originalOptionsClone.https.cert)
 })
 
-test('Should not have issues when passing stream options to Pino.js', t => {
+test('Should not have issues when passing stream options to Pino.js', (t, done) => {
   t.plan(17)
 
   const stream = split(JSON.parse)
@@ -267,8 +267,8 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       return logger.child(bindings, opts)
     })
 
-    t.type(fastify, 'object')
-    t.same(fastify.initialConfig, {
+    t.assert.ok(typeof fastify === 'object')
+    t.assert.deepStrictEqual(fastify.initialConfig, {
       connectionTimeout: 0,
       keepAliveTimeout: 72000,
       maxRequestsPerSocket: 0,
@@ -290,42 +290,44 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       useSemicolonDelimiter: false
     })
   } catch (error) {
-    t.fail()
+    t.assert.fail()
   }
 
   fastify.get('/', function (req, reply) {
-    t.ok(req.log)
+    t.assert.ok(req.log)
     reply.send({ hello: 'world' })
   })
 
   stream.once('data', listenAtLogLine => {
-    t.ok(listenAtLogLine, 'listen at log message is ok')
+    t.assert.ok(listenAtLogLine, 'listen at log message is ok')
 
     stream.once('data', line => {
       const id = line.reqId
-      t.ok(line.reqId, 'reqId is defined')
-      t.equal(line.someBinding, 'value', 'child logger binding is set')
-      t.ok(line.req, 'req is defined')
-      t.equal(line.msg, 'incoming request', 'message is set')
-      t.equal(line.req.method, 'GET', 'method is get')
+      t.assert.ok(line.reqId, 'reqId is defined')
+      t.assert.strictEqual(line.someBinding, 'value', 'child logger binding is set')
+      t.assert.ok(line.req, 'req is defined')
+      t.assert.strictEqual(line.msg, 'incoming request', 'message is set')
+      t.assert.strictEqual(line.req.method, 'GET', 'method is get')
 
       stream.once('data', line => {
-        t.equal(line.reqId, id)
-        t.ok(line.reqId, 'reqId is defined')
-        t.equal(line.someBinding, 'value', 'child logger binding is set')
-        t.ok(line.res, 'res is defined')
-        t.equal(line.msg, 'request completed', 'message is set')
-        t.equal(line.res.statusCode, 200, 'statusCode is 200')
-        t.ok(line.responseTime, 'responseTime is defined')
+        t.assert.strictEqual(line.reqId, id)
+        t.assert.ok(line.reqId, 'reqId is defined')
+        t.assert.strictEqual(line.someBinding, 'value', 'child logger binding is set')
+        t.assert.ok(line.res, 'res is defined')
+        t.assert.strictEqual(line.msg, 'request completed', 'message is set')
+        t.assert.strictEqual(line.res.statusCode, 200, 'statusCode is 200')
+        t.assert.ok(line.responseTime, 'responseTime is defined')
       })
     })
   })
 
   fastify.listen({ port: 0, host: localhost }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
-    http.get(`http://${localhostForURL}:${fastify.server.address().port}`)
+    http.get(`http://${localhostForURL}:${fastify.server.address().port}`, () => {
+      done()
+    })
   })
 })
 
@@ -348,22 +350,32 @@ test('deepFreezeObject() should not throw on TypedArray', t => {
     const frozenObject = deepFreezeObject(object)
 
     // Buffers should not be frozen, as they are Uint8Array inherited instances
-    t.equal(Object.isFrozen(frozenObject.buffer), false)
+    t.assert.strictEqual(Object.isFrozen(frozenObject.buffer), false)
 
-    t.equal(Object.isFrozen(frozenObject), true)
-    t.equal(Object.isFrozen(frozenObject.object), true)
-    t.equal(Object.isFrozen(frozenObject.object.nested), true)
+    t.assert.strictEqual(Object.isFrozen(frozenObject), true)
+    t.assert.strictEqual(Object.isFrozen(frozenObject.object), true)
+    t.assert.strictEqual(Object.isFrozen(frozenObject.object.nested), true)
 
-    t.pass()
+    t.assert.ok(true)
   } catch (error) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
 test('pluginTimeout should be parsed correctly', t => {
   const withDisabledTimeout = Fastify({ pluginTimeout: '0' })
-  t.equal(withDisabledTimeout.initialConfig.pluginTimeout, 0)
+  t.assert.strictEqual(withDisabledTimeout.initialConfig.pluginTimeout, 0)
   const withInvalidTimeout = Fastify({ pluginTimeout: undefined })
-  t.equal(withInvalidTimeout.initialConfig.pluginTimeout, 10000)
-  t.end()
+  t.assert.strictEqual(withInvalidTimeout.initialConfig.pluginTimeout, 10000)
+})
+
+test('Should not mutate the options object outside Fastify', async t => {
+  const options = Object.freeze({})
+
+  try {
+    Fastify(options)
+    t.assert.ok(true)
+  } catch (error) {
+    t.assert.fail(error.message)
+  }
 })

package/test/internals/logger.test.js

@@ -1,34 +1,34 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../..')
-const loggerUtils = require('../../lib/logger')
+const loggerUtils = require('../../lib/logger-factory')
+const { serializers } = require('../../lib/logger-pino')
 
 test('time resolution', t => {
   t.plan(2)
-  t.equal(typeof loggerUtils.now, 'function')
-  t.equal(typeof loggerUtils.now(), 'number')
+  t.assert.strictEqual(typeof loggerUtils.now, 'function')
+  t.assert.strictEqual(typeof loggerUtils.now(), 'number')
 })
 
-test('The logger should add a unique id for every request', t => {
+test('The logger should add a unique id for every request', (t, done) => {
   const ids = []
 
   const fastify = Fastify()
   fastify.get('/', (req, reply) => {
-    t.ok(req.id)
+    t.assert.ok(req.id)
     reply.send({ id: req.id })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
     const queue = new Queue()
     for (let i = 0; i < 10; i++) {
       queue.add(checkId)
     }
     queue.add(() => {
       fastify.close()
-      t.end()
+      done()
     })
   })
 
@@ -37,24 +37,24 @@ test('The logger should add a unique id for every request', t => {
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, res) => {
-      t.error(err)
+      t.assert.ifError(err)
       const payload = JSON.parse(res.payload)
-      t.ok(ids.indexOf(payload.id) === -1, 'the id should not be duplicated')
+      t.assert.ok(ids.indexOf(payload.id) === -1, 'the id should not be duplicated')
       ids.push(payload.id)
       done()
     })
   }
 })
 
-test('The logger should not reuse request id header for req.id', t => {
+test('The logger should not reuse request id header for req.id', (t, done) => {
   const fastify = Fastify()
   fastify.get('/', (req, reply) => {
-    t.ok(req.id)
+    t.assert.ok(req.id)
     reply.send({ id: req.id })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     fastify.inject({
       method: 'GET',
@@ -63,27 +63,27 @@ test('The logger should not reuse request id header for req.id', t => {
         'Request-Id': 'request-id-1'
       }
     }, (err, res) => {
-      t.error(err)
+      t.assert.ifError(err)
       const payload = JSON.parse(res.payload)
-      t.ok(payload.id !== 'request-id-1', 'the request id from the header should not be returned with default configuration')
-      t.ok(payload.id === 'req-1') // first request id when using the default configuration
+      t.assert.ok(payload.id !== 'request-id-1', 'the request id from the header should not be returned with default configuration')
+      t.assert.ok(payload.id === 'req-1') // first request id when using the default configuration
       fastify.close()
-      t.end()
+      done()
     })
   })
 })
 
-test('The logger should reuse request id header for req.id if requestIdHeader is set', t => {
+test('The logger should reuse request id header for req.id if requestIdHeader is set', (t, done) => {
   const fastify = Fastify({
     requestIdHeader: 'request-id'
   })
   fastify.get('/', (req, reply) => {
-    t.ok(req.id)
+    t.assert.ok(req.id)
     reply.send({ id: req.id })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     fastify.inject({
       method: 'GET',
@@ -92,11 +92,11 @@ test('The logger should reuse request id header for req.id if requestIdHeader is
         'Request-Id': 'request-id-1'
       }
     }, (err, res) => {
-      t.error(err)
+      t.assert.ifError(err)
       const payload = JSON.parse(res.payload)
-      t.ok(payload.id === 'request-id-1', 'the request id from the header should be returned')
+      t.assert.ok(payload.id === 'request-id-1', 'the request id from the header should be returned')
       fastify.close()
-      t.end()
+      done()
     })
   })
 })
@@ -137,22 +137,22 @@ test('The logger should error if both stream and file destination are given', t
       }
     })
   } catch (err) {
-    t.equal(err.code, 'FST_ERR_LOG_INVALID_DESTINATION')
-    t.equal(err.message, 'Cannot specify both logger.stream and logger.file options')
+    t.assert.strictEqual(err.code, 'FST_ERR_LOG_INVALID_DESTINATION')
+    t.assert.strictEqual(err.message, 'Cannot specify both logger.stream and logger.file options')
   }
 })
 
 test('The serializer prevent fails if the request socket is undefined', t => {
   t.plan(1)
 
-  const serialized = loggerUtils.serializers.req({
+  const serialized = serializers.req({
     method: 'GET',
     url: '/',
     socket: undefined,
     headers: {}
   })
 
-  t.same(serialized, {
+  t.assert.deepStrictEqual(serialized, {
     method: 'GET',
     url: '/',
     version: undefined,

package/test/internals/plugin.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
 const pluginUtilsPublic = require('../../lib/pluginUtils.js')
 const symbols = require('../../lib/symbols.js')
@@ -12,8 +11,8 @@ test("shouldSkipOverride should check the 'skip-override' symbol", t => {
 
   yes[Symbol.for('skip-override')] = true
 
-  t.ok(pluginUtils.shouldSkipOverride(yes))
-  t.notOk(pluginUtils.shouldSkipOverride(no))
+  t.assert.ok(pluginUtils.shouldSkipOverride(yes))
+  t.assert.ok(!pluginUtils.shouldSkipOverride(no))
 
   function yes () {}
   function no () {}
@@ -26,7 +25,7 @@ test('getPluginName should return plugin name if the file is cached', t => {
   require.cache[expectedPluginName] = { exports: fn }
   const pluginName = pluginUtilsPublic.getPluginName(fn)
 
-  t.equal(pluginName, expectedPluginName)
+  t.assert.strictEqual(pluginName, expectedPluginName)
 })
 
 test('getPluginName should not throw when require.cache is undefined', t => {
@@ -36,12 +35,12 @@ test('getPluginName should not throw when require.cache is undefined', t => {
   }
   const cache = require.cache
   require.cache = undefined
-  t.teardown(() => {
+  t.after(() => {
     require.cache = cache
   })
   const pluginName = pluginUtilsPublic.getPluginName(example)
 
-  t.equal(pluginName, 'example')
+  t.assert.strictEqual(pluginName, 'example')
 })
 
 test("getMeta should return the object stored with the 'plugin-meta' symbol", t => {
@@ -50,7 +49,7 @@ test("getMeta should return the object stored with the 'plugin-meta' symbol", t
   const meta = { hello: 'world' }
   fn[Symbol.for('plugin-meta')] = meta
 
-  t.same(meta, pluginUtils.getMeta(fn))
+  t.assert.deepStrictEqual(meta, pluginUtils.getMeta(fn))
 
   function fn () {}
 })
@@ -73,9 +72,9 @@ test('checkDecorators should check if the given decorator is present in the inst
 
   try {
     pluginUtils.checkDecorators.call(context, fn)
-    t.pass('Everything ok')
+    t.assert.ok('Everything ok')
   } catch (err) {
-    t.fail(err)
+    t.assert.fail(err)
   }
 
   function fn () {}
@@ -99,9 +98,9 @@ test('checkDecorators should check if the given decorator is present in the inst
 
   try {
     pluginUtils.checkDecorators.call(context, fn)
-    t.fail('should throw')
+    t.assert.fail('should throw')
   } catch (err) {
-    t.equal(err.message, "The decorator 'plugin' is not present in Request")
+    t.assert.strictEqual(err.message, "The decorator 'plugin' is not present in Request")
   }
 
   function fn () {}
@@ -121,9 +120,9 @@ test('checkDecorators should accept optional decorators', t => {
 
   try {
     pluginUtils.checkDecorators.call(context, fn)
-    t.pass('Everything ok')
+    t.assert.ok('Everything ok')
   } catch (err) {
-    t.fail(err)
+    t.assert.fail(err)
   }
 
   function fn () {}
@@ -141,9 +140,9 @@ test('checkDependencies should check if the given dependency is present in the i
 
   try {
     pluginUtils.checkDependencies.call(context, fn)
-    t.pass('Everything ok')
+    t.assert.ok('Everything ok')
   } catch (err) {
-    t.fail(err)
+    t.assert.fail(err)
   }
 
   function fn () {}
@@ -162,9 +161,9 @@ test('checkDependencies should check if the given dependency is present in the i
 
   try {
     pluginUtils.checkDependencies.call(context, fn)
-    t.fail('should throw')
+    t.assert.fail('should throw')
   } catch (err) {
-    t.equal(err.message, "The dependency 'plugin' of plugin 'test-plugin' is not registered")
+    t.assert.strictEqual(err.message, "The dependency 'plugin' of plugin 'test-plugin' is not registered")
   }
 
   function fn () {}