fastify 5.0.0 → 5.2.0

package/test/internals/{handleRequest.test.js → handle-request.test.js}

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const handleRequest = require('../../lib/handleRequest')
 const internals = require('../../lib/handleRequest')[Symbol.for('internals')]
 const Request = require('../../lib/request')
@@ -28,14 +28,14 @@ test('handleRequest function - sent reply', t => {
   const request = {}
   const reply = { sent: true }
   const res = handleRequest(null, request, reply)
-  t.equal(res, undefined)
+  t.assert.strictEqual(res, undefined)
 })
 
 test('handleRequest function - invoke with error', t => {
   t.plan(1)
   const request = {}
   const reply = {}
-  reply.send = (err) => t.equal(err.message, 'Kaboom')
+  reply.send = (err) => t.assert.strictEqual(err.message, 'Kaboom')
   handleRequest(new Error('Kaboom'), request, reply)
 })
 
@@ -56,7 +56,7 @@ test('handler function - invalid schema', t => {
         }
       }
     },
-    errorHandler: { func: () => { t.pass('errorHandler called') } },
+    errorHandler: { func: () => { t.assert.ok('errorHandler called') } },
     handler: () => {},
     Reply,
     Request,
@@ -79,13 +79,13 @@ test('handler function - reply', t => {
   t.plan(3)
   const res = {}
   res.end = () => {
-    t.equal(res.statusCode, 204)
-    t.pass()
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.ok(true)
   }
   res.writeHead = () => {}
   const context = {
     handler: (req, reply) => {
-      t.equal(typeof reply, 'object')
+      t.assert.strictEqual(typeof reply, 'object')
       reply.code(204)
       reply.send(undefined)
     },
@@ -110,12 +110,12 @@ test('handler function - preValidationCallback with finished response', t => {
   // Be sure to check only `writableEnded` where is available
   res.writableEnded = true
   res.end = () => {
-    t.fail()
+    t.assert.fail()
   }
   res.writeHead = () => {}
   const context = {
     handler: (req, reply) => {
-      t.fail()
+      t.assert.fail()
       reply.send(undefined)
     },
     Reply,
@@ -129,25 +129,28 @@ test('handler function - preValidationCallback with finished response', t => {
   internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))
 })
 
-test('request should be defined in onSend Hook on post request with content type application/json', t => {
+test('request should be defined in onSend Hook on post request with content type application/json', (t, done) => {
   t.plan(8)
   const fastify = require('../..')()
 
+  t.after(() => {
+    fastify.close()
+  })
+
   fastify.addHook('onSend', (request, reply, payload, done) => {
-    t.ok(request)
-    t.ok(request.raw)
-    t.ok(request.id)
-    t.ok(request.params)
-    t.ok(request.query)
+    t.assert.ok(request)
+    t.assert.ok(request.raw)
+    t.assert.ok(request.id)
+    t.assert.ok(request.params)
+    t.assert.ok(request.query)
     done()
   })
   fastify.post('/', (request, reply) => {
     reply.send(200)
   })
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
 
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
     sget({
       method: 'POST',
       url: 'http://localhost:' + fastify.server.address().port,
@@ -155,30 +158,33 @@ test('request should be defined in onSend Hook on post request with content type
         'content-type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
+      t.assert.ifError(err)
       // a 400 error is expected because of no body
-      t.equal(response.statusCode, 400)
+      t.assert.strictEqual(response.statusCode, 400)
+      done()
     })
   })
 })
 
-test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', t => {
+test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', (t, done) => {
   t.plan(7)
   const fastify = require('../..')()
 
+  t.after(() => { fastify.close() })
+
   fastify.addHook('onSend', (request, reply, payload, done) => {
-    t.ok(request)
-    t.ok(request.raw)
-    t.ok(request.params)
-    t.ok(request.query)
+    t.assert.ok(request)
+    t.assert.ok(request.raw)
+    t.assert.ok(request.params)
+    t.assert.ok(request.query)
     done()
   })
   fastify.post('/', (request, reply) => {
     reply.send(200)
   })
+
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -187,30 +193,33 @@ test('request should be defined in onSend Hook on post request with content type
         'content-type': 'application/x-www-form-urlencoded'
       }
     }, (err, response, body) => {
-      t.error(err)
+      t.assert.ifError(err)
       // a 415 error is expected because of missing content type parser
-      t.equal(response.statusCode, 415)
+      t.assert.strictEqual(response.statusCode, 415)
+      done()
     })
   })
 })
 
-test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', t => {
+test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', (t, done) => {
   t.plan(7)
   const fastify = require('../..')()
 
+  t.after(() => { fastify.close() })
+
   fastify.addHook('onSend', (request, reply, payload, done) => {
-    t.ok(request)
-    t.ok(request.raw)
-    t.ok(request.params)
-    t.ok(request.query)
+    t.assert.ok(request)
+    t.assert.ok(request.raw)
+    t.assert.ok(request.params)
+    t.assert.ok(request.query)
     done()
   })
   fastify.options('/', (request, reply) => {
     reply.send(200)
   })
+
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
 
     sget({
       method: 'OPTIONS',
@@ -219,14 +228,15 @@ test('request should be defined in onSend Hook on options request with content t
         'content-type': 'application/x-www-form-urlencoded'
       }
     }, (err, response, body) => {
-      t.error(err)
+      t.assert.ifError(err)
       // Body parsing skipped, so no body sent
-      t.equal(response.statusCode, 200)
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
 })
 
-test('request should respond with an error if an unserialized payload is sent inside an async handler', t => {
+test('request should respond with an error if an unserialized payload is sent inside an async handler', (t, done) => {
   t.plan(3)
 
   const fastify = require('../..')()
@@ -240,13 +250,14 @@ test('request should respond with an error if an unserialized payload is sent in
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.strictSame(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       code: 'FST_ERR_REP_INVALID_PAYLOAD_TYPE',
       message: 'Attempted to send payload of invalid type \'object\'. Expected a string or Buffer.',
       statusCode: 500
     })
+    done()
   })
 })

package/test/internals/{hookRunner.test.js → hook-runner.test.js}

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const { hookRunnerGenerator, onSendHookRunner } = require('../../lib/hooks')
 
 test('hookRunner - Basic', t => {
@@ -16,27 +15,27 @@ test('hookRunner - Basic', t => {
   }
 
   function fn1 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function fn2 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function fn3 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function done (err, a, b) {
-    t.error(err)
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.ifError(err)
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
   }
 })
 
@@ -52,25 +51,25 @@ test('hookRunner - In case of error should skip to done', t => {
   }
 
   function fn1 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function fn2 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done(new Error('kaboom'))
   }
 
   function fn3 () {
-    t.fail('We should not be here')
+    t.assert.fail('We should not be here')
   }
 
   function done (err, a, b) {
-    t.equal(err.message, 'kaboom')
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(err.message, 'kaboom')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
   }
 })
 
@@ -86,25 +85,25 @@ test('hookRunner - Should handle throw', t => {
   }
 
   function fn1 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function fn2 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     throw new Error('kaboom')
   }
 
   function fn3 () {
-    t.fail('We should not be here')
+    t.assert.fail('We should not be here')
   }
 
   function done (err, a, b) {
-    t.equal(err.message, 'kaboom')
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(err.message, 'kaboom')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
   }
 })
 
@@ -120,27 +119,27 @@ test('hookRunner - Should handle promises', t => {
   }
 
   function fn1 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     return Promise.resolve()
   }
 
   function fn2 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     return Promise.resolve()
   }
 
   function fn3 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     return Promise.resolve()
   }
 
   function done (err, a, b) {
-    t.error(err)
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.ifError(err)
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
   }
 })
 
@@ -156,25 +155,25 @@ test('hookRunner - In case of error should skip to done (with promises)', t => {
   }
 
   function fn1 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     return Promise.resolve()
   }
 
   function fn2 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     return Promise.reject(new Error('kaboom'))
   }
 
   function fn3 () {
-    t.fail('We should not be here')
+    t.assert.fail('We should not be here')
   }
 
   function done (err, a, b) {
-    t.equal(err.message, 'kaboom')
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(err.message, 'kaboom')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
   }
 })
 
@@ -194,24 +193,24 @@ test('hookRunner - Be able to exit before its natural end', t => {
   }
 
   function fn1 (a, b, done) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     done()
   }
 
   function fn2 (a, b) {
-    t.equal(a, 'a')
-    t.equal(b, 'b')
+    t.assert.strictEqual(a, 'a')
+    t.assert.strictEqual(b, 'b')
     shouldStop = true
     return Promise.resolve()
   }
 
   function fn3 () {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   }
 
   function done () {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   }
 })
 
@@ -229,23 +228,23 @@ test('hookRunner - Promises that resolve to a value do not change the state', t
   }
 
   function fn1 (state, b, done) {
-    t.equal(state, originalState)
+    t.assert.strictEqual(state, originalState)
     return Promise.resolve(null)
   }
 
   function fn2 (state, b, done) {
-    t.equal(state, originalState)
+    t.assert.strictEqual(state, originalState)
     return Promise.resolve('string')
   }
 
   function fn3 (state, b, done) {
-    t.equal(state, originalState)
+    t.assert.strictEqual(state, originalState)
     return Promise.resolve({ object: true })
   }
 
   function done (err, state, b) {
-    t.error(err)
-    t.equal(state, originalState)
+    t.assert.ifError(err)
+    t.assert.strictEqual(state, originalState)
   }
 })
 
@@ -259,31 +258,31 @@ test('onSendHookRunner - Basic', t => {
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, originalPayload, done)
 
   function fn1 (request, reply, payload, done) {
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.equal(payload, originalPayload)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.strictEqual(payload, originalPayload)
     done()
   }
 
   function fn2 (request, reply, payload, done) {
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.equal(payload, originalPayload)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.strictEqual(payload, originalPayload)
     done()
   }
 
   function fn3 (request, reply, payload, done) {
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.equal(payload, originalPayload)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.strictEqual(payload, originalPayload)
     done()
   }
 
   function done (err, request, reply, payload) {
-    t.error(err)
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.equal(payload, originalPayload)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.strictEqual(payload, originalPayload)
   }
 })
 
@@ -300,25 +299,25 @@ test('onSendHookRunner - Can change the payload', t => {
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
   function fn1 (request, reply, payload, done) {
-    t.same(payload, v1)
+    t.assert.deepStrictEqual(payload, v1)
     done(null, v2)
   }
 
   function fn2 (request, reply, payload, done) {
-    t.same(payload, v2)
+    t.assert.deepStrictEqual(payload, v2)
     done(null, v3)
   }
 
   function fn3 (request, reply, payload, done) {
-    t.same(payload, v3)
+    t.assert.deepStrictEqual(payload, v3)
     done(null, v4)
   }
 
   function done (err, request, reply, payload) {
-    t.error(err)
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.same(payload, v4)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.deepStrictEqual(payload, v4)
   }
 })
 
@@ -333,24 +332,24 @@ test('onSendHookRunner - In case of error should skip to done', t => {
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
   function fn1 (request, reply, payload, done) {
-    t.same(payload, v1)
+    t.assert.deepStrictEqual(payload, v1)
     done(null, v2)
   }
 
   function fn2 (request, reply, payload, done) {
-    t.same(payload, v2)
+    t.assert.deepStrictEqual(payload, v2)
     done(new Error('kaboom'))
   }
 
   function fn3 () {
-    t.fail('We should not be here')
+    t.assert.fail('We should not be here')
   }
 
   function done (err, request, reply, payload) {
-    t.equal(err.message, 'kaboom')
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.same(payload, v2)
+    t.assert.strictEqual(err.message, 'kaboom')
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.deepStrictEqual(payload, v2)
   }
 })
 
@@ -367,25 +366,25 @@ test('onSendHookRunner - Should handle promises', t => {
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
   function fn1 (request, reply, payload) {
-    t.same(payload, v1)
+    t.assert.deepStrictEqual(payload, v1)
     return Promise.resolve(v2)
   }
 
   function fn2 (request, reply, payload) {
-    t.same(payload, v2)
+    t.assert.deepStrictEqual(payload, v2)
     return Promise.resolve(v3)
   }
 
   function fn3 (request, reply, payload) {
-    t.same(payload, v3)
+    t.assert.deepStrictEqual(payload, v3)
     return Promise.resolve(v4)
   }
 
   function done (err, request, reply, payload) {
-    t.error(err)
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.same(payload, v4)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.deepStrictEqual(payload, v4)
   }
 })
 
@@ -400,24 +399,24 @@ test('onSendHookRunner - In case of error should skip to done (with promises)',
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
   function fn1 (request, reply, payload) {
-    t.same(payload, v1)
+    t.assert.deepStrictEqual(payload, v1)
     return Promise.resolve(v2)
   }
 
   function fn2 (request, reply, payload) {
-    t.same(payload, v2)
+    t.assert.deepStrictEqual(payload, v2)
     return Promise.reject(new Error('kaboom'))
   }
 
   function fn3 () {
-    t.fail('We should not be here')
+    t.assert.fail('We should not be here')
   }
 
   function done (err, request, reply, payload) {
-    t.equal(err.message, 'kaboom')
-    t.same(request, originalRequest)
-    t.same(reply, originalReply)
-    t.same(payload, v2)
+    t.assert.strictEqual(err.message, 'kaboom')
+    t.assert.deepStrictEqual(request, originalRequest)
+    t.assert.deepStrictEqual(reply, originalReply)
+    t.assert.deepStrictEqual(payload, v2)
   }
 })
 
@@ -432,19 +431,19 @@ test('onSendHookRunner - Be able to exit before its natural end', t => {
   onSendHookRunner([fn1, fn2, fn3], originalRequest, originalReply, v1, done)
 
   function fn1 (request, reply, payload, done) {
-    t.same(payload, v1)
+    t.assert.deepStrictEqual(payload, v1)
     done(null, v2)
   }
 
   function fn2 (request, reply, payload) {
-    t.same(payload, v2)
+    t.assert.deepStrictEqual(payload, v2)
   }
 
   function fn3 () {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   }
 
   function done () {
-    t.fail('this should not be called')
+    t.assert.fail('this should not be called')
   }
 })