fastify 5.11.2 → 5.12.0

package/test/helper.js

@@ -4,11 +4,42 @@ const dns = require('node:dns').promises
 const stream = require('node:stream')
 const { promisify } = require('node:util')
 const symbols = require('../lib/symbols')
-const { waitForCb } = require('./toolkit')
 const assert = require('node:assert')
 
 module.exports.sleep = promisify(setTimeout)
 
+function waitForCb (options) {
+  let count = null
+  let done = false
+  let iResolve
+  let iReject
+
+  function stepIn () {
+    if (done) {
+      iReject(new Error('Unexpected done call'))
+      return
+    }
+
+    if (--count) {
+      return
+    }
+
+    done = true
+    iResolve()
+  }
+
+  const patience = new Promise((resolve, reject) => {
+    iResolve = resolve
+    iReject = reject
+  })
+
+  count = options.steps || 1
+  done = false
+
+  return { stepIn, patience }
+}
+module.exports.waitForCb = waitForCb
+
 /**
  * @param method HTTP request method
  * @param t node:test instance
@@ -494,3 +525,44 @@ module.exports.getServerUrl = function (app) {
     ? `http://[${address}]:${port}`
     : `http://${address}:${port}`
 }
+
+module.exports.partialDeepStrictEqual = function partialDeepStrictEqual (actual, expected) {
+  if (typeof expected !== 'object' || expected === null) {
+    return actual === expected
+  }
+
+  if (typeof actual !== 'object' || actual === null) {
+    return false
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false
+    if (expected.length > actual.length) return false
+
+    for (let i = 0; i < expected.length; i++) {
+      if (!partialDeepStrictEqual(actual[i], expected[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  for (const key of Object.keys(expected)) {
+    if (!(key in actual)) return false
+    if (!partialDeepStrictEqual(actual[key], expected[key])) {
+      return false
+    }
+  }
+
+  return true
+}
+
+module.exports.assertNoWarning = function (t) {
+  function doNotWarn () {
+    t.assert.fail('no warning')
+  }
+  process.on('warning', doNotWarn)
+  t.after(() => {
+    process.off('warning', doNotWarn)
+  })
+}

package/test/hooks-async.test.js

@@ -4,8 +4,7 @@ const { Readable } = require('node:stream')
 const { test, describe } = require('node:test')
 const Fastify = require('../fastify')
 const fs = require('node:fs')
-const { sleep } = require('./helper')
-const { waitForCb } = require('./toolkit')
+const { sleep, waitForCb } = require('./helper')
 
 process.removeAllListeners('warning')
 

package/test/hooks.test.js

@@ -10,8 +10,7 @@ const symbols = require('../lib/symbols.js')
 const payload = { hello: 'world' }
 const proxyquire = require('proxyquire')
 const { connect } = require('node:net')
-const { sleep } = require('./helper')
-const { waitForCb } = require('./toolkit.js')
+const { sleep, waitForCb } = require('./helper')
 const { fetch } = require('undici')
 
 process.removeAllListeners('warning')

package/test/internals/reply.test.js

@@ -34,7 +34,7 @@ const doGet = async function (url) {
 }
 
 test('Once called, Reply should return an object with methods', t => {
-  t.plan(15)
+  t.plan(16)
   const response = { res: 'res' }
   const context = {
     config: { onSend: [] },
@@ -49,6 +49,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.assert.strictEqual(typeof reply[kReplyErrorHandlerCalled], 'boolean')
   t.assert.strictEqual(typeof reply.send, 'function')
   t.assert.strictEqual(typeof reply.code, 'function')
+  t.assert.strictEqual(typeof reply.mediaType, 'string')
   t.assert.strictEqual(typeof reply.status, 'function')
   t.assert.strictEqual(typeof reply.header, 'function')
   t.assert.strictEqual(typeof reply.serialize, 'function')
@@ -1114,6 +1115,80 @@ test('reply.removeHeader can remove the value', async t => {
   await fetch(`${fastifyServer}/headers`)
 })
 
+test('reply.removeHeader removes raw headers', async t => {
+  t.plan(9)
+
+  const fastify = require('../../')()
+
+  t.after(() => fastify.close())
+
+  fastify.get('/headers', function (req, reply) {
+    reply.raw.setHeader('X-Foo', 'raw')
+    t.assert.strictEqual(reply.getHeader('x-foo'), 'raw')
+    t.assert.strictEqual(reply.getHeaders()['x-foo'], 'raw')
+    t.assert.strictEqual(reply.hasHeader('x-foo'), true)
+
+    t.assert.strictEqual(reply.removeHeader('x-FoO'), reply)
+    t.assert.strictEqual(reply.getHeader('x-foo'), undefined)
+    t.assert.strictEqual(Object.hasOwn(reply.getHeaders(), 'x-foo'), false)
+    t.assert.strictEqual(reply.hasHeader('x-foo'), false)
+    t.assert.strictEqual(reply.removeHeader('X-FOO'), reply)
+
+    reply.send()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const response = await fetch(`${fastifyServer}/headers`)
+  t.assert.strictEqual(response.headers.get('x-foo'), null)
+})
+
+test('reply.removeHeader removes layered headers', async t => {
+  t.plan(7)
+
+  const fastify = require('../../')()
+
+  t.after(() => fastify.close())
+
+  fastify.get('/headers', function (req, reply) {
+    reply.raw.setHeader('x-foo', 'raw')
+    reply.header('x-foo', 'fastify')
+    t.assert.strictEqual(reply.getHeader('x-foo'), 'fastify')
+    t.assert.strictEqual(reply.getHeaders()['x-foo'], 'fastify')
+
+    t.assert.strictEqual(reply.removeHeader('x-foo'), reply)
+    t.assert.strictEqual(reply.getHeader('x-foo'), undefined)
+    t.assert.strictEqual(Object.hasOwn(reply.getHeaders(), 'x-foo'), false)
+    t.assert.strictEqual(reply.hasHeader('x-foo'), false)
+
+    reply.send()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const response = await fetch(`${fastifyServer}/headers`)
+  t.assert.strictEqual(response.headers.get('x-foo'), null)
+})
+
+test('reply.removeHeader does not throw after headers are sent', async t => {
+  t.plan(3)
+
+  const fastify = require('../../')()
+
+  t.after(() => fastify.close())
+
+  fastify.get('/headers', function (req, reply) {
+    reply.hijack()
+    reply.raw.setHeader('x-foo', 'raw')
+    reply.raw.flushHeaders()
+    t.assert.strictEqual(reply.raw.headersSent, true)
+    t.assert.doesNotThrow(() => reply.removeHeader('x-foo'))
+    reply.raw.end()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  const response = await fetch(`${fastifyServer}/headers`)
+  t.assert.strictEqual(response.headers.get('x-foo'), 'raw')
+})
+
 test('reply.header can reset the value', async t => {
   t.plan(1)
 

package/test/listen.1.test.js

@@ -4,6 +4,7 @@ const { networkInterfaces } = require('node:os')
 const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
+const { assertNoWarning } = require('./helper')
 
 let localhost
 let localhostForURL
@@ -13,33 +14,22 @@ before(async function () {
 })
 
 test('listen works without arguments', async t => {
-  const doNotWarn = () => {
-    t.assert.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
+
   await fastify.listen()
   const address = fastify.server.address()
   t.assert.strictEqual(address.address, localhost)
   t.assert.ok(address.port > 0)
+  await fastify.close()
 })
 
 test('Async/await listen with arguments', async t => {
-  const doNotWarn = () => {
-    t.assert.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
+
   const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
   const address = fastify.server.address()
   const { protocol, hostname, port, pathname } = new URL(addr)
@@ -55,39 +45,27 @@ test('Async/await listen with arguments', async t => {
     family: 'IPv4',
     port: address.port
   })
+  await fastify.close()
 })
 
 test('listen accepts a callback', (t, done) => {
   t.plan(2)
-  const doNotWarn = () => {
-    t.assert.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
+
   fastify.listen({ port: 0 }, (err) => {
     t.assert.ifError(err)
     t.assert.strictEqual(fastify.server.address().address, localhost)
-    done()
+    fastify.close(done)
   })
 })
 
 test('listen accepts options and a callback', (t, done) => {
   t.plan(1)
-  const doNotWarn = () => {
-    t.assert.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
   fastify.listen({
     port: 0,
     host: 'localhost',
@@ -98,7 +76,7 @@ test('listen accepts options and a callback', (t, done) => {
     ipv6Only: false
   }, (err) => {
     t.assert.ifError(err)
-    done()
+    fastify.close(done)
   })
 })
 
@@ -118,37 +96,24 @@ test('listen after Promise.resolve()', (t, done) => {
 })
 
 test('listen works with undefined host', async t => {
-  const doNotWarn = () => {
-    t.assert.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => fastify.close())
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
   await fastify.listen({ host: undefined, port: 0 })
   const address = fastify.server.address()
   t.assert.strictEqual(address.address, localhost)
   t.assert.ok(address.port > 0)
+  await fastify.close()
 })
 
 test('listen works with null host', async t => {
-  const doNotWarn = () => {
-    t.fail('should not be deprecated')
-  }
-  process.on('warning', doNotWarn)
+  assertNoWarning(t)
 
   const fastify = Fastify()
-  t.after(() => fastify.close())
-  t.after(() => {
-    fastify.close()
-    process.removeListener('warning', doNotWarn)
-  })
+
   await fastify.listen({ host: null, port: 0 })
   const address = fastify.server.address()
   t.assert.strictEqual(address.address, localhost)
   t.assert.ok(address.port > 0)
+  await fastify.close()
 })

package/test/listen.5.test.js

@@ -2,8 +2,9 @@
 
 const { test } = require('node:test')
 const net = require('node:net')
-const Fastify = require('../fastify')
 const { once } = require('node:events')
+const { spyWarning } = require('process-warning')
+const Fastify = require('../fastify')
 const { FSTWRN003 } = require('../lib/warnings.js')
 
 function createDeferredPromise () {
@@ -102,21 +103,17 @@ test('same port conflict and success should not fire callback multiple times - p
 test('should emit a warning when using async callback', (t, done) => {
   t.plan(2)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN003.code)
-  }
-
+  const spyData = spyWarning(FSTWRN003)
   const fastify = Fastify()
 
   t.after(async () => {
     await fastify.close()
-    process.removeListener('warning', onWarning)
-    FSTWRN003.emitted = false
+    spyData.restore()
   })
 
   fastify.listen({ port: 0 }, async function doNotUseAsyncCallback () {
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['listen method'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     done()
   })
 })

package/test/logger/instantiation.test.js

@@ -14,7 +14,7 @@ const helper = require('../helper')
 const { FST_ERR_LOG_INVALID_LOGGER } = require('../../lib/errors')
 const { once, on } = stream
 const { createTempFile, request } = require('./logger-test-utils')
-const { partialDeepStrictEqual } = require('../toolkit')
+const { partialDeepStrictEqual } = require('../helper')
 
 t.test('logger instantiation', { timeout: 60000 }, async (t) => {
   let localhost

package/test/logger/logging.test.js

@@ -11,7 +11,7 @@ const { LogController } = require('../../lib/log-controller')
 const helper = require('../helper')
 const { once, on } = stream
 const { request } = require('./logger-test-utils')
-const { partialDeepStrictEqual } = require('../toolkit')
+const { partialDeepStrictEqual } = require('../helper')
 
 t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost

package/test/logger/request.test.js

@@ -9,7 +9,7 @@ const Fastify = require('../../fastify')
 const helper = require('../helper')
 const { on } = stream
 const { request } = require('./logger-test-utils')
-const { partialDeepStrictEqual } = require('../toolkit')
+const { partialDeepStrictEqual } = require('../helper')
 
 t.test('request', { timeout: 60000 }, async (t) => {
   let localhost

package/test/logger/response.test.js

@@ -7,7 +7,7 @@ const split = require('split2')
 const pino = require('pino')
 
 const Fastify = require('../../fastify')
-const { partialDeepStrictEqual } = require('../toolkit')
+const { partialDeepStrictEqual } = require('../helper')
 const { on } = stream
 
 t.test('response serialization', { timeout: 60000 }, async (t) => {

package/test/plugin.4.test.js

@@ -3,7 +3,6 @@
 const { test, describe } = require('node:test')
 const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
-const fakeTimer = require('@sinonjs/fake-timers')
 const { FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER } = require('../lib/errors')
 
 test('pluginTimeout', (t, testDone) => {
@@ -46,12 +45,14 @@ test('pluginTimeout - named function', (t, testDone) => {
 
 test('pluginTimeout default', (t, testDone) => {
   t.plan(5)
-  const clock = fakeTimer.install({ shouldClearNativeTimers: true })
+  t.mock.timers.enable({
+    apis: ['setTimeout', 'Date']
+  })
 
   const fastify = Fastify()
   fastify.register(function (app, opts, done) {
     // default time elapsed without calling done
-    clock.tick(10000)
+    t.mock.timers.tick(10000)
   })
 
   fastify.ready((err) => {
@@ -64,7 +65,7 @@ test('pluginTimeout default', (t, testDone) => {
     testDone()
   })
 
-  t.after(clock.uninstall)
+  t.after(() => t.mock.timers.reset())
 })
 
 test('plugin metadata - version', (t, testDone) => {

package/test/reply-media-type.test.js

@@ -0,0 +1,131 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('reply.mediaType should match the content-type header', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.type('application/json')
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('reply.mediaType should strip the charset parameter', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.header('content-type', 'application/json; charset=utf-8')
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('reply.mediaType should strip the space', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.header('content-type', ' application/json ; charset=utf-8')
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('reply.mediaType is undefined when content-type is not set', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    t.assert.strictEqual(reply.mediaType, undefined)
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, undefined)
+})
+
+test('reply.mediaType supported in hooks', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    preHandler: (request, reply, done) => {
+      reply.type('application/json')
+      t.assert.strictEqual(reply.mediaType, 'application/json')
+      done()
+    },
+    preSerialization: (request, reply, payload, done) => {
+      t.assert.strictEqual(reply.mediaType, 'application/json')
+      done(null, payload)
+    },
+    onSend: (request, reply, payload, done) => {
+      t.assert.strictEqual(reply.mediaType, 'application/json')
+      done(null, payload)
+    }
+  }, (request, reply) => {
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('reply.mediaType should reflect the last type set', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.type('application/json')
+    reply.type('text/plain')
+    t.assert.strictEqual(reply.mediaType, 'text/plain')
+    reply.send(`mediaType = ${reply.mediaType}`)
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = response.body
+  t.assert.strictEqual(body, 'mediaType = text/plain')
+})