fastify 4.28.0 → 5.0.0-alpha.3

package/test/content-parser.test.js

@@ -12,19 +12,20 @@ const third = function (req, payload, done) {}
 
 test('hasContentTypeParser', t => {
   test('should know about internal parsers', t => {
-    t.plan(4)
+    t.plan(5)
 
     const fastify = Fastify()
     fastify.ready(err => {
       t.error(err)
       t.ok(fastify.hasContentTypeParser('application/json'))
       t.ok(fastify.hasContentTypeParser('text/plain'))
+      t.ok(fastify.hasContentTypeParser('  text/plain  '))
       t.notOk(fastify.hasContentTypeParser('application/jsoff'))
     })
   })
 
-  test('should work with string and RegExp', t => {
-    t.plan(7)
+  test('should only work with string and RegExp', t => {
+    t.plan(8)
 
     const fastify = Fastify()
     fastify.addContentTypeParser(/^image\/.*/, first)
@@ -38,6 +39,7 @@ test('hasContentTypeParser', t => {
     t.notOk(fastify.hasContentTypeParser(/^image\/.+\+xml/))
     t.notOk(fastify.hasContentTypeParser('image/png'))
     t.notOk(fastify.hasContentTypeParser('*'))
+    t.throws(() => fastify.hasContentTypeParser(123), FST_ERR_CTP_INVALID_TYPE)
   })
 
   t.end()
@@ -45,7 +47,7 @@ test('hasContentTypeParser', t => {
 
 test('getParser', t => {
   test('should return matching parser', t => {
-    t.plan(3)
+    t.plan(6)
 
     const fastify = Fastify()
 
@@ -56,9 +58,12 @@ test('getParser', t => {
     t.equal(fastify[keys.kContentTypeParser].getParser('application/t+xml').fn, second)
     t.equal(fastify[keys.kContentTypeParser].getParser('image/png').fn, first)
     t.equal(fastify[keys.kContentTypeParser].getParser('text/html').fn, third)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html; charset=utf-8').fn, third)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html ; charset=utf-8').fn, third)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/htmlINVALID')?.fn, undefined)
   })
 
-  test('should return matching parser with caching', t => {
+  test('should return matching parser with caching /1', t => {
     t.plan(6)
 
     const fastify = Fastify()
@@ -73,6 +78,21 @@ test('getParser', t => {
     t.equal(fastify[keys.kContentTypeParser].cache.size, 1)
   })
 
+  test('should return matching parser with caching /2', t => {
+    t.plan(6)
+
+    const fastify = Fastify()
+
+    fastify.addContentTypeParser(/^text\/html(;\s*charset=[^;]+)?$/, first)
+
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 1)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html;charset=utf-8').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 2)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html;charset=utf-8').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 2)
+  })
+
   test('should prefer content type parser with string value', t => {
     t.plan(2)
 
@@ -199,6 +219,36 @@ test('add', t => {
     t.equal(contentTypeParser.customParsers.get('').fn, first)
   })
 
+  test('should lowercase contentTypeParser name', async t => {
+    t.plan(1)
+    const fastify = Fastify()
+    fastify.addContentTypeParser('text/html', function (req, done) {
+      done()
+    })
+    try {
+      fastify.addContentTypeParser('TEXT/html', function (req, done) {
+        done()
+      })
+    } catch (err) {
+      t.same(err.message, FST_ERR_CTP_ALREADY_PRESENT('text/html').message)
+    }
+  })
+
+  test('should trim contentTypeParser name', async t => {
+    t.plan(1)
+    const fastify = Fastify()
+    fastify.addContentTypeParser('text/html', function (req, done) {
+      done()
+    })
+    try {
+      fastify.addContentTypeParser('    text/html', function (req, done) {
+        done()
+      })
+    } catch (err) {
+      t.same(err.message, FST_ERR_CTP_ALREADY_PRESENT('text/html').message)
+    }
+  })
+
   t.end()
 })
 
@@ -256,7 +306,7 @@ test('Error thrown 415 from content type is null and make post request to server
 
 test('remove', t => {
   test('should remove default parser', t => {
-    t.plan(3)
+    t.plan(6)
 
     const fastify = Fastify()
     const contentTypeParser = fastify[keys.kContentTypeParser]
@@ -264,6 +314,9 @@ test('remove', t => {
     t.ok(contentTypeParser.remove('application/json'))
     t.notOk(contentTypeParser.customParsers['application/json'])
     t.notOk(contentTypeParser.parserList.find(parser => parser === 'application/json'))
+    t.ok(contentTypeParser.remove('  text/plain  '))
+    t.notOk(contentTypeParser.customParsers['text/plain'])
+    t.notOk(contentTypeParser.parserList.find(parser => parser === 'text/plain'))
   })
 
   test('should remove RegExp parser', t => {
@@ -421,32 +474,25 @@ test('Safeguard against content-type spoofing - string', async t => {
   })
 })
 
-test('Safeguard against content-type spoofing - regexp', async t => {
-  t.plan(1)
+test('Warning against improper content-type - regexp', t => {
+  t.plan(2)
 
   const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifySecurity')
+    t.equal(warning.code, 'FSTSEC001')
+  }
+  t.teardown(() => process.removeListener('warning', onWarning))
+
   fastify.removeAllContentTypeParsers()
   fastify.addContentTypeParser(/text\/plain/, function (request, body, done) {
-    t.pass('should be called')
     done(null, body)
   })
   fastify.addContentTypeParser(/application\/json/, function (request, body, done) {
-    t.fail('shouldn\'t be called')
     done(null, body)
   })
-
-  fastify.post('/', async () => {
-    return 'ok'
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'text/plain; content-type="application/json"'
-    },
-    body: ''
-  })
 })
 
 test('content-type match parameters - string 1', async t => {
@@ -477,34 +523,6 @@ test('content-type match parameters - string 1', async t => {
   })
 })
 
-test('content-type match parameters - string 2', async t => {
-  t.plan(1)
-
-  const fastify = Fastify()
-  fastify.removeAllContentTypeParsers()
-  fastify.addContentTypeParser('application/json; charset=utf8; foo=bar', function (request, body, done) {
-    t.pass('should be called')
-    done(null, body)
-  })
-  fastify.addContentTypeParser('text/plain; charset=utf8; foo=bar', function (request, body, done) {
-    t.fail('shouldn\'t be called')
-    done(null, body)
-  })
-
-  fastify.post('/', async () => {
-    return 'ok'
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'application/json; foo=bar; charset=utf8'
-    },
-    body: ''
-  })
-})
-
 test('content-type match parameters - regexp', async t => {
   t.plan(1)
 
@@ -650,72 +668,6 @@ test('content-type regexp list should be cloned when plugin override', async t =
   }
 })
 
-test('allow partial content-type - essence check', async t => {
-  t.plan(1)
-
-  const fastify = Fastify()
-  fastify.removeAllContentTypeParsers()
-  fastify.addContentTypeParser('json', function (request, body, done) {
-    t.pass('should be called')
-    done(null, body)
-  })
-
-  fastify.post('/', async () => {
-    return 'ok'
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'application/json; foo=bar; charset=utf8'
-    },
-    body: ''
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'image/jpeg'
-    },
-    body: ''
-  })
-})
-
-test('allow partial content-type - not essence check', async t => {
-  t.plan(1)
-
-  const fastify = Fastify()
-  fastify.removeAllContentTypeParsers()
-  fastify.addContentTypeParser('json;', function (request, body, done) {
-    t.pass('should be called')
-    done(null, body)
-  })
-
-  fastify.post('/', async () => {
-    return 'ok'
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'application/json; foo=bar; charset=utf8'
-    },
-    body: ''
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'image/jpeg'
-    },
-    body: ''
-  })
-})
-
 test('edge case content-type - ;', async t => {
   t.plan(1)
 

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

@@ -63,7 +63,7 @@ test('Should have typeof body object with no custom parser defined, undefined bo
   })
 })
 
-test('Should get the body as string', t => {
+test('Should get the body as string /1', t => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -102,6 +102,45 @@ test('Should get the body as string', t => {
   })
 })
 
+test('Should get the body as string /2', t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('text/plain/test', { parseAs: 'string' }, function (req, body, done) {
+    t.ok('called')
+    t.ok(typeof body === 'string')
+    try {
+      const plainText = body
+      done(null, plainText)
+    } catch (err) {
+      err.statusCode = 400
+      done(err, undefined)
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: getServerUrl(fastify),
+      body: 'hello world',
+      headers: {
+        'Content-Type': '   text/plain/test  '
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), 'hello world')
+      fastify.close()
+    })
+  })
+})
+
 test('Should get the body as buffer', t => {
   t.plan(6)
   const fastify = Fastify()

package/test/decorator-namespace.test._js_

@@ -0,0 +1,31 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const fp = require('fastify-plugin')
+
+test('plugin namespace', async t => {
+  t.plan(2)
+  const app = Fastify()
+
+  await app.register(async function plugin (app, opts) {
+    app.decorate('utility', function () {
+      return 'utility'
+    })
+
+    app.get('/', function (req, reply) {
+      // ! here the plugin would use app.utility()
+      // ! the plugin does not know about the namespace
+      reply.send({ utility: app.utility() })
+    })
+  }, { namepace: 'foo' })
+
+  // ! but outside the plugin the decorator would be app.foo.utility()
+  t.ok(app.foo.utility)
+
+  const res = await app.inject('/')
+  t.same(res.json(), { utility: 'utility' })
+})

package/test/decorator.test.js

@@ -1,14 +1,11 @@
 'use strict'
 
-/* eslint no-prototype-builtins: 0 */
-
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const fp = require('fastify-plugin')
 const sget = require('simple-get').concat
 const symbols = require('../lib/symbols.js')
-const proxyquire = require('proxyquire')
 
 test('server methods should exist', t => {
   t.plan(2)
@@ -789,49 +786,44 @@ test('decorate* should throw if called after ready', async t => {
   await fastify.close()
 })
 
-test('decorate* should emit warning if an array is passed', t => {
-  t.plan(1)
+test('decorate* should emit error if an array is passed', t => {
+  t.plan(2)
 
-  function onWarning (name) {
-    t.equal(name, 'test_array')
+  const fastify = Fastify()
+  try {
+    fastify.decorateRequest('test_array', [])
+    t.fail('should not decorate')
+  } catch (err) {
+    t.same(err.code, 'FST_ERR_DEC_REFERENCE_TYPE')
+    t.same(err.message, "The decorator 'test_array' of type 'object' is a reference type. Use the { getter, setter } interface instead.")
   }
+})
 
-  const decorate = proxyquire('../lib/decorate', {
-    './warnings': {
-      FSTDEP006: onWarning
-    }
-  })
-  const fastify = proxyquire('..', { './lib/decorate.js': decorate })()
-  fastify.decorateRequest('test_array', [])
+test('server.decorate should not emit error if reference type is passed', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  fastify.decorate('test_array', [])
+  fastify.decorate('test_object', {})
+  await fastify.ready()
+  t.pass('Done')
 })
 
 test('decorate* should emit warning if object type is passed', t => {
-  t.plan(1)
+  t.plan(2)
 
-  function onWarning (name) {
-    t.equal(name, 'test_object')
+  const fastify = Fastify()
+  try {
+    fastify.decorateRequest('test_object', { foo: 'bar' })
+    t.fail('should not decorate')
+  } catch (err) {
+    t.same(err.code, 'FST_ERR_DEC_REFERENCE_TYPE')
+    t.same(err.message, "The decorator 'test_object' of type 'object' is a reference type. Use the { getter, setter } interface instead.")
   }
-
-  const decorate = proxyquire('../lib/decorate', {
-    './warnings': {
-      FSTDEP006: onWarning
-    }
-  })
-  const fastify = proxyquire('..', { './lib/decorate.js': decorate })()
-  fastify.decorateRequest('test_object', { foo: 'bar' })
 })
 
 test('decorate* should not emit warning if object with getter/setter is passed', t => {
-  function onWarning (warning) {
-    t.fail('Should not call a warn')
-  }
-
-  const decorate = proxyquire('../lib/decorate', {
-    './warnings': {
-      FSTDEP006: onWarning
-    }
-  })
-  const fastify = proxyquire('..', { './lib/decorate.js': decorate })()
+  const fastify = Fastify()
 
   fastify.decorateRequest('test_getter_setter', {
     setter (val) {
@@ -844,17 +836,74 @@ test('decorate* should not emit warning if object with getter/setter is passed',
   t.end('Done')
 })
 
-test('decorate* should not emit warning if string,bool,numbers are passed', t => {
-  function onWarning (warning) {
-    t.fail('Should not call a warn')
-  }
+test('decorateRequest with getter/setter can handle encapsulation', async t => {
+  t.plan(24)
+
+  const fastify = Fastify({ logger: true })
+
+  fastify.decorateRequest('test_getter_setter_holder')
+  fastify.decorateRequest('test_getter_setter', {
+    getter () {
+      this.test_getter_setter_holder ??= {}
+      return this.test_getter_setter_holder
+    }
+  })
+
+  fastify.get('/', async function (req, reply) {
+    t.same(req.test_getter_setter, {}, 'a getter')
+    req.test_getter_setter.a = req.id
+    t.same(req.test_getter_setter, { a: req.id })
+  })
+
+  fastify.addHook('onResponse', async function hook (req, reply) {
+    t.same(req.test_getter_setter, { a: req.id })
+  })
 
-  const decorate = proxyquire('../lib/decorate', {
-    './warnings': {
-      FSTDEP006: onWarning
+  await Promise.all([
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200))
+  ])
+})
+
+test('decorateRequest with getter/setter can handle encapsulation with arrays', async t => {
+  t.plan(24)
+
+  const fastify = Fastify({ logger: true })
+
+  fastify.decorateRequest('array_holder')
+  fastify.decorateRequest('my_array', {
+    getter () {
+      this.array_holder ??= []
+      return this.array_holder
     }
   })
-  const fastify = proxyquire('..', { './lib/decorate.js': decorate })()
+
+  fastify.get('/', async function (req, reply) {
+    t.same(req.my_array, [])
+    req.my_array.push(req.id)
+    t.same(req.my_array, [req.id])
+  })
+
+  fastify.addHook('onResponse', async function hook (req, reply) {
+    t.same(req.my_array, [req.id])
+  })
+
+  await Promise.all([
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200)),
+    fastify.inject('/').then(res => t.same(res.statusCode, 200))
+  ])
+})
+
+test('decorate* should not emit error if string,bool,numbers are passed', t => {
+  const fastify = Fastify()
 
   fastify.decorateRequest('test_str', 'foo')
   fastify.decorateRequest('test_bool', true)

package/test/delete.test.js

@@ -300,8 +300,28 @@ fastify.listen({ port: 0 }, err => {
   })
 })
 
+test('shorthand - delete with application/json Content-Type header and null body', t => {
+  t.plan(4)
+  const fastify = require('..')()
+  fastify.delete('/', {}, (req, reply) => {
+    t.equal(req.body, null)
+    reply.send(req.body)
+  })
+  fastify.inject({
+    method: 'DELETE',
+    url: '/',
+    headers: { 'Content-Type': 'application/json' },
+    body: 'null'
+  }, (err, response) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(response.payload.toString(), 'null')
+  })
+})
+
 // https://github.com/fastify/fastify/issues/936
-test('shorthand - delete with application/json Content-Type header and without body', t => {
+// Skip this test because this is an invalid request
+test('shorthand - delete with application/json Content-Type header and without body', { skip: 'https://github.com/fastify/fastify/pull/5419' }, t => {
   t.plan(4)
   const fastify = require('..')()
   fastify.delete('/', {}, (req, reply) => {

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const t = require('tap')
+const diagnostics = require('dc-polyfill')
+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 => {
+  t.plan(9)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.equal(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.ok(msg.request instanceof Request)
+    t.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)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      reply.callNotFound()
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    if (err) t.error(err)
+
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'GET',
+      url: getServerUrl(fastify) + '/'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 404)
+    })
+  })
+})