fastify 5.0.0 → 5.2.0

package/test/content-type.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('should remove content-type for setErrorHandler', async t => {
@@ -10,22 +9,22 @@ test('should remove content-type for setErrorHandler', async t => {
 
   const fastify = Fastify()
   fastify.setErrorHandler(function (error, request, reply) {
-    t.same(error.message, 'kaboom')
-    t.same(reply.hasHeader('content-type'), false)
+    t.assert.strictEqual(error.message, 'kaboom')
+    t.assert.strictEqual(reply.hasHeader('content-type'), false)
     reply.code(400).send({ foo: 'bar' })
   })
   fastify.addHook('onSend', async function (request, reply, payload) {
     count++
-    t.same(typeof payload, 'string')
+    t.assert.strictEqual(typeof payload, 'string')
     switch (count) {
       case 1: {
         // should guess the correct content-type based on payload
-        t.same(reply.getHeader('content-type'), 'text/plain; charset=utf-8')
+        t.assert.strictEqual(reply.getHeader('content-type'), 'text/plain; charset=utf-8')
         throw Error('kaboom')
       }
       case 2: {
         // should guess the correct content-type based on payload
-        t.same(reply.getHeader('content-type'), 'application/json; charset=utf-8')
+        t.assert.strictEqual(reply.getHeader('content-type'), 'application/json; charset=utf-8')
         return payload
       }
       default: {
@@ -38,6 +37,6 @@ test('should remove content-type for setErrorHandler', async t => {
   })
 
   const { statusCode, body } = await fastify.inject({ method: 'GET', path: '/' })
-  t.same(statusCode, 400)
-  t.same(body, JSON.stringify({ foo: 'bar' }))
+  t.assert.strictEqual(statusCode, 400)
+  t.assert.strictEqual(body, JSON.stringify({ foo: 'bar' }))
 })

package/test/context-config.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
+
 const { kRouteContext } = require('../lib/symbols')
 const Fastify = require('..')
 
@@ -17,8 +17,8 @@ function handler (req, reply) {
   reply.send(reply[kRouteContext].config)
 }
 
-test('config', t => {
-  t.plan(9)
+test('config', async t => {
+  t.plan(6)
   const fastify = Fastify()
 
   fastify.get('/get', {
@@ -41,36 +41,33 @@ test('config', t => {
     handler
   })
 
-  fastify.inject({
+  let response = await fastify.inject({
     method: 'GET',
-    url: '/get'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+    url: '/route'
   })
 
-  fastify.inject({
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
     method: 'GET',
     url: '/route'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/route', method: 'GET' }, schema.config))
   })
 
-  fastify.inject({
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
     method: 'GET',
     url: '/no-config'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), { url: '/no-config', method: 'GET' })
   })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
 })
 
-test('config with exposeHeadRoutes', t => {
-  t.plan(9)
+test('config with exposeHeadRoutes', async t => {
+  t.plan(6)
   const fastify = Fastify({ exposeHeadRoutes: true })
 
   fastify.get('/get', {
@@ -93,36 +90,33 @@ test('config with exposeHeadRoutes', t => {
     handler
   })
 
-  fastify.inject({
+  let response = await fastify.inject({
     method: 'GET',
     url: '/get'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/get', method: 'GET' }, schema.config))
   })
 
-  fastify.inject({
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
     method: 'GET',
     url: '/route'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/route', method: 'GET' }, schema.config))
   })
 
-  fastify.inject({
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
     method: 'GET',
     url: '/no-config'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), { url: '/no-config', method: 'GET' })
   })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
 })
 
-test('config without exposeHeadRoutes', t => {
-  t.plan(9)
+test('config without exposeHeadRoutes', async t => {
+  t.plan(6)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   fastify.get('/get', {
@@ -145,30 +139,26 @@ test('config without exposeHeadRoutes', t => {
     handler
   })
 
-  fastify.inject({
+  let response = await fastify.inject({
     method: 'GET',
     url: '/get'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/get', method: 'GET' }, schema.config))
   })
 
-  fastify.inject({
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
     method: 'GET',
     url: '/route'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), Object.assign({ url: '/route', method: 'GET' }, schema.config))
   })
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
 
-  fastify.inject({
+  response = await fastify.inject({
     method: 'GET',
     url: '/no-config'
-  }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(JSON.parse(response.payload), { url: '/no-config', method: 'GET' })
   })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
 })

package/test/custom-http-server.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const http = require('node:http')
 const dns = require('node:dns').promises
 const sget = require('simple-get').concat
@@ -16,7 +15,7 @@ async function setup () {
 
     const fastify = Fastify({
       serverFactory: (handler, opts) => {
-        t.ok(opts.serverFactory, 'it is called once for localhost')
+        t.assert.ok(opts.serverFactory, 'it is called once for localhost')
 
         const server = http.createServer((req, res) => {
           req.custom = true
@@ -27,10 +26,9 @@ async function setup () {
       }
     })
 
-    t.teardown(fastify.close.bind(fastify))
-
+    t.after(() => fastify.close())
     fastify.get('/', (req, reply) => {
-      t.ok(req.raw.custom)
+      t.assert.ok(req.raw.custom)
       reply.send({ hello: 'world' })
     })
 
@@ -45,8 +43,8 @@ async function setup () {
         if (err) {
           return reject(err)
         }
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
         resolve()
       })
     })
@@ -55,7 +53,7 @@ async function setup () {
   test('Should not allow forceCloseConnection=idle if the server does not support closeIdleConnections', t => {
     t.plan(1)
 
-    t.throws(
+    t.assert.throws(
       () => {
         Fastify({
           forceCloseConnections: 'idle',
@@ -75,13 +73,11 @@ async function setup () {
 
   test('Should accept user defined serverFactory and ignore secondary server creation', async t => {
     const server = http.createServer(() => { })
-    t.teardown(() => new Promise(resolve => server.close(resolve)))
-    const app = await Fastify({
+    t.after(() => new Promise(resolve => server.close(resolve)))
+    const app = Fastify({
       serverFactory: () => server
     })
-    t.resolves(async () => {
-      await app.listen({ port: 0 })
-    })
+    await t.assert.doesNotReject(async () => { await app.listen({ port: 0 }) })
   })
 
   test('Should not call close on the server if it has not created it', async t => {
@@ -107,12 +103,12 @@ async function setup () {
     })
 
     const address = server.address()
-    t.equal(server.listening, true)
+    t.assert.strictEqual(server.listening, true)
     await fastify.close()
 
-    t.equal(server.listening, true)
-    t.same(server.address(), address)
-    t.same(fastify.addresses(), [address])
+    t.assert.strictEqual(server.listening, true)
+    t.assert.deepStrictEqual(server.address(), address)
+    t.assert.deepStrictEqual(fastify.addresses(), [address])
 
     await new Promise((resolve, reject) => {
       server.close((err) => {
@@ -122,8 +118,8 @@ async function setup () {
         resolve()
       })
     })
-    t.equal(server.listening, false)
-    t.same(server.address(), null)
+    t.assert.strictEqual(server.listening, false)
+    t.assert.deepStrictEqual(server.address(), null)
   })
 }
 

package/test/custom-parser.5.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const jsonParser = require('fast-json-body')
@@ -9,35 +8,34 @@ const { getServerUrl, plainTextParser } = require('./helper')
 
 process.removeAllListeners('warning')
 
-test('cannot remove all content type parsers after binding', t => {
+test('cannot remove all content type parsers after binding', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
 
-  t.teardown(fastify.close.bind(fastify))
-
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-
-    t.throws(() => fastify.removeAllContentTypeParsers())
+    t.assert.ifError(err)
+    t.assert.throws(() => fastify.removeAllContentTypeParsers())
+    fastify.close()
+    done()
   })
 })
 
-test('cannot remove content type parsers after binding', t => {
+test('cannot remove content type parsers after binding', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-
-    t.throws(() => fastify.removeContentTypeParser('application/json'))
+    t.assert.ifError(err)
+    t.assert.throws(() => fastify.removeContentTypeParser('application/json'))
+    done()
   })
 })
 
-test('should be able to override the default json parser after removeAllContentTypeParsers', t => {
+test('should be able to override the default json parser after removeAllContentTypeParsers', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -49,14 +47,14 @@ test('should be able to override the default json parser after removeAllContentT
   fastify.removeAllContentTypeParsers()
 
   fastify.addContentTypeParser('application/json', function (req, payload, done) {
-    t.ok('called')
+    t.assert.ok('called')
     jsonParser(payload, function (err, body) {
       done(err, body)
     })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -66,15 +64,16 @@ test('should be able to override the default json parser after removeAllContentT
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
       fastify.close()
+      done()
     })
   })
 })
 
-test('should be able to override the default plain text parser after removeAllContentTypeParsers', t => {
+test('should be able to override the default plain text parser after removeAllContentTypeParsers', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -86,14 +85,14 @@ test('should be able to override the default plain text parser after removeAllCo
   fastify.removeAllContentTypeParsers()
 
   fastify.addContentTypeParser('text/plain', function (req, payload, done) {
-    t.ok('called')
+    t.assert.ok('called')
     plainTextParser(payload, function (err, body) {
       done(err, body)
     })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -103,15 +102,16 @@ test('should be able to override the default plain text parser after removeAllCo
         'Content-Type': 'text/plain'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(body.toString(), 'hello world')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(body.toString(), 'hello world')
       fastify.close()
+      done()
     })
   })
 })
 
-test('should be able to add a custom content type parser after removeAllContentTypeParsers', t => {
+test('should be able to add a custom content type parser after removeAllContentTypeParsers', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -121,16 +121,15 @@ test('should be able to add a custom content type parser after removeAllContentT
   })
 
   fastify.removeAllContentTypeParsers()
-
   fastify.addContentTypeParser('application/jsoff', function (req, payload, done) {
-    t.ok('called')
+    t.assert.ok('called')
     jsonParser(payload, function (err, body) {
       done(err, body)
     })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -140,10 +139,11 @@ test('should be able to add a custom content type parser after removeAllContentT
         'Content-Type': 'application/jsoff'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
       fastify.close()
+      done()
     })
   })
 })

package/test/diagnostics-channel/404.test.js

@@ -1,35 +1,34 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const test = t.test
 const sget = require('simple-get').concat
 const Fastify = require('../..')
 const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel sync events fire in expected order', t => {
+test('diagnostics channel sync events fire in expected order', (t, done) => {
   t.plan(9)
   let callOrder = 0
   let firstEncounteredMessage
 
   diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
-    t.equal(callOrder++, 0)
+    t.assert.strictEqual(callOrder++, 0)
     firstEncounteredMessage = msg
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
-    t.equal(callOrder++, 1)
-    t.equal(msg, firstEncounteredMessage)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
-    t.fail('should not trigger error channel')
+    t.assert.fail('should not trigger error channel')
   })
 
   const fastify = Fastify()
@@ -42,16 +41,17 @@ test('diagnostics channel sync events fire in expected order', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    if (err) t.error(err)
+    if (err) t.assert.ifError(err)
 
-    t.teardown(() => { fastify.close() })
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
       url: getServerUrl(fastify) + '/'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 404)
+      done()
     })
   })
 })

package/test/diagnostics-channel/async-delay-request.test.js

@@ -1,50 +1,49 @@
 'use strict'
 
-const t = require('tap')
 const diagnostics = require('node:diagnostics_channel')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('../..')
 const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel async events fire in expected order', t => {
+test('diagnostics channel async events fire in expected order', (t, done) => {
   t.plan(19)
   let callOrder = 0
   let firstEncounteredMessage
 
   diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
-    t.equal(callOrder++, 0)
+    t.assert.strictEqual(callOrder++, 0)
     firstEncounteredMessage = msg
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
-    t.equal(callOrder++, 1)
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
-    t.equal(msg, firstEncounteredMessage)
-    t.equal(msg.async, true)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    t.assert.strictEqual(msg.async, true)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:asyncStart', (msg) => {
-    t.equal(callOrder++, 2)
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
-    t.equal(msg, firstEncounteredMessage)
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:asyncEnd', (msg) => {
-    t.equal(callOrder++, 3)
-    t.ok(msg.request instanceof Request)
-    t.ok(msg.reply instanceof Reply)
-    t.equal(msg, firstEncounteredMessage)
+    t.assert.strictEqual(callOrder++, 3)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
   })
 
   diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
-    t.fail('should not trigger error channel')
+    t.assert.fail('should not trigger error channel')
   })
 
   const fastify = Fastify()
@@ -58,17 +57,18 @@ test('diagnostics channel async events fire in expected order', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    if (err) t.error(err)
+    if (err) t.assert.ifError(err)
 
-    t.teardown(() => { fastify.close() })
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
       url: getServerUrl(fastify) + '/'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), { hello: 'world' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      done()
     })
   })
 })