fastify 5.11.3 → 5.12.1

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)
@@ -563,6 +563,38 @@ test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "
   completion.patience.then(testDone)
 })
 
+test('reports the canonical route url for hidden prefix trailing slash route', async t => {
+  t.plan(4)
+
+  const fastify = Fastify({
+    ignoreTrailingSlash: false,
+    exposeHeadRoutes: false
+  })
+
+  const onRouteUrls = []
+
+  fastify.addHook('onRoute', routeOptions => {
+    onRouteUrls.push(routeOptions.url)
+  })
+
+  fastify.register(async instance => {
+    instance.get('/', async request => {
+      return request.routeOptions.url
+    })
+
+    instance.get('/bar/', async request => {
+      return request.routeOptions.url
+    })
+  }, { prefix: '/prefix' })
+
+  t.assert.strictEqual((await fastify.inject('/prefix')).payload, '/prefix')
+  t.assert.strictEqual((await fastify.inject('/prefix/')).payload, '/prefix')
+  t.assert.strictEqual((await fastify.inject('/prefix/bar/')).payload, '/prefix/bar/')
+  t.assert.deepStrictEqual(onRouteUrls, ['/prefix', '/prefix/bar/'])
+
+  await fastify.close()
+})
+
 test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreDuplicateSlashes: false', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify({

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/trust-proxy.test.js

@@ -106,20 +106,33 @@ test('trust proxy function', async t => {
   await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined, 'fastify.test:1234')
 })
 
-test('trust proxy number', async t => {
-  t.plan(8)
+test('trust proxy number ignores forwarded headers', async t => {
+  t.plan(5)
   const app = fastify({
     trustProxy: 1
   })
   t.after(() => app.close())
 
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
+    t.assert.strictEqual(req.ip, '203.0.113.7', 'ip falls back to socket remote address')
+    t.assert.deepStrictEqual(req.ips, ['203.0.113.7'], 'ips falls back to socket remote address')
+    t.assert.strictEqual(req.host, 'app.example.com', 'host ignores x-forwarded-host')
+    t.assert.strictEqual(req.hostname, 'app.example.com', 'hostname ignores x-forwarded-host')
+    t.assert.strictEqual(req.protocol, 'http', 'protocol ignores x-forwarded-proto')
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, 'fastify.test:1234')
+  await app.inject({
+    method: 'GET',
+    url: '/trustproxynumber',
+    remoteAddress: '203.0.113.7',
+    headers: {
+      host: 'app.example.com',
+      'x-forwarded-for': '9.9.9.9, 8.8.8.8',
+      'x-forwarded-host': 'evil.com',
+      'x-forwarded-proto': 'https'
+    }
+  })
 })
 
 test('trust proxy IP addresses', async t => {
@@ -241,18 +254,15 @@ test('trust proxy reads forwarded headers from trusted connections', async t =>
   })
 })
 
-test('trust proxy with number and undefined socket remoteAddress', t => {
+test('trust proxy with number and undefined socket remoteAddress ignores forwarded headers', t => {
   t.plan(3)
 
-  // Test case for issue #6606: trustProxy: 1 with undefined/null socket.remoteAddress
-  // This simulates IISNode on Windows where socket.remoteAddress may be undefined
   const headers = {
+    host: 'real.test',
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'fastify.test',
     'x-forwarded-proto': 'https'
   }
-  // socket must exist but remoteAddress can be undefined
-  // This is what happens in IISNode with enableXFF="true"
   const req = {
     method: 'GET',
     url: '/',
@@ -262,20 +272,16 @@ test('trust proxy with number and undefined socket remoteAddress', t => {
 
   const TpRequest = buildRequest(Request, 1)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  // Even with undefined socket.remoteAddress, req.ip should be populated from X-Forwarded-For
-  t.assert.ok(request.ip, 'ip is defined')
-  // With trustProxy: 1, we trust 1 hop from socket. Since socket.remoteAddress is undefined,
-  // the hop count check should skip it and we get 1.1.1.1 (the first trusted address from X-Forwarded-For)
-  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
-  // The host should also work correctly
-  t.assert.strictEqual(request.host, 'fastify.test', 'gets host from x-forwarded-host')
+  t.assert.strictEqual(request.ip, undefined, 'ip falls back to undefined socket remote address')
+  t.assert.strictEqual(request.host, 'real.test', 'host ignores x-forwarded-host')
+  t.assert.strictEqual(request.protocol, 'http', 'protocol ignores x-forwarded-proto')
 })
 
-test('trust proxy with number and null socket remoteAddress', t => {
+test('trust proxy with number and null socket remoteAddress ignores forwarded headers', t => {
   t.plan(2)
 
-  // Test case for trustProxy: 1 with null socket.remoteAddress
   const headers = {
+    host: 'real.test',
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'fastify.test'
   }
@@ -288,8 +294,8 @@ test('trust proxy with number and null socket remoteAddress', t => {
 
   const TpRequest = buildRequest(Request, 1)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.assert.ok(request.ip, 'ip is defined')
-  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
+  t.assert.strictEqual(request.ip, null, 'ip falls back to null socket remote address')
+  t.assert.strictEqual(request.host, 'real.test', 'host ignores x-forwarded-host')
 })
 
 test('trust proxy does not trust x-forwarded-host/proto when socket is null', t => {

package/test/types/fastify.tst.ts

@@ -198,6 +198,8 @@ expect(fastify({
   }
 })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ trustProxy: true })).type.toBeAssignableTo<FastifyInstance>()
+// @ts-expect-error  No overload matches this call.
+fastify({ trustProxy: 1 })
 expect(fastify({ querystringParser: () => ({ foo: 'bar' }) })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ querystringParser: () => ({ foo: { bar: 'fuzz' } }) })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ querystringParser: () => ({ foo: ['bar', 'fuzz'] }) })).type.toBeAssignableTo<FastifyInstance>()