fastify 5.3.2 → 5.4.0

package/test/input-validation.js

@@ -4,6 +4,7 @@ const sget = require('simple-get').concat
 const Ajv = require('ajv')
 const Joi = require('joi')
 const yup = require('yup')
+const assert = require('node:assert')
 
 module.exports.payloadMethod = function (method, t) {
   const test = t.test
@@ -127,28 +128,27 @@ module.exports.payloadMethod = function (method, t) {
 
         done()
       })
-      t.pass()
+      t.assert.ok(true)
     } catch (e) {
-      t.fail()
+      t.assert.fail()
     }
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    if (err) {
-      t.error(err)
-    }
+    assert.ifError(err)
 
-    t.teardown(() => { fastify.close() })
+    t.after(() => { fastify.close() })
 
-    test(`${upMethod} - correctly replies`, t => {
+    test(`${upMethod} - correctly replies`, (t, testDone) => {
       if (upMethod === 'HEAD') {
         t.plan(2)
         sget({
           method: upMethod,
           url: 'http://localhost:' + fastify.server.address().port
         }, (err, response) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          testDone()
         })
       } else {
         t.plan(3)
@@ -160,14 +160,15 @@ module.exports.payloadMethod = function (method, t) {
           },
           json: true
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.same(body, { hello: 42 })
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          t.assert.deepStrictEqual(body, { hello: 42 })
+          testDone()
         })
       }
     })
 
-    test(`${upMethod} - 400 on bad parameters`, t => {
+    test(`${upMethod} - 400 on bad parameters`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -177,18 +178,19 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'body/hello must be integer',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation coerce`, t => {
+    test(`${upMethod} - input-validation coerce`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -198,13 +200,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: 42 })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler`, t => {
+    test(`${upMethod} - input-validation custom schema compiler`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -215,13 +218,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: 42 })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ok`, t => {
+    test(`${upMethod} - input-validation joi schema compiler ok`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -231,13 +235,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: '42' })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ko`, t => {
+    test(`${upMethod} - input-validation joi schema compiler ko`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -247,18 +252,19 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: '"hello" must be a string',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ok`, t => {
+    test(`${upMethod} - input-validation yup schema compiler ok`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -268,13 +274,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: '42' })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ko`, t => {
+    test(`${upMethod} - input-validation yup schema compiler ko`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -284,52 +291,55 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.match(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
-          message: /body hello must be a `string` type, but the final value was: `44`./,
+          message: 'body hello must be a `string` type, but the final value was: `44`.',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, t => {
+    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
         url: 'http://localhost:' + fastify.server.address().port + '/plugin',
-        body: { },
+        body: {},
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'From custom schema compiler!',
-          statusCode: '400',
+          statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler encapsulated`, t => {
+    test(`${upMethod} - input-validation custom schema compiler encapsulated`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
         url: 'http://localhost:' + fastify.server.address().port + '/plugin/custom',
-        body: { },
+        body: {},
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'Always fail!',
-          statusCode: '400',
+          statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
   })

package/test/internals/errors.test.js

@@ -580,16 +580,6 @@ test('FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX', t => {
   t.assert.ok(error instanceof Error)
 })
 
-test('FST_ERR_HTTP2_INVALID_VERSION', t => {
-  t.plan(5)
-  const error = new errors.FST_ERR_HTTP2_INVALID_VERSION()
-  t.assert.strictEqual(error.name, 'FastifyError')
-  t.assert.strictEqual(error.code, 'FST_ERR_HTTP2_INVALID_VERSION')
-  t.assert.strictEqual(error.message, 'HTTP2 is available only from node >= 8.8.1')
-  t.assert.strictEqual(error.statusCode, 500)
-  t.assert.ok(error instanceof Error)
-})
-
 test('FST_ERR_INIT_OPTS_INVALID', t => {
   t.plan(5)
   const error = new errors.FST_ERR_INIT_OPTS_INVALID()

package/test/internals/handle-request.test.js

@@ -7,7 +7,6 @@ const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 const { kRouteContext } = require('../../lib/symbols')
 const buildSchema = require('../../lib/validation').compileSchemasForValidation
-const sget = require('simple-get').concat
 
 const Ajv = require('ajv')
 const ajv = new Ajv({ coerceTypes: true })
@@ -129,8 +128,8 @@ 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, done) => {
-  t.plan(8)
+test('request should be defined in onSend Hook on post request with content type application/json', async t => {
+  t.plan(6)
   const fastify = require('../..')()
 
   t.after(() => {
@@ -149,28 +148,24 @@ test('request should be defined in onSend Hook on post request with content type
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/json'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // a 400 error is expected because of no body
-      t.assert.strictEqual(response.statusCode, 400)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    }
   })
+
+  t.assert.strictEqual(result.status, 400)
 })
 
-test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', (t, done) => {
-  t.plan(7)
+test('request should be defined in onSend Hook on post request with content type application/x-www-form-urlencoded', async t => {
+  t.plan(5)
   const fastify = require('../..')()
 
-  t.after(() => { fastify.close() })
+  t.after(() => {
+    fastify.close()
+  })
 
   fastify.addHook('onSend', (request, reply, payload, done) => {
     t.assert.ok(request)
@@ -183,29 +178,25 @@ test('request should be defined in onSend Hook on post request with content type
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/x-www-form-urlencoded'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // a 415 error is expected because of missing content type parser
-      t.assert.strictEqual(response.statusCode, 415)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    }
   })
+
+  // a 415 error is expected because of missing content type parser
+  t.assert.strictEqual(result.status, 415)
 })
 
-test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', (t, done) => {
-  t.plan(7)
+test('request should be defined in onSend Hook on options request with content type application/x-www-form-urlencoded', async t => {
+  t.plan(5)
   const fastify = require('../..')()
 
-  t.after(() => { fastify.close() })
+  t.after(() => {
+    fastify.close()
+  })
 
   fastify.addHook('onSend', (request, reply, payload, done) => {
     t.assert.ok(request)
@@ -218,26 +209,20 @@ test('request should be defined in onSend Hook on options request with content t
     reply.send(200)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'OPTIONS',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'content-type': 'application/x-www-form-urlencoded'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      // Body parsing skipped, so no body sent
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const result = await fetch(fastifyServer, {
+    method: 'OPTIONS',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    }
   })
+
+  // Body parsing skipped, so no body sent
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('request should respond with an error if an unserialized payload is sent inside an async handler', (t, done) => {
-  t.plan(3)
+test('request should respond with an error if an unserialized payload is sent inside an async handler', async t => {
+  t.plan(2)
 
   const fastify = require('../..')()
 
@@ -246,18 +231,16 @@ test('request should respond with an error if an unserialized payload is sent in
     return Promise.resolve(request.headers)
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/'
-  }, (err, res) => {
-    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()
+  })
+
+  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
   })
 })

package/test/internals/hooks.test.js

@@ -2,6 +2,7 @@
 
 const { test } = require('node:test')
 const { Hooks } = require('../../lib/hooks')
+const { default: fastify } = require('../../fastify')
 const noop = () => {}
 
 test('hooks should have 4 array with the registered hooks', t => {
@@ -77,3 +78,19 @@ test('should throw on wrong parameters', t => {
     t.assert.strictEqual(e.message, 'onSend hook should be a function, instead got [object Null]')
   }
 })
+
+test('Integration test: internal function _addHook should be turned into app.ready() rejection', async (t) => {
+  const app = fastify()
+
+  app.register(async function () {
+    app.addHook('notRealHook', async () => {})
+  })
+
+  try {
+    await app.ready()
+    t.assert.fail('Expected ready() to throw')
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'FST_ERR_HOOK_NOT_SUPPORTED')
+    t.assert.match(err.message, /hook not supported/i)
+  }
+})

package/test/issue-4959.test.js

@@ -3,7 +3,14 @@
 const { test } = require('node:test')
 const http = require('node:http')
 const Fastify = require('../fastify')
-
+const { setTimeout } = require('node:timers')
+
+/*
+* Ensure that a socket error during the request does not cause the
+* onSend hook to be called multiple times.
+*
+* @see https://github.com/fastify/fastify/issues/4959
+*/
 function runBadClientCall (reqOptions, payload) {
   let innerResolve, innerReject
   const promise = new Promise((resolve, reject) => {
@@ -17,7 +24,7 @@ function runBadClientCall (reqOptions, payload) {
     ...reqOptions,
     headers: {
       'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(postData),
+      'Content-Length': Buffer.byteLength(postData)
     }
   }, () => {
     innerReject(new Error('Request should have failed'))
@@ -25,7 +32,9 @@ function runBadClientCall (reqOptions, payload) {
 
   // Kill the socket immediately (before sending data)
   req.on('socket', (socket) => {
-    setTimeout(() => { socket.destroy() }, 5)
+    socket.on('connect', () => {
+      setTimeout(() => { socket.destroy() }, 0)
+    })
   })
   req.on('error', innerResolve)
   req.write(postData)
@@ -34,7 +43,7 @@ function runBadClientCall (reqOptions, payload) {
   return promise
 }
 
-test('should handle a soket error', async (t) => {
+test('should handle a socket error', async (t) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -78,7 +87,7 @@ test('should handle a soket error', async (t) => {
     hostname: 'localhost',
     port: fastify.server.address().port,
     path: '/',
-    method: 'PUT',
+    method: 'PUT'
   }, { test: 'me' })
   t.assert.equal(err.code, 'ECONNRESET')
 })

package/test/listen.4.test.js

@@ -3,10 +3,8 @@
 const { test, before } = require('node:test')
 const dns = require('node:dns').promises
 const dnsCb = require('node:dns')
-const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const helper = require('./helper')
-const { waitForCb } = require('./toolkit')
 
 let localhostForURL
 
@@ -90,7 +88,7 @@ test('listen logs the port as info', async t => {
 
 test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
-  t.plan(2 * localAddresses.length)
+  t.plan(3 * localAddresses.length)
 
   const app = Fastify()
   app.get('/', async () => 'hello localhost')
@@ -98,52 +96,42 @@ test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
   await app.listen({ port: 0, host: 'localhost' })
 
   for (const lookup of localAddresses) {
-    await new Promise((resolve, reject) => {
-      sget({
-        method: 'GET',
-        url: getUrl(app, lookup)
-      }, (err, response, body) => {
-        if (err) { return reject(err) }
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body.toString(), 'hello localhost')
-        resolve()
-      })
+    const result = await fetch(getUrl(app, lookup), {
+      method: 'GET'
     })
+
+    t.assert.ok(result.ok)
+    t.assert.deepEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.text(), 'hello localhost')
   }
 })
 
-test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', (t, done) => {
-  dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
-    t.plan(2 + (3 * lookups.length))
-    t.assert.ifError(err)
-
-    const app = Fastify()
-    app.get('/', async () => 'hello localhost')
-    app.listen({ port: 0, host: 'localhost' }, (err) => {
-      t.assert.ifError(err)
-      t.after(() => app.close())
-
-      const { stepIn, patience } = waitForCb({ steps: lookups.length })
-
-      // Loop over each lookup and perform the assertions
-      if (lookups.length > 0) {
-        for (const lookup of lookups) {
-          sget({
-            method: 'GET',
-            url: getUrl(app, lookup)
-          }, (err, response, body) => {
-            t.assert.ifError(err)
-            t.assert.strictEqual(response.statusCode, 200)
-            t.assert.deepStrictEqual(body.toString(), 'hello localhost')
-            // Call stepIn to report that a request has been completed
-            stepIn()
-          })
-        }
-        // When all requests have been completed, call done
-        patience.then(() => done())
-      }
+test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', async (t) => {
+  const lookups = await new Promise((resolve, reject) => {
+    dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
+      if (err) return reject(err)
+      resolve(lookups)
     })
   })
+
+  t.plan(3 * lookups.length)
+
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.after(() => app.close())
+
+  await app.listen({ port: 0, host: 'localhost' })
+
+  // Loop over each lookup and perform the assertions
+  for (const lookup of lookups) {
+    const result = await fetch(getUrl(app, lookup), {
+      method: 'GET'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.deepEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.text(), 'hello localhost')
+  }
 })
 
 test('addresses getter', async t => {