fastify 4.9.2 → 4.10.0

package/test/bodyLimit.test.js

@@ -44,3 +44,82 @@ test('bodyLimit', t => {
     })
   })
 })
+
+test('default request.routeOptions.bodyLimit should be 1048576', t => {
+  t.plan(4)
+  const fastify = Fastify()
+  fastify.post('/default-bodylimit', {
+    handler (request, reply) {
+      t.equal(1048576, request.routeOptions.bodyLimit)
+      reply.send({ })
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/default-bodylimit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('request.routeOptions.bodyLimit should be equal to route limit', t => {
+  t.plan(4)
+  const fastify = Fastify({ bodyLimit: 1 })
+  fastify.post('/route-limit', {
+    bodyLimit: 1000,
+    handler (request, reply) {
+      t.equal(1000, request.routeOptions.bodyLimit)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/route-limit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('request.routeOptions.bodyLimit should be equal to server limit', t => {
+  t.plan(4)
+  const fastify = Fastify({ bodyLimit: 100 })
+  fastify.post('/server-limit', {
+    handler (request, reply) {
+      t.equal(100, request.routeOptions.bodyLimit)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/server-limit',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})

package/test/close-pipelining.test.js

@@ -4,42 +4,72 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const { Client } = require('undici')
+const semver = require('semver')
 
-test('Should return 503 while closing - pipelining', t => {
+test('Should return 503 while closing - pipelining', async t => {
   const fastify = Fastify({
     return503OnClosing: true,
     forceCloseConnections: false
   })
 
+  fastify.get('/', async (req, reply) => {
+    fastify.close()
+    return { hello: 'world' }
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const instance = new Client('http://localhost:' + fastify.server.address().port, {
+    pipelining: 2
+  })
+
+  const codes = [200, 200, 503]
+  const responses = await Promise.all([
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' })
+  ])
+  const actual = responses.map(r => r.statusCode)
+
+  t.same(actual, codes)
+
+  await instance.close()
+})
+
+const isV19plus = semver.satisfies(process.version, '>= v19.0.0')
+test('Should not return 503 while closing - pipelining - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, async t => {
+  const fastify = Fastify({
+    return503OnClosing: false,
+    forceCloseConnections: false
+  })
+
   fastify.get('/', (req, reply) => {
     fastify.close()
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen({ port: 0 }, async err => {
-    t.error(err)
-
-    const instance = new Client('http://localhost:' + fastify.server.address().port, {
-      pipelining: 1
-    })
-
-    const codes = [200, 503]
-    for (const code of codes) {
-      instance.request(
-        { path: '/', method: 'GET' }
-      ).then(data => {
-        t.equal(data.statusCode, code)
-      }).catch((e) => {
-        t.fail(e)
-      })
-    }
-    instance.close(() => {
-      t.end('Done')
-    })
+  await fastify.listen({ port: 0 })
+
+  const instance = new Client('http://localhost:' + fastify.server.address().port, {
+    pipelining: 2
   })
+
+  const codes = [200, 200, 200]
+  const responses = await Promise.all([
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' })
+  ])
+  const actual = responses.map(r => r.statusCode)
+
+  t.same(actual, codes)
+
+  await instance.close()
 })
 
-test('Should not return 503 while closing - pipelining - return503OnClosing', t => {
+test('Should close the socket abruptly - pipelining - return503OnClosing: false, skip Node < v19.x', { skip: !isV19plus }, async t => {
+  // Since Node v19, we will always invoke server.closeIdleConnections()
+  // therefore our socket will be closed
   const fastify = Fastify({
     return503OnClosing: false,
     forceCloseConnections: false
@@ -50,25 +80,20 @@ test('Should not return 503 while closing - pipelining - return503OnClosing', t
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-
-    const instance = new Client('http://localhost:' + fastify.server.address().port, {
-      pipelining: 1
-    })
-
-    const codes = [200, 200]
-    for (const code of codes) {
-      instance.request(
-        { path: '/', method: 'GET' }
-      ).then(data => {
-        t.equal(data.statusCode, code)
-      }).catch((e) => {
-        t.fail(e)
-      })
-    }
-    instance.close(() => {
-      t.end('Done')
-    })
+  await fastify.listen({ port: 0 })
+
+  const instance = new Client('http://localhost:' + fastify.server.address().port, {
+    pipelining: 2
   })
+
+  const responses = await Promise.allSettled([
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' }),
+    instance.request({ path: '/', method: 'GET' })
+  ])
+  t.equal(responses[0].status, 'fulfilled')
+  t.equal(responses[1].status, 'rejected')
+  t.equal(responses[2].status, 'rejected')
+
+  await instance.close()
 })

package/test/close.test.js

@@ -6,6 +6,7 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const { Client } = require('undici')
+const semver = require('semver')
 
 test('close callback', t => {
   t.plan(4)
@@ -202,7 +203,8 @@ test('Should return error while closing (callback) - injection', t => {
   })
 })
 
-t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false', t => {
+const isV19plus = semver.satisfies(process.version, '>= v19.0.0')
+t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, t => {
   const fastify = Fastify({
     return503OnClosing: false,
     forceCloseConnections: false
@@ -240,6 +242,45 @@ t.test('Current opened connection should continue to work after closing and retu
   })
 })
 
+t.test('Current opened connection should NOT continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node < v19.x', { skip: !isV19plus }, t => {
+  t.plan(4)
+  const fastify = Fastify({
+    return503OnClosing: false,
+    forceCloseConnections: false
+  })
+
+  fastify.get('/', (req, reply) => {
+    fastify.close()
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port }, () => {
+      client.write('GET / HTTP/1.1\r\n\r\n')
+
+      client.on('error', function () {
+        // Dependending on the Operating System
+        // the socket could error or not.
+        // However, it will always be closed.
+      })
+
+      client.on('close', function () {
+        t.pass('close')
+      })
+
+      client.once('data', data => {
+        t.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.match(data.toString(), /200 OK/i)
+
+        client.write('GET / HTTP/1.1\r\n\r\n')
+      })
+    })
+  })
+})
+
 t.test('Current opened connection should not accept new incoming connections', t => {
   t.plan(3)
   const fastify = Fastify({ forceCloseConnections: false })

package/test/hooks-async.test.js

@@ -585,33 +585,37 @@ test('preHandler respond with a stream', t => {
 
 test('Should log a warning if is an async function with `done`', t => {
   t.test('3 arguments', t => {
-    t.plan(1)
+    t.plan(2)
     const fastify = Fastify()
 
     try {
       fastify.addHook('onRequest', async (req, reply, done) => {})
     } catch (e) {
+      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
       t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
   })
 
   t.test('4 arguments', t => {
-    t.plan(3)
+    t.plan(6)
     const fastify = Fastify()
 
     try {
       fastify.addHook('onSend', async (req, reply, payload, done) => {})
     } catch (e) {
+      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
       t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
     try {
       fastify.addHook('preSerialization', async (req, reply, payload, done) => {})
     } catch (e) {
+      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
       t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
     try {
       fastify.addHook('onError', async (req, reply, payload, done) => {})
     } catch (e) {
+      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
       t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
     }
   })

package/test/hooks.on-ready.test.js

@@ -291,12 +291,13 @@ t.test('onReady cannot add lifecycle hooks', t => {
 })
 
 t.test('onReady throw loading error', t => {
-  t.plan(1)
+  t.plan(2)
   const fastify = Fastify()
 
   try {
     fastify.addHook('onReady', async function (done) {})
   } catch (e) {
+    t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
     t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
   }
 })

package/test/hooks.test.js

@@ -23,7 +23,7 @@ function getUrl (app) {
 }
 
 test('hooks', t => {
-  t.plan(43)
+  t.plan(49)
   const fastify = Fastify({ exposeHeadRoutes: false })
 
   try {
@@ -41,6 +41,22 @@ test('hooks', t => {
     t.fail()
   }
 
+  try {
+    fastify.addHook('preHandler', null)
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
+    t.equal(e.message, 'preHandler hook should be a function, instead got null')
+    t.pass()
+  }
+
+  try {
+    fastify.addHook('preParsing')
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
+    t.equal(e.message, 'preParsing hook should be a function, instead got undefined')
+    t.pass()
+  }
+
   try {
     fastify.addHook('preParsing', function (request, reply, payload, done) {
       request.preParsing = true
@@ -3316,7 +3332,7 @@ test('registering invalid hooks should throw an error', async t => {
         return 'hello world'
       }
     })
-  }, new Error('onRequest hook should be a function, instead got undefined'))
+  }, new Error('onRequest hook should be a function, instead got [object Undefined]'))
 
   t.throws(() => {
     fastify.route({
@@ -3327,7 +3343,7 @@ test('registering invalid hooks should throw an error', async t => {
         return 'hello world'
       }
     })
-  }, new Error('onRequest hook should be a function, instead got object'))
+  }, new Error('onRequest hook should be a function, instead got [object Null]'))
 
   // undefined is ok
   fastify.route({
@@ -3347,5 +3363,5 @@ test('registering invalid hooks should throw an error', async t => {
     fastify.get('/', function (request, reply) {
       reply.send('hello world')
     })
-  }, new Error('onSend hook should be a function, instead got undefined'))
+  }, new Error('onSend hook should be a function, instead got [object Undefined]'))
 })

package/test/input-validation.js

@@ -1,4 +1,3 @@
-
 'use strict'
 
 const sget = require('simple-get').concat

package/test/internals/hooks.test.js

@@ -78,6 +78,6 @@ test('should throw on wrong parameters', t => {
     t.fail()
   } catch (e) {
     t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
-    t.equal(e.message, 'onSend hook should be a function, instead got object')
+    t.equal(e.message, 'onSend hook should be a function, instead got [object Null]')
   }
 })