fastify 4.24.0 → 4.24.1

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

@@ -0,0 +1,149 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('../fastify')
+const jsonParser = require('fast-json-body')
+const { getServerUrl, plainTextParser } = require('./helper')
+
+process.removeAllListeners('warning')
+
+test('cannot remove all content type parsers after binding', t => {
+  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())
+  })
+})
+
+test('cannot remove content type parsers after binding', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+
+    t.throws(() => fastify.removeContentTypeParser('application/json'))
+  })
+})
+
+test('should be able to override the default json parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('application/json', function (req, payload, done) {
+    t.ok('called')
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: getServerUrl(fastify),
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      fastify.close()
+    })
+  })
+})
+
+test('should be able to override the default plain text parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('text/plain', function (req, payload, done) {
+    t.ok('called')
+    plainTextParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: getServerUrl(fastify),
+      body: 'hello world',
+      headers: {
+        'Content-Type': 'text/plain'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), 'hello world')
+      fastify.close()
+    })
+  })
+})
+
+test('should be able to add a custom content type parser after removeAllContentTypeParsers', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.removeAllContentTypeParsers()
+
+  fastify.addContentTypeParser('application/jsoff', function (req, payload, done) {
+    t.ok('called')
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: getServerUrl(fastify),
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+      fastify.close()
+    })
+  })
+})

package/test/head.test.js

@@ -56,6 +56,134 @@ test('shorthand - head', t => {
   }
 })
 
+test('shorthand - custom head', t => {
+  t.plan(1)
+  try {
+    fastify.get('/proxy/*', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    fastify.head('/proxy/*', function (req, reply) {
+      reply.headers({ 'x-foo': 'bar' })
+      reply.code(200).send(null)
+    })
+
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - custom head with constraints', t => {
+  t.plan(1)
+  try {
+    fastify.get('/proxy/*', { constraints: { version: '1.0.0' } }, function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    fastify.head('/proxy/*', { constraints: { version: '1.0.0' } }, function (req, reply) {
+      reply.headers({ 'x-foo': 'bar' })
+      reply.code(200).send(null)
+    })
+
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - should not reset a head route', t => {
+  t.plan(1)
+  try {
+    fastify.get('/query1', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    fastify.put('/query1', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - should override head route when setting multiple routes', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'GET',
+      url: '/query2',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    fastify.route({
+      method: ['POST', 'PUT', 'HEAD'],
+      url: '/query2',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    t.pass()
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+})
+
+test('shorthand - should override head route when setting multiple routes', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: ['GET'],
+      url: '/query3',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    fastify.route({
+      method: ['POST', 'PUT', 'HEAD'],
+      url: '/query3',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    t.pass()
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+})
+
+test('shorthand - should set get and head route in the same api call', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: ['HEAD', 'GET'],
+      url: '/query4',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    t.pass()
+  } catch (e) {
+    console.log(e)
+    t.fail()
+  }
+})
+
 test('shorthand - head params', t => {
   t.plan(1)
   try {
@@ -76,6 +204,7 @@ test('shorthand - head, querystring schema', t => {
     })
     t.pass()
   } catch (e) {
+    console.log(e)
     t.fail()
   }
 })
@@ -88,6 +217,7 @@ test('missing schema - head', t => {
     })
     t.pass()
   } catch (e) {
+    console.log(e)
     t.fail()
   }
 })
@@ -161,4 +291,78 @@ fastify.listen({ port: 0 }, err => {
       t.equal(response.statusCode, 200)
     })
   })
+
+  test('shorthand - request head custom head', t => {
+    t.plan(3)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/proxy/test'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['x-foo'], 'bar')
+      t.equal(response.statusCode, 200)
+    })
+  })
+
+  test('shorthand - request head custom head with constraints', t => {
+    t.plan(3)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/proxy/test',
+      headers: {
+        version: '1.0.0'
+      }
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['x-foo'], 'bar')
+      t.equal(response.statusCode, 200)
+    })
+  })
+
+  test('shorthand - should not reset a head route', t => {
+    t.plan(2)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/query1'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+
+  test('shorthand - should override head route when setting multiple routes', t => {
+    t.plan(3)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/query2'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['x-foo'], 'bar')
+      t.equal(response.statusCode, 200)
+    })
+  })
+
+  test('shorthand - should override head route when setting multiple routes', t => {
+    t.plan(3)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/query3'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['x-foo'], 'bar')
+      t.equal(response.statusCode, 200)
+    })
+  })
+
+  test('shorthand - should set get and head route in the same api call', t => {
+    t.plan(3)
+    sget({
+      method: 'HEAD',
+      url: 'http://localhost:' + fastify.server.address().port + '/query4'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['x-foo'], 'bar')
+      t.equal(response.statusCode, 200)
+    })
+  })
 })

package/test/helper.js

@@ -3,8 +3,11 @@
 const sget = require('simple-get').concat
 const dns = require('node:dns').promises
 const stream = require('node:stream')
+const { promisify } = require('node:util')
 const symbols = require('../lib/symbols')
 
+module.exports.sleep = promisify(setTimeout)
+
 /**
  * @param method HTTP request method
  * @param t tap instance
@@ -421,16 +424,35 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
   })
 }
 
-module.exports.getLoopbackHost = async () => {
-  let localhostForURL
+function lookupToIp (lookup) {
+  return lookup.family === 6 ? `[${lookup.address}]` : lookup.address
+}
 
+module.exports.getLoopbackHost = async () => {
   const lookup = await dns.lookup('localhost')
-  const localhost = lookup.address
-  if (lookup.family === 6) {
-    localhostForURL = `[${lookup.address}]`
-  } else {
-    localhostForURL = localhost
+  return [lookup.address, lookupToIp(lookup)]
+}
+
+module.exports.plainTextParser = function (request, callback) {
+  let body = ''
+  request.setEncoding('utf8')
+  request.on('error', onError)
+  request.on('data', onData)
+  request.on('end', onEnd)
+  function onError (err) {
+    callback(err, null)
+  }
+  function onData (chunk) {
+    body += chunk
   }
+  function onEnd () {
+    callback(null, body)
+  }
+}
 
-  return [localhost, localhostForURL]
+module.exports.getServerUrl = function (app) {
+  const { address, port } = app.server.address()
+  return address === '::1'
+    ? `http://[${address}]:${port}`
+    : `http://${address}:${port}`
 }

package/test/hooks-async.test.js

@@ -6,7 +6,7 @@ const test = t.test
 const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const fs = require('node:fs')
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const { sleep } = require('./helper')
 
 process.removeAllListeners('warning')
 
@@ -653,7 +653,7 @@ test('onRequest respond with a stream', t => {
 
   fastify.addHook('onRequest', async (req, reply) => {
     return new Promise((resolve, reject) => {
-      const stream = fs.createReadStream(process.cwd() + '/test/stream.test.js', 'utf8')
+      const stream = fs.createReadStream(__filename, 'utf8')
       // stream.pipe(res)
       // res.once('finish', resolve)
       reply.send(stream).then(() => {
@@ -704,7 +704,7 @@ test('preHandler respond with a stream', t => {
   const order = [1, 2]
 
   fastify.addHook('preHandler', async (req, reply) => {
-    const stream = fs.createReadStream(process.cwd() + '/test/stream.test.js', 'utf8')
+    const stream = fs.createReadStream(__filename, 'utf8')
     reply.raw.once('finish', () => {
       t.equal(order.shift(), 2)
     })

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

@@ -3,14 +3,15 @@
 const { test, before } = require('tap')
 const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
-const dns = require('node:dns').promises
 const split = require('split2')
+const helper = require('./helper')
 
-let localhost
+// fix citgm @aix72-ppc64
+const LISTEN_READYNESS = process.env.CITGM ? 250 : 50
 
+let localhost
 before(async function () {
-  const lookup = await dns.lookup('localhost')
-  localhost = lookup.address
+  [localhost] = await helper.getLoopbackHost()
 })
 
 test('onListen should not be processed when .ready() is called', t => {
@@ -1068,7 +1069,7 @@ test('onListen hooks do not block /1', t => {
     port: 0
   }, err => {
     t.error(err)
-    t.ok(new Date() - startDate < 50)
+    t.ok(new Date() - startDate < LISTEN_READYNESS)
   })
 })
 
@@ -1086,5 +1087,5 @@ test('onListen hooks do not block /2', async t => {
     host: 'localhost',
     port: 0
   })
-  t.ok(new Date() - startDate < 50)
+  t.ok(new Date() - startDate < LISTEN_READYNESS)
 })

package/test/hooks.test.js

@@ -11,22 +11,11 @@ const split = require('split2')
 const symbols = require('../lib/symbols.js')
 const payload = { hello: 'world' }
 const proxyquire = require('proxyquire')
-const { promisify } = require('node:util')
 const { connect } = require('node:net')
-
-const sleep = promisify(setTimeout)
+const { sleep, getServerUrl } = require('./helper')
 
 process.removeAllListeners('warning')
 
-function getUrl (app) {
-  const { address, port } = app.server.address()
-  if (address === '::1') {
-    return `http://[${address}]:${port}`
-  } else {
-    return `http://${address}:${port}`
-  }
-}
-
 test('hooks', t => {
   t.plan(49)
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -760,7 +749,7 @@ test('onRoute hook should able to change the route url', t => {
 
     sget({
       method: 'GET',
-      url: getUrl(fastify) + encodeURI('/foo')
+      url: getServerUrl(fastify) + encodeURI('/foo')
     }, (err, response, body) => {
       t.error(err)
       t.equal(response.statusCode, 200)
@@ -1782,7 +1771,7 @@ test('onRequest respond with a stream', t => {
   const fastify = Fastify()
 
   fastify.addHook('onRequest', (req, reply, done) => {
-    const stream = fs.createReadStream(process.cwd() + '/test/stream.test.js', 'utf8')
+    const stream = fs.createReadStream(__filename, 'utf8')
     // stream.pipe(res)
     // res.once('finish', done)
     reply.send(stream)
@@ -1833,7 +1822,7 @@ test('preHandler respond with a stream', t => {
   const order = [1, 2]
 
   fastify.addHook('preHandler', (req, reply, done) => {
-    const stream = fs.createReadStream(process.cwd() + '/test/stream.test.js', 'utf8')
+    const stream = fs.createReadStream(__filename, 'utf8')
     reply.send(stream)
     reply.raw.once('finish', () => {
       t.equal(order.shift(), 2)

package/test/http2/closing.test.js

@@ -6,18 +6,10 @@ const http2 = require('node:http2')
 const { promisify } = require('node:util')
 const connect = promisify(http2.connect)
 const { once } = require('node:events')
-
 const { buildCertificate } = require('../build-certificate')
-t.before(buildCertificate)
+const { getServerUrl } = require('../helper')
 
-function getUrl (app) {
-  const { address, port } = app.server.address()
-  if (address === '::1') {
-    return `http://[${address}]:${port}`
-  } else {
-    return `http://${address}:${port}`
-  }
-}
+t.before(buildCertificate)
 
 t.test('http/2 request while fastify closing', t => {
   let fastify
@@ -37,7 +29,7 @@ t.test('http/2 request while fastify closing', t => {
     t.teardown(() => { fastify.close() })
 
     t.test('return 200', t => {
-      const url = getUrl(fastify)
+      const url = getServerUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -84,7 +76,7 @@ t.test('http/2 request while fastify closing - return503OnClosing: false', t =>
     t.teardown(() => { fastify.close() })
 
     t.test('return 200', t => {
-      const url = getUrl(fastify)
+      const url = getServerUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -120,7 +112,7 @@ t.test('http/2 closes successfully with async await', async t => {
 
   await fastify.listen({ port: 0 })
 
-  const url = getUrl(fastify)
+  const url = getServerUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -139,7 +131,7 @@ t.test('https/2 closes successfully with async await', async t => {
 
   await fastify.listen({ port: 0 })
 
-  const url = getUrl(fastify)
+  const url = getServerUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -162,7 +154,7 @@ t.test('http/2 server side session emits a timeout event', async t => {
 
   await fastify.listen({ port: 0 })
 
-  const url = getUrl(fastify)
+  const url = getServerUrl(fastify)
   const session = await connect(url)
   const req = session.request({
     ':method': 'GET',