fastify 5.11.3 → 5.12.0

package/SPONSORS.md

@@ -19,6 +19,7 @@ or [GitHub Sponsors](https://github.com/sponsors/fastify)!
 - [atagon GmbH](https://github.com/atagon-GmbH)
 - [Photon](https://github.com/photon-hq)
 - [N-iX](https://www.n-ix.com/)
+- [TestMu AI](https://www.testmuai.com/?utm_medium=sponsor&utm_source=fastify)
 
 ## Tier 2
 

package/docs/Guides/Serverless.md

@@ -256,9 +256,41 @@ curl -X POST https://$GOOGLE_REGION-$GOOGLE_PROJECT.cloudfunctions.net/me \
 {"message":"Hello Fastify!"}
 ```
 
+#### Per-route logging
+
+Google Cloud Functions exposes one entry point for your Fastify instance, so
+the dashboard may show all HTTP traffic under that function. Instead of
+deploying one function per endpoint, keep the single Fastify instance and emit
+a structured log line after each request with the matched route:
+
+```js
+fastify.addHook('onResponse', async (request, reply) => {
+  request.log.info({
+    route: request.routeOptions.url,
+    method: request.method,
+    statusCode: reply.statusCode,
+    responseTime: reply.elapsedTime
+  }, 'request completed')
+})
+```
+
+`request.routeOptions.url` is the route pattern, so `/users/123` and
+`/users/456` are grouped under `/users/:id`. With Fastify's logger enabled, the
+fields are emitted as structured log fields, as described in the [Cloud
+Logging structured logging documentation](https://cloud.google.com/logging/docs/structured-logging)
+and the [Cloud Functions logging guide](https://cloud.google.com/functions/docs/monitoring/logging).
+In Cloud Logging, create a [log-based
+metric](https://cloud.google.com/logging/docs/logs-based-metrics) or filter on
+`jsonPayload.route` to get per-route request counts, latency, and error rates.
+
+The same hook works when deploying through Firebase Functions with `onRequest`.
+
 ### References
 - [Google Cloud Functions - Node.js Quickstart
-  ](https://docs.cloud.google.com/run/docs/quickstarts/functions/deploy-functions-gcloud)
+  ](https://cloud.google.com/run/docs/quickstarts/functions/deploy-functions-gcloud)
+- [Cloud Logging - Structured Logging](https://cloud.google.com/logging/docs/structured-logging)
+- [Cloud Logging - Log-based Metrics](https://cloud.google.com/logging/docs/logs-based-metrics)
+- [Cloud Functions - Logging](https://cloud.google.com/functions/docs/monitoring/logging)
 
 ## Google Firebase Functions
 
@@ -594,4 +626,4 @@ https://vercel.com/templates/backend/fastify-on-vercel).
 [Fluid compute](https://vercel.com/docs/fluid-compute) currently
 requires an explicit opt-in. Learn more about enabling Fluid compute
 [here](
-https://vercel.com/docs/fluid-compute#enabling-fluid-compute).
+https://vercel.com/docs/fluid-compute#enabling-fluid-compute).

package/docs/Reference/Reply.md

@@ -6,6 +6,7 @@
   - [.code(statusCode)](#codestatuscode)
   - [.elapsedTime](#elapsedtime)
   - [.statusCode](#statuscode)
+  - [.mediaType](#mediatype)
   - [.server](#server)
   - [.header(key, value)](#headerkey-value)
   - [.headers(object)](#headersobject)
@@ -51,6 +52,7 @@ object that exposes the following functions and properties:
 - `.statusCode` - Read and set the HTTP status code.
 - `.elapsedTime` - Returns the amount of time passed
 since the request was received by Fastify.
+- `.mediaType` - The media type extracted from `Content-Type` header.
 - `.server` - A reference to the fastify instance object.
 - `.header(name, value)` - Sets a response header.
 - `.headers(object)` - Sets all the keys of the object as response headers.
@@ -129,6 +131,18 @@ if (reply.statusCode >= 299) {
   reply.statusCode = 500
 }
 ```
+### .mediaType
+<a id="mediatype"></a>
+
+Returns the media type extracted from `Content-Type` header. When `Content-Type`
+header is missing, it will return `undefined`.
+
+```js
+if (reply.mediaType === 'image/gif') {
+  const versionBuffer = new Uint8Array(reply.payload, 3, 3)
+  reply.header('x-gif-version', new TextDecoder().decode(versionBuffer))
+}
+```
 
 ### .server
 <a id="server"></a>

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.11.3'
+const VERSION = '5.12.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')

package/lib/content-type.js

@@ -183,7 +183,10 @@ class ContentType {
 
   get isValid () { return this.#valid }
 
-  get mediaType () { return `${this.#type}/${this.#subtype}` }
+  get mediaType () {
+    if (this.#valid === false) return undefined
+    return `${this.#type}/${this.#subtype}`
+  }
 
   get type () { return this.#type }
 

package/lib/reply.js

@@ -93,6 +93,12 @@ Object.defineProperties(Reply.prototype, {
       return (this[kReplyEndTime] || now()) - this[kReplyStartTime]
     }
   },
+  mediaType: {
+    get () {
+      const contentTypeHeader = this[kReplyHeaders]['content-type']
+      return ContentType.from(contentTypeHeader).mediaType
+    }
+  },
   server: {
     get () {
       return this.request[kRouteContext].server
@@ -254,9 +260,13 @@ Reply.prototype.hasHeader = function (key) {
 }
 
 Reply.prototype.removeHeader = function (key) {
+  key = key.toLowerCase()
   // Node.js does not like headers with keys set to undefined,
   // so we have to delete the key.
-  delete this[kReplyHeaders][key.toLowerCase()]
+  delete this[kReplyHeaders][key]
+  if (!this.raw.headersSent) {
+    this.raw.removeHeader(key)
+  }
   return this
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.11.3",
+  "version": "5.12.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -167,7 +167,6 @@
   ],
   "devDependencies": {
     "@jsumners/line-reporter": "^1.0.1",
-    "@sinonjs/fake-timers": "^11.2.2",
     "@stylistic/eslint-plugin": "^5.1.0",
     "@stylistic/eslint-plugin-js": "^4.1.0",
     "@types/node": "^26.0.1",
@@ -214,7 +213,7 @@
     "find-my-way": "^9.6.0",
     "light-my-request": "^6.0.0",
     "pino": "^9.14.0 || ^10.1.0",
-    "process-warning": "^5.0.0",
+    "process-warning": "^5.1.0",
     "rfdc": "^1.3.1",
     "secure-json-parse": "^4.0.0",
     "semver": "^7.6.0",

package/test/content-parser.test.js

@@ -1,9 +1,11 @@
 'use strict'
 
 const { test } = require('node:test')
+const { spyWarning } = require('process-warning')
 const Fastify = require('..')
 const keys = require('../lib/symbols')
 const { FST_ERR_CTP_ALREADY_PRESENT, FST_ERR_CTP_INVALID_TYPE, FST_ERR_CTP_INVALID_MEDIA_TYPE } = require('../lib/errors')
+const { FSTSEC001 } = require('../lib/warnings')
 
 const first = function (req, payload, done) {}
 const second = function (req, payload, done) {}
@@ -488,41 +490,37 @@ test('Safeguard against content-type spoofing - string', async t => {
 })
 
 test('Warning against improper content-type - regexp', async t => {
-  await t.test('improper regex - text plain', (t, done) => {
+  await t.test('improper regex - text plain', async (t) => {
     t.plan(2)
-    const fastify = Fastify()
+    const spyData = spyWarning(FSTSEC001)
+    t.after(spyData.restore)
 
-    process.on('warning', onWarning)
-    function onWarning (warning) {
-      t.assert.strictEqual(warning.name, 'FastifySecurity')
-      t.assert.strictEqual(warning.code, 'FSTSEC001')
-      done()
-    }
-    t.after(() => process.removeListener('warning', onWarning))
+    const fastify = Fastify()
 
     fastify.removeAllContentTypeParsers()
     fastify.addContentTypeParser(/text\/plain/, function (request, body, done) {
       done(null, body)
     })
+
+    await fastify.ready()
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['text\\/plain'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
   })
 
-  await t.test('improper regex - application json', (t, done) => {
+  await t.test('improper regex - application json', async (t) => {
     t.plan(2)
+    const spyData = spyWarning(FSTSEC001)
+    t.after(spyData.restore)
     const fastify = Fastify()
 
-    process.on('warning', onWarning)
-    function onWarning (warning) {
-      t.assert.strictEqual(warning.name, 'FastifySecurity')
-      t.assert.strictEqual(warning.code, 'FSTSEC001')
-      done()
-    }
-    t.after(() => process.removeListener('warning', onWarning))
-
     fastify.removeAllContentTypeParsers()
 
     fastify.addContentTypeParser(/application\/json/, function (request, body, done) {
       done(null, body)
     })
+
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['application\\/json'], result: true }])
+    t.assert.deepEqual(spyData.callCount(), 1)
   })
 })
 

package/test/content-type.test.js

@@ -46,18 +46,22 @@ describe('ContentType class', () => {
   test('returns empty instance for empty value', (t) => {
     let found = new ContentType('')
     t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.mediaType, undefined)
 
     found = new ContentType('undefined')
     t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.mediaType, undefined)
 
     found = new ContentType()
     t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.mediaType, undefined)
   })
 
   test('indicates media type is not correct format', (t) => {
     let found = new ContentType('foo')
     t.assert.equal(found.isEmpty, true)
     t.assert.equal(found.isValid, false)
+    t.assert.equal(found.mediaType, undefined)
 
     found = new ContentType('foo /bar')
     t.assert.equal(found.isEmpty, true)

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')
+})

package/test/route-prefix.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('Prefix options should add a prefix for all the routes inside a register / 1', (t, testDone) => {
   t.plan(6)

package/test/route.6.test.js

@@ -4,6 +4,7 @@ const stream = require('node:stream')
 const { ReadableStream } = require('node:stream/web')
 const { test } = require('node:test')
 const Fastify = require('..')
+const { assertNoWarning } = require('./helper')
 
 test('Creates a HEAD route for a GET one with prefixTrailingSlash', async (t) => {
   t.plan(1)
@@ -281,6 +282,8 @@ test('route onSend can be function or array of functions', async t => {
 })
 
 test('no warning for exposeHeadRoute', async t => {
+  assertNoWarning(t)
+
   const fastify = Fastify()
 
   fastify.route({
@@ -292,15 +295,5 @@ test('no warning for exposeHeadRoute', async t => {
     }
   })
 
-  const listener = (w) => {
-    t.assert.fail('no warning')
-  }
-
-  process.on('warning', listener)
-
-  await fastify.listen({ port: 0 })
-
-  process.removeListener('warning', listener)
-
-  await fastify.close()
+  await fastify.ready()
 })

package/test/schema-feature.test.js

@@ -1,13 +1,14 @@
 'use strict'
 
 const { test } = require('node:test')
-const Fastify = require('..')
 const fp = require('fastify-plugin')
+const { spyWarning } = require('process-warning')
+const Fastify = require('..')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
 const { FSTWRN001 } = require('../lib/warnings')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -320,18 +321,10 @@ test('Should not change the input schemas', (t, testDone) => {
 
 test('Should emit warning if the schema headers is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -346,24 +339,18 @@ test('Should emit warning if the schema headers is undefined', (t, testDone) =>
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['headers', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema body is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
-
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -378,24 +365,18 @@ test('Should emit warning if the schema body is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['body', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema query is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -410,24 +391,18 @@ test('Should emit warning if the schema query is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['querystring', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema params is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -442,31 +417,18 @@ test('Should emit warning if the schema params is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['params', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit a warning for every route with undefined schema', (t, testDone) => {
-  t.plan(16)
-  const fastify = Fastify()
-
-  let runs = 0
-  const expectedWarningEmitted = [0, 1, 2, 3]
-  // It emits 4 warnings:
-  // - 2 - GET and HEAD for /undefinedParams/:id
-  // - 2 - GET and HEAD for /undefinedBody/:id
-  // => 3 x 4 assertions = 12 assertions
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-    t.assert.strictEqual(runs++, expectedWarningEmitted.shift())
-  }
+  t.plan(9)
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.get('/undefinedParams/:id', {
     handler: echoParams,
@@ -496,6 +458,15 @@ test('Should emit a warning for every route with undefined schema', (t, testDone
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    // fastify.inject run in series
+    // last callback recieve all warnings at once
+    // GET /undefinedParams/123
+    t.assert.deepStrictEqual(spyData.calls[0], { arguments: ['params', 'GET', '/undefinedParams/:id'], result: true })
+    t.assert.deepStrictEqual(spyData.calls[1], { arguments: ['params', 'HEAD', '/undefinedParams/:id'], result: true })
+    // GET /undefinedBody/123
+    t.assert.deepStrictEqual(spyData.calls[2], { arguments: ['body', 'GET', '/undefinedBody/:id'], result: true })
+    t.assert.deepStrictEqual(spyData.calls[3], { arguments: ['body', 'HEAD', '/undefinedBody/:id'], result: true })
+    t.assert.strictEqual(spyData.callCount(), 4)
     testDone()
   })
 })

package/test/schema-serialization.test.js

@@ -3,7 +3,7 @@
 const { test } = require('node:test')
 const Fastify = require('..')
 const ContentType = require('../lib/content-type')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 const echoBody = (req, reply) => { reply.send(req.body) }
 

package/test/schema-special-usage.test.js

@@ -9,7 +9,7 @@ const Fastify = require('..')
 const ajvMergePatch = require('ajv-merge-patch')
 const ajvErrors = require('ajv-errors')
 const proxyquire = require('proxyquire')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('Ajv plugins array parameter', (t, testDone) => {
   t.plan(3)

package/test/schema-validation.test.js

@@ -5,7 +5,7 @@ const Fastify = require('..')
 
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 const { kRequestContentType } = require('../lib/symbols')
 
 const customSchemaCompilers = {

package/test/stream.2.test.js

@@ -7,7 +7,7 @@ const resolve = require('node:path').resolve
 const zlib = require('node:zlib')
 const pipeline = require('node:stream').pipeline
 const Fastify = require('..')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('onSend hook stream', t => {
   t.plan(4)

package/test/toolkit.js

@@ -1,63 +0,0 @@
-'use strict'
-
-exports.waitForCb = function (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 }
-}
-
-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
-}