fastify 5.0.0 → 5.2.0

package/test/async-dispose.test.js

@@ -1,21 +1,20 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const Fastify = require('../fastify')
 
 // asyncDispose doesn't exist in node <= 16
-t.test('async dispose should close fastify', { skip: !('asyncDispose' in Symbol) }, async t => {
+test('async dispose should close fastify', { skip: !('asyncDispose' in Symbol) }, async t => {
   t.plan(2)
 
   const fastify = Fastify()
 
   await fastify.listen({ port: 0 })
 
-  t.equal(fastify.server.listening, true)
+  t.assert.strictEqual(fastify.server.listening, true)
 
   // the same as syntax sugar for
   // await using app = fastify()
   await fastify[Symbol.asyncDispose]()
-
-  t.equal(fastify.server.listening, false)
+  t.assert.strictEqual(fastify.server.listening, false)
 })

package/test/async_hooks.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { createHook } = require('node:async_hooks')
-const t = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
@@ -20,27 +20,17 @@ createHook({
 
 const app = Fastify({ logger: false })
 
-app.get('/', function (request, reply) {
-  reply.send({ id: 42 })
-})
-
-app.post('/', function (request, reply) {
-  reply.send({ id: 42 })
-})
+test('test async hooks', (t, done) => {
+  app.get('/', function (request, reply) {
+    reply.send({ id: 42 })
+  })
 
-app.listen({ port: 0 }, function (err, address) {
-  t.error(err)
+  app.post('/', function (request, reply) {
+    reply.send({ id: 42 })
+  })
 
-  sget({
-    method: 'POST',
-    url: 'http://localhost:' + app.server.address().port,
-    body: {
-      hello: 'world'
-    },
-    json: true
-  }, (err, response, body) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
+  app.listen({ port: 0 }, function (err, address) {
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -50,19 +40,31 @@ app.listen({ port: 0 }, function (err, address) {
       },
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
 
       sget({
-        method: 'GET',
+        method: 'POST',
         url: 'http://localhost:' + app.server.address().port,
+        body: {
+          hello: 'world'
+        },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        app.close()
-        t.equal(remainingIds.size, 0)
-        t.end()
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+
+        sget({
+          method: 'GET',
+          url: 'http://localhost:' + app.server.address().port,
+          json: true
+        }, (err, response, body) => {
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          app.close()
+          t.assert.strictEqual(remainingIds.size, 0)
+          done()
+        })
       })
     })
   })

package/test/{bodyLimit.test.js → body-limit.test.js}

@@ -1,26 +1,25 @@
 'use strict'
 
-const Fastify = require('..')
+const Fastify = require('../fastify')
 const sget = require('simple-get').concat
 const zlib = require('node:zlib')
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
-test('bodyLimit', t => {
+test('bodyLimit', (t, done) => {
   t.plan(5)
 
   try {
     Fastify({ bodyLimit: 1.3 })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   try {
     Fastify({ bodyLimit: [] })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   const fastify = Fastify({ bodyLimit: 1 })
@@ -30,8 +29,8 @@ test('bodyLimit', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'POST',
@@ -40,14 +39,15 @@ test('bodyLimit', t => {
       body: [],
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 413)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 413)
+      done()
     })
   })
 })
 
-test('bodyLimit is applied to decoded content', t => {
-  t.plan(9)
+test('bodyLimit is applied to decoded content', async (t) => {
+  t.plan(6)
 
   const body = { x: 'x'.repeat(30000) }
   const json = JSON.stringify(body)
@@ -56,7 +56,7 @@ test('bodyLimit is applied to decoded content', t => {
   const fastify = Fastify()
 
   fastify.addHook('preParsing', async (req, reply, payload) => {
-    t.equal(req.headers['content-length'], `${encoded.length}`)
+    t.assert.strictEqual(req.headers['content-length'], `${encoded.length}`)
     const unzip = zlib.createGunzip()
     Object.defineProperty(unzip, 'receivedEncodedLength', {
       get () {
@@ -79,53 +79,53 @@ test('bodyLimit is applied to decoded content', t => {
   fastify.post('/body-limit-20k', {
     bodyLimit: 20000,
     onError: async (req, res, err) => {
-      t.equal(err.code, 'FST_ERR_CTP_BODY_TOO_LARGE')
-      t.equal(err.statusCode, 413)
+      t.assert.strictEqual(err.code, 'FST_ERR_CTP_BODY_TOO_LARGE')
+      t.assert.strictEqual(err.statusCode, 413)
     }
   }, (request, reply) => {
     reply.send({ x: 'handler should not be called' })
   })
 
-  fastify.inject({
-    method: 'POST',
-    url: '/body-limit-40k',
-    headers: {
-      'content-encoding': 'gzip',
-      'content-type': 'application/json'
-    },
-    payload: encoded
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(res.json(), body)
+  await t.test('bodyLimit 40k', async (t) => {
+    const result = await fastify.inject({
+      method: 'POST',
+      url: '/body-limit-40k',
+      headers: {
+        'content-encoding': 'gzip',
+        'content-type': 'application/json'
+      },
+      payload: encoded
+    })
+    t.assert.strictEqual(result.statusCode, 200)
+    t.assert.deepStrictEqual(result.json(), body)
   })
 
-  fastify.inject({
-    method: 'POST',
-    url: '/body-limit-20k',
-    headers: {
-      'content-encoding': 'gzip',
-      'content-type': 'application/json'
-    },
-    payload: encoded
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 413)
+  await t.test('bodyLimit 20k', async (t) => {
+    const result = await fastify.inject({
+      method: 'POST',
+      url: '/body-limit-20k',
+      headers: {
+        'content-encoding': 'gzip',
+        'content-type': 'application/json'
+      },
+      payload: encoded
+    })
+    t.assert.strictEqual(result.statusCode, 413)
   })
 })
 
-test('default request.routeOptions.bodyLimit should be 1048576', t => {
+test('default request.routeOptions.bodyLimit should be 1048576', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
   fastify.post('/default-bodylimit', {
     handler (request, reply) {
-      t.equal(1048576, request.routeOptions.bodyLimit)
+      t.assert.strictEqual(1048576, request.routeOptions.bodyLimit)
       reply.send({ })
     }
   })
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'POST',
@@ -134,25 +134,26 @@ test('default request.routeOptions.bodyLimit should be 1048576', t => {
       body: [],
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
 })
 
-test('request.routeOptions.bodyLimit should be equal to route limit', t => {
+test('request.routeOptions.bodyLimit should be equal to route limit', (t, done) => {
   t.plan(4)
   const fastify = Fastify({ bodyLimit: 1 })
   fastify.post('/route-limit', {
     bodyLimit: 1000,
     handler (request, reply) {
-      t.equal(1000, request.routeOptions.bodyLimit)
+      t.assert.strictEqual(1000, request.routeOptions.bodyLimit)
       reply.send({})
     }
   })
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'POST',
@@ -161,24 +162,25 @@ test('request.routeOptions.bodyLimit should be equal to route limit', t => {
       body: [],
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
 })
 
-test('request.routeOptions.bodyLimit should be equal to server limit', t => {
+test('request.routeOptions.bodyLimit should be equal to server limit', (t, done) => {
   t.plan(4)
   const fastify = Fastify({ bodyLimit: 100 })
   fastify.post('/server-limit', {
     handler (request, reply) {
-      t.equal(100, request.routeOptions.bodyLimit)
+      t.assert.strictEqual(100, request.routeOptions.bodyLimit)
       reply.send({})
     }
   })
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'POST',
@@ -187,8 +189,9 @@ test('request.routeOptions.bodyLimit should be equal to server limit', t => {
       body: [],
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
 })

package/test/buffer.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 
 test('Buffer test', async t => {
@@ -12,7 +11,7 @@ test('Buffer test', async t => {
     return request.body
   })
 
-  test('should return 200 if the body is not empty', async t => {
+  await test('should return 200 if the body is not empty', async t => {
     t.plan(3)
 
     const response = await fastify.inject({
@@ -24,12 +23,12 @@ test('Buffer test', async t => {
       }
     })
 
-    t.error(response.error)
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), '{"hello":"world"}')
+    t.assert.ifError(response.error)
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), '{"hello":"world"}')
   })
 
-  test('should return 400 if the body is empty', async t => {
+  await test('should return 400 if the body is empty', async t => {
     t.plan(3)
 
     const response = await fastify.inject({
@@ -41,9 +40,9 @@ test('Buffer test', async t => {
       }
     })
 
-    t.error(response.error)
-    t.equal(response.statusCode, 400)
-    t.same(JSON.parse(response.payload.toString()), {
+    t.assert.ifError(response.error)
+    t.assert.strictEqual(response.statusCode, 400)
+    t.assert.deepStrictEqual(JSON.parse(response.payload.toString()), {
       error: 'Bad Request',
       code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
       message: 'Body cannot be empty when content-type is set to \'application/json\'',

package/test/build/error-serializer.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fs = require('node:fs')
 const path = require('node:path')
 const { loadESLint } = require('eslint')
@@ -22,7 +21,7 @@ test('check generated code syntax', async (t) => {
 
   // if there are any invalid syntax
   // fatal count will be greater than 0
-  t.equal(result[0].fatalErrorCount, 0)
+  t.assert.strictEqual(result[0].fatalErrorCount, 0)
 })
 
 const isPrepublish = !!process.env.PREPUBLISH
@@ -33,5 +32,5 @@ test('ensure the current error serializer is latest', { skip: !isPrepublish }, a
   const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))
 
   // line break should not be a problem depends on system
-  t.equal(unifyLineBreak(current), unifyLineBreak(code))
+  t.assert.strictEqual(unifyLineBreak(current), unifyLineBreak(code))
 })

package/test/build/version.test.js

@@ -2,8 +2,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fastify = require('../../fastify')()
 
 test('should be the same as package.json', t => {
@@ -11,5 +10,5 @@ test('should be the same as package.json', t => {
 
   const json = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json')).toString('utf8'))
 
-  t.equal(fastify.version, json.version)
+  t.assert.strictEqual(fastify.version, json.version)
 })

package/test/build-certificate.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const os = require('os')
+const os = require('node:os')
 const forge = require('node-forge')
 
 // from self-cert module

package/test/bundler/README.md

@@ -1,12 +1,12 @@
 # Bundlers test stack
 
-In some cases, developers bundle their apps for several targets such as serverless applications. 
-Even if it's not recommended by Fastify team; we need to ensure we do not break the build process. 
+In some cases, developers bundle their apps for several targets such as serverless applications.
+Even if it's not recommended by Fastify team; we need to ensure we do not break the build process.
 Please note this might result in features behaving differently, like the version handling check for plugins.
 
 ## Test bundlers
 
-The bundler test stack has been defined separately from the rest of the Unit testing stack because it's not a 
+The bundler test stack has been defined separately from the rest of the Unit testing stack because it's not a
 part of the fastify lib itself. Note that the tests run in CI only on NodeJs LTS version.
 Developers do not need to install every bundler to run unit tests.
 
@@ -23,7 +23,7 @@ stack dependencies. See:
 
 ## Bundler test development
 
-To not break the fastify unit testing stack please name test files like this `*-test.js` and not `*.test.js`, 
+To not break the fastify unit testing stack please name test files like this `*-test.js` and not `*.test.js`,
 otherwise it will be targeted by the regular expression used for unit tests for fastify.
-Tests need to ensure the build process works and the fastify application can be run, 
+Tests need to ensure the build process works and the fastify application can be run,
 no need to go in deep testing unless an issue is raised.

package/test/bundler/esbuild/bundler-test.js

@@ -1,31 +1,32 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fastifySuccess = require('./dist/success')
 const fastifyFailPlugin = require('./dist/failPlugin')
 
-test('Bundled package should work', (t) => {
+test('Bundled package should work', (t, done) => {
   t.plan(4)
   fastifySuccess.ready((err) => {
-    t.error(err)
+    t.assert.ifError(err)
     fastifySuccess.inject(
       {
         method: 'GET',
         url: '/'
       },
       (error, res) => {
-        t.error(error)
-        t.equal(res.statusCode, 200)
-        t.same(res.json(), { hello: 'world' })
+        t.assert.ifError(error)
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.deepStrictEqual(res.json(), { hello: 'world' })
+        done()
       }
     )
   })
 })
 
-test('Bundled package should not work with bad plugin version', (t) => {
+test('Bundled package should not work with bad plugin version', (t, done) => {
   t.plan(1)
   fastifyFailPlugin.ready((err) => {
-    t.match(err.message, /expected '9.x' fastify version/i)
+    t.assert.match(err.message, /expected '9.x' fastify version/i)
+    done()
   })
 })

package/test/bundler/webpack/bundler-test.js

@@ -1,31 +1,32 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fastifySuccess = require('./dist/success')
 const fastifyFailPlugin = require('./dist/failPlugin')
 
-test('Bundled package should work', (t) => {
+test('Bundled package should work', (t, done) => {
   t.plan(4)
   fastifySuccess.ready((err) => {
-    t.error(err)
+    t.assert.ifError(err)
     fastifySuccess.inject(
       {
         method: 'GET',
         url: '/'
       },
       (error, res) => {
-        t.error(error)
-        t.equal(res.statusCode, 200)
-        t.same(res.json(), { hello: 'world' })
+        t.assert.ifError(error)
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.deepStrictEqual(res.json(), { hello: 'world' })
+        done()
       }
     )
   })
 })
 
-test('Bundled package should not work with bad plugin version', (t) => {
+test('Bundled package should not work with bad plugin version', (t, done) => {
   t.plan(1)
   fastifyFailPlugin.ready((err) => {
-    t.match(err.message, /expected '9.x' fastify version/i)
+    t.assert.match(err.message, /expected '9.x' fastify version/i)
+    done()
   })
 })