@fastify/cookie 11.0.1 → 11.0.2

package/test/cookie.test.js

@@ -1,71 +1,71 @@
 'use strict'
 
-const { test } = require('tap')
+const { describe, test } = require('node:test')
 const Fastify = require('fastify')
 const sinon = require('sinon')
 const { sign, unsign } = require('../signer')
 const plugin = require('../')
 
-test('cookies get set correctly', (t) => {
-  t.plan(7)
+test('cookies get set correctly', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', { path: '/' })
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
   })
+
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
 })
 
-test('express cookie compatibility', (t) => {
-  t.plan(7)
+test('express cookie compatibility', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/espresso', (req, reply) => {
+  fastify.get('/espresso', (_req, reply) => {
     reply
       .cookie('foo', 'foo', { path: '/' })
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/espresso'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
 })
 
-test('should set multiple cookies', (t) => {
-  t.plan(10)
+test('should set multiple cookies', async (t) => {
+  t.plan(9)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply
       .setCookie('foo', 'foo')
       .cookie('bar', 'test')
@@ -73,31 +73,30 @@ test('should set multiple cookies', (t) => {
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 3)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[1].name, 'bar')
-    t.equal(cookies[1].value, 'test')
-    t.equal(cookies[2].name, 'wee')
-    t.equal(cookies[2].value, 'woo')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 3)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[1].name, 'bar')
+  t.assert.strictEqual(cookies[1].value, 'test')
+  t.assert.strictEqual(cookies[2].name, 'wee')
+  t.assert.strictEqual(cookies[2].value, 'woo')
 })
 
-test('should set multiple cookies', (t) => {
-  t.plan(12)
+test('should set multiple cookies', async (t) => {
+  t.plan(11)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply
       .setCookie('foo', 'foo')
       .cookie('bar', 'test', {
@@ -110,34 +109,33 @@ test('should set multiple cookies', (t) => {
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 3)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[1].name, 'bar')
-    t.equal(cookies[1].value, 'test')
-    t.equal(cookies[2].name, 'wee')
-    t.equal(cookies[2].value, 'woo')
-
-    t.equal(res.headers['set-cookie'][1], 'bar=test; Partitioned; SameSite=Lax')
-    t.equal(res.headers['set-cookie'][2], 'wee=woo; Secure; Partitioned; SameSite=Lax')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 3)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[1].name, 'bar')
+  t.assert.strictEqual(cookies[1].value, 'test')
+  t.assert.strictEqual(cookies[2].name, 'wee')
+  t.assert.strictEqual(cookies[2].value, 'woo')
+
+  t.assert.strictEqual(res.headers['set-cookie'][1], 'bar=test; Partitioned; SameSite=Lax')
+  t.assert.strictEqual(res.headers['set-cookie'][2], 'wee=woo; Secure; Partitioned; SameSite=Lax')
 })
 
-test('should set multiple cookies (an array already exists)', (t) => {
-  t.plan(10)
+test('should set multiple cookies (an array already exists)', async (t) => {
+  t.plan(9)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .header('Set-Cookie', ['bar=bar'])
       .setCookie('foo', 'foo', { path: '/' })
@@ -145,57 +143,55 @@ test('should set multiple cookies (an array already exists)', (t) => {
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 3)
-    t.equal(cookies[0].name, 'bar')
-    t.equal(cookies[0].value, 'bar')
-    t.equal(cookies[0].path, undefined)
-
-    t.equal(cookies[1].name, 'foo')
-    t.equal(cookies[1].value, 'foo')
-    t.equal(cookies[2].path, '/path')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 3)
+  t.assert.strictEqual(cookies[0].name, 'bar')
+  t.assert.strictEqual(cookies[0].value, 'bar')
+  t.assert.strictEqual(cookies[0].path, undefined)
+
+  t.assert.strictEqual(cookies[1].name, 'foo')
+  t.assert.strictEqual(cookies[1].value, 'foo')
+  t.assert.strictEqual(cookies[2].path, '/path')
 })
 
-test('cookies get set correctly with millisecond dates', (t) => {
-  t.plan(8)
+test('cookies get set correctly with millisecond dates', async (t) => {
+  t.plan(7)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', { path: '/', expires: Date.now() + 1000 })
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
-    const expires = new Date(cookies[0].expires)
-    t.ok(expires < new Date(Date.now() + 5000))
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
+  const expires = new Date(cookies[0].expires)
+  t.assert.ok(expires < new Date(Date.now() + 5000))
 })
 
-test('share options for setCookie and clearCookie', (t) => {
-  t.plan(8)
+test('share options for setCookie and clearCookie', async (t) => {
+  t.plan(7)
+
   const fastify = Fastify()
   const secret = 'testsecret'
   fastify.register(plugin, { secret })
@@ -205,33 +201,32 @@ test('share options for setCookie and clearCookie', (t) => {
     maxAge: 36000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', cookieOptions)
       .clearCookie('foo', cookieOptions)
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, '')
-    t.equal(cookies[0].maxAge, 0)
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, '')
+  t.assert.strictEqual(cookies[0].maxAge, 0)
 
-    t.ok(new Date(cookies[0].expires) < new Date())
-  })
+  t.assert.ok(new Date(cookies[0].expires) < new Date())
 })
 
-test('expires should not be overridden in clearCookie', (t) => {
-  t.plan(7)
+test('expires should not be overridden in clearCookie', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
   const secret = 'testsecret'
   fastify.register(plugin, { secret })
@@ -241,129 +236,127 @@ test('expires should not be overridden in clearCookie', (t) => {
     expires: Date.now() + 1000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', cookieOptions)
       .clearCookie('foo', cookieOptions)
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, '')
-    const expires = new Date(cookies[0].expires)
-    t.ok(expires < new Date(Date.now() + 5000))
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, '')
+  const expires = new Date(cookies[0].expires)
+  t.assert.ok(expires < new Date(Date.now() + 5000))
 })
 
-test('parses incoming cookies', (t) => {
-  t.plan(15)
+test('parses incoming cookies', async (t) => {
+  t.plan(14)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
   // check that it parses the cookies in the onRequest hook
   for (const hook of ['preValidation', 'preHandler']) {
-    fastify.addHook(hook, (req, reply, done) => {
-      t.ok(req.cookies)
-      t.ok(req.cookies.bar)
-      t.equal(req.cookies.bar, 'bar')
+    fastify.addHook(hook, (req, _reply, done) => {
+      t.assert.ok(req.cookies)
+      t.assert.ok(req.cookies.bar)
+      t.assert.strictEqual(req.cookies.bar, 'bar')
       done()
     })
   }
 
-  fastify.addHook('preParsing', (req, reply, payload, done) => {
-    t.ok(req.cookies)
-    t.ok(req.cookies.bar)
-    t.equal(req.cookies.bar, 'bar')
+  fastify.addHook('preParsing', (req, _reply, _payload, done) => {
+    t.assert.ok(req.cookies)
+    t.assert.ok(req.cookies.bar)
+    t.assert.strictEqual(req.cookies.bar, 'bar')
     done()
   })
 
   fastify.get('/test2', (req, reply) => {
-    t.ok(req.cookies)
-    t.ok(req.cookies.bar)
-    t.equal(req.cookies.bar, 'bar')
+    t.assert.ok(req.cookies)
+    t.assert.ok(req.cookies.bar)
+    t.assert.strictEqual(req.cookies.bar, 'bar')
     reply.send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test2',
     headers: {
       cookie: 'bar=bar'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 })
 
-test('defined and undefined cookies', (t) => {
-  t.plan(23)
+test('defined and undefined cookies', async (t) => {
+  t.plan(22)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
   // check that it parses the cookies in the onRequest hook
   for (const hook of ['preValidation', 'preHandler']) {
-    fastify.addHook(hook, (req, reply, done) => {
-      t.ok(req.cookies)
+    fastify.addHook(hook, (req, _reply, done) => {
+      t.assert.ok(req.cookies)
 
-      t.ok(req.cookies.bar)
-      t.notOk(req.cookies.baz)
+      t.assert.ok(req.cookies.bar)
+      t.assert.ok(!req.cookies.baz)
 
-      t.equal(req.cookies.bar, 'bar')
-      t.equal(req.cookies.baz, undefined)
+      t.assert.strictEqual(req.cookies.bar, 'bar')
+      t.assert.strictEqual(req.cookies.baz, undefined)
       done()
     })
   }
 
-  fastify.addHook('preParsing', (req, reply, payload, done) => {
-    t.ok(req.cookies)
+  fastify.addHook('preParsing', (req, _reply, _payload, done) => {
+    t.assert.ok(req.cookies)
+
+    t.assert.ok(req.cookies.bar)
+    t.assert.ok(!req.cookies.baz)
 
-    t.ok(req.cookies.bar)
-    t.notOk(req.cookies.baz)
+    t.assert.strictEqual(req.cookies.bar, 'bar')
+    t.assert.strictEqual(req.cookies.baz, undefined)
 
-    t.equal(req.cookies.bar, 'bar')
-    t.equal(req.cookies.baz, undefined)
     done()
   })
 
   fastify.get('/test2', (req, reply) => {
-    t.ok(req.cookies)
+    t.assert.ok(req.cookies)
 
-    t.ok(req.cookies.bar)
-    t.notOk(req.cookies.baz)
+    t.assert.ok(req.cookies.bar)
+    t.assert.ok(!req.cookies.baz)
 
-    t.equal(req.cookies.bar, 'bar')
-    t.equal(req.cookies.baz, undefined)
+    t.assert.strictEqual(req.cookies.bar, 'bar')
+    t.assert.strictEqual(req.cookies.baz, undefined)
 
     reply.send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test2',
     headers: {
       cookie: 'bar=bar'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 })
 
-test('does not modify supplied cookie options object', (t) => {
-  t.plan(3)
+test('does not modify supplied cookie options object', async (t) => {
+  t.plan(2)
+
   const expireDate = Date.now() + 1000
   const cookieOptions = {
     path: '/',
@@ -372,110 +365,104 @@ test('does not modify supplied cookie options object', (t) => {
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', cookieOptions)
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.strictSame(cookieOptions, {
-      path: '/',
-      expires: expireDate
-    })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(cookieOptions, {
+    path: '/',
+    expires: expireDate
   })
 })
 
-test('cookies gets cleared correctly', (t) => {
-  t.plan(5)
+test('cookies gets cleared correctly', async (t) => {
+  t.plan(4)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .clearCookie('foo')
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(new Date(cookies[0].expires) < new Date(), true)
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(new Date(cookies[0].expires) < new Date(), true)
 })
 
-test('cookies signature', (t) => {
-  t.plan(9)
+describe('cookies signature', () => {
+  test('unsign', async (t) => {
+    t.plan(5)
 
-  t.test('unsign', t => {
-    t.plan(6)
     const fastify = Fastify()
     const secret = 'bar'
     fastify.register(plugin, { secret })
 
-    fastify.get('/test1', (req, reply) => {
+    fastify.get('/test1', (_req, reply) => {
       reply
         .setCookie('foo', 'foo', { signed: true })
         .send({ hello: 'world' })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1'
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { hello: 'world' })
-
-      const cookies = res.cookies
-      t.equal(cookies.length, 1)
-      t.equal(cookies[0].name, 'foo')
-      t.same(unsign(cookies[0].value, secret), { valid: true, renew: false, value: 'foo' })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+    const cookies = res.cookies
+    t.assert.strictEqual(cookies.length, 1)
+    t.assert.strictEqual(cookies[0].name, 'foo')
+    t.assert.deepStrictEqual(unsign(cookies[0].value, secret), { valid: true, renew: false, value: 'foo' })
   })
 
-  t.test('key rotation uses first key to sign', t => {
-    t.plan(6)
+  test('key rotation uses first key to sign', async (t) => {
+    t.plan(5)
+
     const fastify = Fastify()
     const secret1 = 'secret-1'
     const secret2 = 'secret-2'
     fastify.register(plugin, { secret: [secret1, secret2] })
 
-    fastify.get('/test1', (req, reply) => {
+    fastify.get('/test1', (_req, reply) => {
       reply
         .setCookie('foo', 'cookieVal', { signed: true })
         .send({ hello: 'world' })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1'
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { hello: 'world' })
-
-      const cookies = res.cookies
-      t.equal(cookies.length, 1)
-      t.equal(cookies[0].name, 'foo')
-      t.same(unsign(cookies[0].value, secret1), { valid: true, renew: false, value: 'cookieVal' }) // decode using first key
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+    const cookies = res.cookies
+    t.assert.strictEqual(cookies.length, 1)
+    t.assert.strictEqual(cookies[0].name, 'foo')
+    t.assert.deepStrictEqual(unsign(cookies[0].value, secret1), { valid: true, renew: false, value: 'cookieVal' }) // decode using first key
   })
 
-  t.test('unsginCookie via fastify instance', t => {
-    t.plan(3)
+  test('unsginCookie via fastify instance', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret = 'bar'
 
@@ -487,21 +474,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', secret)}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
   })
 
-  t.test('unsignCookie via request decorator', t => {
-    t.plan(3)
+  test('unsignCookie via request decorator', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret = 'bar'
     fastify.register(plugin, { secret })
@@ -512,21 +498,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', secret)}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
   })
 
-  t.test('unsignCookie via reply decorator', t => {
-    t.plan(3)
+  test('unsignCookie via reply decorator', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret = 'bar'
     fastify.register(plugin, { secret })
@@ -537,21 +522,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', secret)}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'foo', renew: false, valid: true } })
   })
 
-  t.test('unsignCookie via request decorator after rotation', t => {
-    t.plan(3)
+  test('unsignCookie via request decorator after rotation', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret1 = 'sec-1'
     const secret2 = 'sec-2'
@@ -563,21 +547,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', secret2)}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: 'foo', renew: true, valid: true } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'foo', renew: true, valid: true } })
   })
 
-  t.test('unsignCookie via reply decorator after rotation', t => {
-    t.plan(3)
+  test('unsignCookie via reply decorator after rotation', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret1 = 'sec-1'
     const secret2 = 'sec-2'
@@ -589,21 +572,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', secret2)}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: 'foo', renew: true, valid: true } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'foo', renew: true, valid: true } })
   })
 
-  t.test('unsignCookie via request decorator failure response', t => {
-    t.plan(3)
+  test('unsignCookie via request decorator failure response', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret1 = 'sec-1'
     const secret2 = 'sec-2'
@@ -615,21 +597,20 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', 'invalid-secret')}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: null, renew: false, valid: false } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: null, renew: false, valid: false } })
   })
 
-  t.test('unsignCookie reply decorator failure response', t => {
-    t.plan(3)
+  test('unsignCookie reply decorator failure response', async (t) => {
+    t.plan(2)
+
     const fastify = Fastify()
     const secret1 = 'sec-1'
     const secret2 = 'sec-2'
@@ -641,52 +622,50 @@ test('cookies signature', (t) => {
       })
     })
 
-    fastify.inject({
+    const res = await fastify.inject({
       method: 'GET',
       url: '/test1',
       headers: {
         cookie: `foo=${sign('foo', 'invalid-secret')}`
       }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { unsigned: { value: null, renew: false, valid: false } })
     })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: null, renew: false, valid: false } })
   })
 })
 
-test('custom signer', t => {
-  t.plan(7)
+test('custom signer', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
   const signStub = sinon.stub().returns('SIGNED-VALUE')
   const unsignStub = sinon.stub().returns('ORIGINAL VALUE')
   const secret = { sign: signStub, unsign: unsignStub }
   fastify.register(plugin, { secret })
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'bar', { signed: true })
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'SIGNED-VALUE')
-    t.ok(signStub.calledOnceWithExactly('bar'))
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'SIGNED-VALUE')
+  t.assert.ok(signStub.calledOnceWithExactly('bar'))
 })
 
-test('unsignCookie decorator with custom signer', t => {
-  t.plan(4)
+test('unsignCookie decorator with custom signer', async (t) => {
+  t.plan(3)
+
   const fastify = Fastify()
   const signStub = sinon.stub().returns('SIGNED-VALUE')
   const unsignStub = sinon.stub().returns('ORIGINAL VALUE')
@@ -699,22 +678,21 @@ test('unsignCookie decorator with custom signer', t => {
     })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1',
     headers: {
       cookie: 'foo=SOME-SIGNED-VALUE'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { unsigned: 'ORIGINAL VALUE' })
-    t.ok(unsignStub.calledOnceWithExactly('SOME-SIGNED-VALUE'))
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: 'ORIGINAL VALUE' })
+  t.assert.ok(unsignStub.calledOnceWithExactly('SOME-SIGNED-VALUE'))
 })
 
-test('pass options to `cookies.parse`', (t) => {
-  t.plan(6)
+test('pass options to `cookies.parse`', async (t) => {
+  t.plan(5)
+
   const fastify = Fastify()
   fastify.register(plugin, {
     parseOptions: {
@@ -723,31 +701,30 @@ test('pass options to `cookies.parse`', (t) => {
   })
 
   fastify.get('/test1', (req, reply) => {
-    t.ok(req.cookies)
-    t.ok(req.cookies.foo)
-    t.equal(req.cookies.foo, 'bartest')
+    t.assert.ok(req.cookies)
+    t.assert.ok(req.cookies.foo)
+    t.assert.strictEqual(req.cookies.foo, 'bartest')
     reply.send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1',
     headers: {
       cookie: 'foo=bar'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
   function decoder (str) {
     return str + 'test'
   }
 })
 
-test('issue 53', (t) => {
-  t.plan(5)
+test('issue 53', async (t) => {
+  t.plan(3)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
@@ -755,7 +732,7 @@ test('issue 53', (t) => {
   let count = 1
   fastify.get('/foo', (req, reply) => {
     if (count > 1) {
-      t.not(cookies, req.cookies)
+      t.assert.notEqual(cookies, req.cookies)
       return reply.send('done')
     }
 
@@ -763,44 +740,44 @@ test('issue 53', (t) => {
     cookies = req.cookies
     reply.send('done')
   })
+  {
+    const res = await fastify.inject({ url: '/foo' })
+    t.assert.strictEqual(res.body, 'done')
+  }
 
-  fastify.inject({ url: '/foo' }, (err, response) => {
-    t.error(err)
-    t.equal(response.body, 'done')
-  })
-
-  fastify.inject({ url: '/foo' }, (err, response) => {
-    t.error(err)
-    t.equal(response.body, 'done')
-  })
+  {
+    const res = await fastify.inject({ url: '/foo' })
+    t.assert.strictEqual(res.body, 'done')
+  }
 })
 
-test('serialize cookie manually using decorator', (t) => {
+test('serialize cookie manually using decorator', async (t) => {
   t.plan(2)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.ready(() => {
-    t.ok(fastify.serializeCookie)
-    t.same(fastify.serializeCookie('foo', 'bar', {}), 'foo=bar')
-    t.end()
-  })
+  await new Promise(resolve => fastify.ready(resolve))
+
+  t.assert.ok(fastify.serializeCookie)
+  t.assert.deepStrictEqual(fastify.serializeCookie('foo', 'bar', {}), 'foo=bar')
 })
 
-test('parse cookie manually using decorator', (t) => {
+test('parse cookie manually using decorator', async (t) => {
   t.plan(2)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.ready(() => {
-    t.ok(fastify.parseCookie)
-    t.same(fastify.parseCookie('foo=bar', {}), { foo: 'bar' })
-    t.end()
-  })
+  await new Promise(resolve => fastify.ready(resolve))
+
+  t.assert.ok(fastify.parseCookie)
+  t.assert.deepStrictEqual({ ...fastify.parseCookie('foo=bar', {}) }, { foo: 'bar' })
 })
 
-test('cookies set with plugin options parseOptions field', (t) => {
-  t.plan(8)
+test('cookies set with plugin options parseOptions field', async (t) => {
+  t.plan(7)
+
   const fastify = Fastify()
   fastify.register(plugin, {
     parseOptions: {
@@ -809,31 +786,29 @@ test('cookies set with plugin options parseOptions field', (t) => {
     }
   })
 
-  fastify.get('/test', (req, reply) => {
+  fastify.get('/test', (_req, reply) => {
     reply.setCookie('foo', 'foo').send({ hello: 'world' })
   })
 
-  fastify.inject(
+  const res = await fastify.inject(
     {
       method: 'GET',
       url: '/test'
-    },
-    (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.same(JSON.parse(res.body), { hello: 'world' })
-
-      const cookies = res.cookies
-      t.equal(cookies.length, 1)
-      t.equal(cookies[0].name, 'foo')
-      t.equal(cookies[0].value, 'foo')
-      t.equal(cookies[0].path, '/test')
-      t.equal(cookies[0].domain, 'example.com')
-    }
-  )
+    })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/test')
+  t.assert.strictEqual(cookies[0].domain, 'example.com')
 })
 
 test('create signed cookie manually using signCookie decorator', async (t) => {
+  t.plan(2)
+
   const fastify = Fastify()
 
   await fastify.register(plugin, { secret: 'secret' })
@@ -849,16 +824,18 @@ test('create signed cookie manually using signCookie decorator', async (t) => {
     url: '/test1',
     headers: { cookie: `foo=${fastify.signCookie('bar')}` }
   })
-  t.equal(res.statusCode, 200)
-  t.same(JSON.parse(res.body), { unsigned: { value: 'bar', renew: false, valid: true } })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { unsigned: { value: 'bar', renew: false, valid: true } })
 })
 
 test('handle secure:auto of cookieOptions', async (t) => {
+  t.plan(11)
+
   const fastify = Fastify({ trustProxy: true })
 
   await fastify.register(plugin)
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', { path: '/', secure: 'auto' })
       .send()
@@ -871,11 +848,11 @@ test('handle secure:auto of cookieOptions', async (t) => {
   })
 
   const cookies = res.cookies
-  t.equal(cookies.length, 1)
-  t.equal(cookies[0].name, 'foo')
-  t.equal(cookies[0].value, 'foo')
-  t.equal(cookies[0].secure, true)
-  t.equal(cookies[0].path, '/')
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].secure, true)
+  t.assert.strictEqual(cookies[0].path, '/')
 
   const res2 = await fastify.inject({
     method: 'GET',
@@ -883,28 +860,29 @@ test('handle secure:auto of cookieOptions', async (t) => {
   })
 
   const cookies2 = res2.cookies
-  t.equal(cookies2.length, 1)
-  t.equal(cookies2[0].name, 'foo')
-  t.equal(cookies2[0].value, 'foo')
-  t.equal(cookies2[0].sameSite, 'Lax')
-  t.same(cookies2[0].secure, null)
-  t.equal(cookies2[0].path, '/')
+  t.assert.strictEqual(cookies2.length, 1)
+  t.assert.strictEqual(cookies2[0].name, 'foo')
+  t.assert.strictEqual(cookies2[0].value, 'foo')
+  t.assert.strictEqual(cookies2[0].sameSite, 'Lax')
+  t.assert.deepStrictEqual(cookies2[0].secure, undefined)
+  t.assert.strictEqual(cookies2[0].path, '/')
 })
 
 test('should not decorate fastify, request and reply if no secret was provided', async (t) => {
   t.plan(8)
+
   const fastify = Fastify()
 
   await fastify.register(plugin)
 
-  t.notOk(fastify.signCookie)
-  t.notOk(fastify.unsignCookie)
+  t.assert.ok(!fastify.signCookie)
+  t.assert.ok(!fastify.unsignCookie)
 
   fastify.get('/testDecorators', (req, reply) => {
-    t.notOk(req.signCookie)
-    t.notOk(reply.signCookie)
-    t.notOk(req.unsignCookie)
-    t.notOk(reply.unsignCookie)
+    t.assert.ok(!req.signCookie)
+    t.assert.ok(!reply.signCookie)
+    t.assert.ok(!req.unsignCookie)
+    t.assert.ok(!reply.unsignCookie)
 
     reply.send({
       unsigned: req.unsignCookie(req.cookies.foo)
@@ -916,111 +894,110 @@ test('should not decorate fastify, request and reply if no secret was provided',
     url: '/testDecorators'
   })
 
-  t.equal(res.statusCode, 500)
-  t.same(JSON.parse(res.body), {
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.deepStrictEqual(JSON.parse(res.body), {
     statusCode: 500,
     error: 'Internal Server Error',
     message: 'req.unsignCookie is not a function'
   })
 })
 
-test('dont add auto cookie parsing to onRequest-hook if hook-option is set to false', (t) => {
-  t.plan(6)
+test('dont add auto cookie parsing to onRequest-hook if hook-option is set to false', async (t) => {
+  t.plan(5)
+
   const fastify = Fastify()
   fastify.register(plugin, { hook: false })
 
   for (const hook of ['preValidation', 'preHandler', 'preParsing']) {
     fastify.addHook(hook, async (req) => {
-      t.equal(req.cookies, null)
+      t.assert.strictEqual(req.cookies, null)
     })
   }
 
   fastify.get('/disable', (req, reply) => {
-    t.equal(req.cookies, null)
+    t.assert.strictEqual(req.cookies, null)
     reply.send()
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/disable',
     headers: {
       cookie: 'bar=bar'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
   })
+  t.assert.strictEqual(res.statusCode, 200)
 })
 
-test('result in an error if hook-option is set to an invalid value', (t) => {
+test('result in an error if hook-option is set to an invalid value', async (t) => {
   t.plan(1)
+
   const fastify = Fastify()
 
-  t.rejects(
+  await t.assert.rejects(
     async () => fastify.register(plugin, { hook: true }),
     new Error("@fastify/cookie: Invalid value provided for the hook-option. You can set the hook-option only to false, 'onRequest' , 'preParsing' , 'preValidation' or 'preHandler'")
   )
 })
 
-test('correct working plugin if hook-option to preParsing', (t) => {
-  t.plan(5)
+test('correct working plugin if hook-option to preParsing', async (t) => {
+  t.plan(4)
+
   const fastify = Fastify()
   fastify.register(plugin, { hook: 'preParsing' })
 
   fastify.addHook('onRequest', async (req) => {
-    t.equal(req.cookies, null)
+    t.assert.strictEqual(req.cookies, null)
   })
 
   fastify.addHook('preValidation', async (req) => {
-    t.equal(req.cookies.bar, 'bar')
+    t.assert.strictEqual(req.cookies.bar, 'bar')
   })
 
   fastify.get('/preparsing', (req, reply) => {
-    t.equal(req.cookies.bar, 'bar')
+    t.assert.strictEqual(req.cookies.bar, 'bar')
     reply.send()
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/preparsing',
     headers: {
       cookie: 'bar=bar'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
   })
+  t.assert.strictEqual(res.statusCode, 200)
 })
 
-test('if cookies are not set, then the handler creates an empty req.cookies object', (t) => {
-  t.plan(5)
+test('if cookies are not set, then the handler creates an empty req.cookies object', async (t) => {
+  t.plan(4)
+
   const fastify = Fastify()
   fastify.register(plugin, { hook: 'preParsing' })
 
   fastify.addHook('onRequest', async (req) => {
-    t.equal(req.cookies, null)
+    t.assert.strictEqual(req.cookies, null)
   })
 
   fastify.addHook('preValidation', async (req) => {
-    t.ok(req.cookies)
+    t.assert.ok(req.cookies)
   })
 
   fastify.get('/preparsing', (req, reply) => {
-    t.ok(req.cookies)
+    t.assert.ok(req.cookies)
     reply.send()
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/preparsing'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
   })
+  t.assert.strictEqual(res.statusCode, 200)
 })
 
-test('clearCookie should include parseOptions', (t) => {
-  t.plan(10)
+test('clearCookie should include parseOptions', async (t) => {
+  t.plan(9)
+
   const fastify = Fastify()
   fastify.register(plugin, {
     parseOptions: {
@@ -1034,36 +1011,35 @@ test('clearCookie should include parseOptions', (t) => {
     maxAge: 36000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', cookieOptions)
       .clearCookie('foo', cookieOptions)
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
-    const cookies = res.cookies
+  const cookies = res.cookies
 
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, '')
-    t.equal(cookies[0].maxAge, 0)
-    t.equal(cookies[0].path, '/test')
-    t.equal(cookies[0].domain, 'example.com')
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, '')
+  t.assert.strictEqual(cookies[0].maxAge, 0)
+  t.assert.strictEqual(cookies[0].path, '/test')
+  t.assert.strictEqual(cookies[0].domain, 'example.com')
 
-    t.ok(new Date(cookies[0].expires) < new Date())
-  })
+  t.assert.ok(new Date(cookies[0].expires) < new Date())
 })
 
-test('should update a cookie value when setCookie is called multiple times', (t) => {
-  t.plan(15)
+test('should update a cookie value when setCookie is called multiple times', async (t) => {
+  t.plan(14)
+
   const fastify = Fastify()
   const secret = 'testsecret'
   fastify.register(plugin, { secret })
@@ -1079,7 +1055,7 @@ test('should update a cookie value when setCookie is called multiple times', (t)
     maxAge: 36000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .setCookie('foo', 'foo', cookieOptions)
       .clearCookie('foo', cookieOptions)
@@ -1089,36 +1065,35 @@ test('should update a cookie value when setCookie is called multiple times', (t)
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
-    const cookies = res.cookies
-    t.equal(cookies.length, 3)
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 3)
 
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, '')
-    t.equal(cookies[0].path, '/foo')
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, '')
+  t.assert.strictEqual(cookies[0].path, '/foo')
 
-    t.equal(cookies[1].name, 'foo')
-    t.equal(cookies[1].value, sign('foo', secret))
-    t.equal(cookies[1].maxAge, 36000)
+  t.assert.strictEqual(cookies[1].name, 'foo')
+  t.assert.strictEqual(cookies[1].value, sign('foo', secret))
+  t.assert.strictEqual(cookies[1].maxAge, 36000)
 
-    t.equal(cookies[2].name, 'foos')
-    t.equal(cookies[2].value, sign('foosy', secret))
-    t.equal(cookies[2].path, '/foo')
-    t.equal(cookies[2].maxAge, 36000)
+  t.assert.strictEqual(cookies[2].name, 'foos')
+  t.assert.strictEqual(cookies[2].value, sign('foosy', secret))
+  t.assert.strictEqual(cookies[2].path, '/foo')
+  t.assert.strictEqual(cookies[2].maxAge, 36000)
 
-    t.ok(new Date(cookies[0].expires) < new Date())
-  })
+  t.assert.ok(new Date(cookies[0].expires) < new Date())
 })
 
-test('should update a cookie value when setCookie is called multiple times (empty header)', (t) => {
-  t.plan(15)
+test('should update a cookie value when setCookie is called multiple times (empty header)', async (t) => {
+  t.plan(14)
+
   const fastify = Fastify()
   const secret = 'testsecret'
   fastify.register(plugin, { secret })
@@ -1134,7 +1109,7 @@ test('should update a cookie value when setCookie is called multiple times (empt
     maxAge: 36000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .header('Set-Cookie', '', cookieOptions)
       .setCookie('foo', 'foo', cookieOptions)
@@ -1145,36 +1120,35 @@ test('should update a cookie value when setCookie is called multiple times (empt
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
-    const cookies = res.cookies
-    t.equal(cookies.length, 3)
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 3)
 
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, '')
-    t.equal(cookies[0].path, '/foo')
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, '')
+  t.assert.strictEqual(cookies[0].path, '/foo')
 
-    t.equal(cookies[1].name, 'foo')
-    t.equal(cookies[1].value, sign('foo', secret))
-    t.equal(cookies[1].maxAge, 36000)
+  t.assert.strictEqual(cookies[1].name, 'foo')
+  t.assert.strictEqual(cookies[1].value, sign('foo', secret))
+  t.assert.strictEqual(cookies[1].maxAge, 36000)
 
-    t.equal(cookies[2].name, 'foos')
-    t.equal(cookies[2].value, sign('foosy', secret))
-    t.equal(cookies[2].path, '/foo')
-    t.equal(cookies[2].maxAge, 36000)
+  t.assert.strictEqual(cookies[2].name, 'foos')
+  t.assert.strictEqual(cookies[2].value, sign('foosy', secret))
+  t.assert.strictEqual(cookies[2].path, '/foo')
+  t.assert.strictEqual(cookies[2].maxAge, 36000)
 
-    t.ok(new Date(cookies[0].expires) < new Date())
-  })
+  t.assert.ok(new Date(cookies[0].expires) < new Date())
 })
 
-test('should update a cookie value when setCookie is called multiple times (non-empty header)', (t) => {
-  t.plan(15)
+test('should update a cookie value when setCookie is called multiple times (non-empty header)', async (t) => {
+  t.plan(14)
+
   const fastify = Fastify()
   const secret = 'testsecret'
   fastify.register(plugin, { secret })
@@ -1190,7 +1164,7 @@ test('should update a cookie value when setCookie is called multiple times (non-
     maxAge: 36000
   }
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .header('Set-Cookie', 'manual=manual', cookieOptions)
       .setCookie('foo', 'foo', cookieOptions)
@@ -1201,148 +1175,142 @@ test('should update a cookie value when setCookie is called multiple times (non-
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 
-    const cookies = res.cookies
-    t.equal(cookies.length, 4)
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 4)
 
-    t.equal(cookies[1].name, 'foo')
-    t.equal(cookies[1].value, '')
-    t.equal(cookies[1].path, '/foo')
+  t.assert.strictEqual(cookies[1].name, 'foo')
+  t.assert.strictEqual(cookies[1].value, '')
+  t.assert.strictEqual(cookies[1].path, '/foo')
 
-    t.equal(cookies[2].name, 'foo')
-    t.equal(cookies[2].value, sign('foo', secret))
-    t.equal(cookies[2].maxAge, 36000)
+  t.assert.strictEqual(cookies[2].name, 'foo')
+  t.assert.strictEqual(cookies[2].value, sign('foo', secret))
+  t.assert.strictEqual(cookies[2].maxAge, 36000)
 
-    t.equal(cookies[3].name, 'foos')
-    t.equal(cookies[3].value, sign('foosy', secret))
-    t.equal(cookies[3].path, '/foo')
-    t.equal(cookies[3].maxAge, 36000)
+  t.assert.strictEqual(cookies[3].name, 'foos')
+  t.assert.strictEqual(cookies[3].value, sign('foosy', secret))
+  t.assert.strictEqual(cookies[3].path, '/foo')
+  t.assert.strictEqual(cookies[3].maxAge, 36000)
 
-    t.ok(new Date(cookies[1].expires) < new Date())
-  })
+  t.assert.ok(new Date(cookies[1].expires) < new Date())
 })
 
-test('cookies get set correctly if set inside onSend', (t) => {
-  t.plan(7)
+test('cookies get set correctly if set inside onSend', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.addHook('onSend', async (req, reply, payload) => {
+  fastify.addHook('onSend', async (_req, reply, payload) => {
     reply.setCookie('foo', 'foo', { path: '/' })
     return payload
   })
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
 })
 
-test('cookies get set correctly if set inside multiple onSends', (t) => {
-  t.plan(10)
+test('cookies get set correctly if set inside multiple onSends', async (t) => {
+  t.plan(9)
+
   const fastify = Fastify()
   fastify.register(plugin)
 
-  fastify.addHook('onSend', async (req, reply, payload) => {
+  fastify.addHook('onSend', async (_req, reply, _payload) => {
     reply.setCookie('foo', 'foo', { path: '/' })
   })
 
-  fastify.addHook('onSend', async (req, reply, payload) => {
+  fastify.addHook('onSend', async (_req, reply, payload) => {
     reply.setCookie('foo', 'foos', { path: '/' })
     return payload
   })
 
-  fastify.get('/test1', (req, reply) => {
+  fastify.get('/test1', (_req, reply) => {
     reply
       .send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 2)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
-
-    t.equal(cookies[1].name, 'foo')
-    t.equal(cookies[1].value, 'foos')
-    t.equal(cookies[1].path, '/')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 2)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
+
+  t.assert.strictEqual(cookies[1].name, 'foo')
+  t.assert.strictEqual(cookies[1].value, 'foos')
+  t.assert.strictEqual(cookies[1].path, '/')
 })
 
-test('cookies get set correctly if set inside onRequest', (t) => {
-  t.plan(7)
+test('cookies get set correctly if set inside onRequest', async (t) => {
+  t.plan(6)
+
   const fastify = Fastify()
-  fastify.addHook('onRequest', async (req, reply) => {
+  fastify.addHook('onRequest', async (_req, reply) => {
     reply.setCookie('foo', 'foo', { path: '/' })
     return reply.send({ hello: 'world' })
   })
 
   fastify.register(plugin)
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
-
-    const cookies = res.cookies
-    t.equal(cookies.length, 1)
-    t.equal(cookies[0].name, 'foo')
-    t.equal(cookies[0].value, 'foo')
-    t.equal(cookies[0].path, '/')
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
+
+  const cookies = res.cookies
+  t.assert.strictEqual(cookies.length, 1)
+  t.assert.strictEqual(cookies[0].name, 'foo')
+  t.assert.strictEqual(cookies[0].value, 'foo')
+  t.assert.strictEqual(cookies[0].path, '/')
 })
 
-test('do not crash if the onRequest hook is not run', (t) => {
-  t.plan(3)
+test('do not crash if the onRequest hook is not run', async (t) => {
+  t.plan(2)
+
   const fastify = Fastify()
-  fastify.addHook('onRequest', async (req, reply) => {
+  fastify.addHook('onRequest', async (_req, reply) => {
     return reply.send({ hello: 'world' })
   })
 
   fastify.register(plugin)
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test1',
     headers: {
       cookie: 'foo=foo'
     }
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.body), { hello: 'world' })
   })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(res.body), { hello: 'world' })
 })