fastify 6.0.0-alpha.4 → 6.0.0-alpha.6

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 95
+const expectedErrors = 94
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -151,53 +151,58 @@ test('FST_ERR_CTP_INVALID_PARSE_TYPE', t => {
 })
 
 test('FST_ERR_CTP_BODY_TOO_LARGE', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_CTP_BODY_TOO_LARGE()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_CTP_BODY_TOO_LARGE')
   t.assert.strictEqual(error.message, 'Request body is too large')
   t.assert.strictEqual(error.statusCode, 413)
   t.assert.ok(error instanceof RangeError)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_CTP_INVALID_MEDIA_TYPE', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_CTP_INVALID_MEDIA_TYPE()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
   t.assert.strictEqual(error.message, 'Unsupported Media Type')
   t.assert.strictEqual(error.statusCode, 415)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_CTP_INVALID_CONTENT_LENGTH', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_CTP_INVALID_CONTENT_LENGTH()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_CTP_INVALID_CONTENT_LENGTH')
   t.assert.strictEqual(error.message, 'Request body size did not match Content-Length')
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof RangeError)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_CTP_EMPTY_JSON_BODY', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_CTP_EMPTY_JSON_BODY()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_CTP_EMPTY_JSON_BODY')
   t.assert.strictEqual(error.message, "Body cannot be empty when content-type is set to 'application/json'")
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_CTP_INVALID_JSON_BODY', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_CTP_INVALID_JSON_BODY()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_CTP_INVALID_JSON_BODY')
   t.assert.strictEqual(error.message, "Body is not valid JSON but content-type is set to 'application/json'")
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_CTP_INSTANCE_ALREADY_STARTED', t => {
@@ -621,23 +626,25 @@ test('FST_ERR_DUPLICATED_ROUTE', t => {
 })
 
 test('FST_ERR_BAD_URL', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_BAD_URL()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_BAD_URL')
   t.assert.strictEqual(error.message, "'%s' is not a valid url component")
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_MAX_PARAM_LENGTH', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_MAX_PARAM_LENGTH()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_MAX_PARAM_LENGTH')
   t.assert.strictEqual(error.message, "'%s' is exceeding the max param length")
   t.assert.strictEqual(error.statusCode, 414)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_ASYNC_CONSTRAINT', t => {
@@ -781,23 +788,14 @@ test('FST_ERR_ROUTE_REWRITE_NOT_STR', t => {
 })
 
 test('FST_ERR_ROUTE_MISSING_CONTENT_TYPE', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_ROUTE_MISSING_CONTENT_TYPE()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_ROUTE_MISSING_CONTENT_TYPE')
   t.assert.strictEqual(error.message, "Method '%s' must provide a 'Content-Type' header.")
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof Error)
-})
-
-test('FST_ERR_ROUTE_MISSING_CONTENT', t => {
-  t.plan(5)
-  const error = new errors.FST_ERR_ROUTE_MISSING_CONTENT()
-  t.assert.strictEqual(error.name, 'FastifyError')
-  t.assert.strictEqual(error.code, 'FST_ERR_ROUTE_MISSING_CONTENT')
-  t.assert.strictEqual(error.message, "Method '%s' must provide a request body.")
-  t.assert.strictEqual(error.statusCode, 400)
-  t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_REOPENED_CLOSE_SERVER', t => {
@@ -921,13 +919,14 @@ test('FST_ERR_PLUGIN_TIMEOUT', t => {
 })
 
 test('FST_ERR_VALIDATION', t => {
-  t.plan(5)
+  t.plan(6)
   const error = new errors.FST_ERR_VALIDATION()
   t.assert.strictEqual(error.name, 'FastifyError')
   t.assert.strictEqual(error.code, 'FST_ERR_VALIDATION')
   t.assert.strictEqual(error.message, '%s')
   t.assert.strictEqual(error.statusCode, 400)
   t.assert.ok(error instanceof Error)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_LISTEN_OPTIONS_INVALID', t => {

package/test/internals/initial-config.test.js

@@ -45,6 +45,7 @@ test('without options passed to Fastify, initialConfig should expose default val
     routerOptions: {
       allowUnsafeRegex: false,
       caseSensitive: true,
+      compile: false,
       constraints: undefined,
       ignoreTrailingSlash: false,
       ignoreDuplicateSlashes: false,
@@ -302,6 +303,7 @@ test('Should not have issues when passing stream options to Pino.js', (t, done)
       routerOptions: {
         allowUnsafeRegex: false,
         caseSensitive: true,
+        compile: false,
         constraints: undefined,
         ignoreTrailingSlash: true,
         ignoreDuplicateSlashes: false,

package/test/internals/reply-serialize.test.js

@@ -712,3 +712,23 @@ test('Reply#serializeInput', async t => {
     })
   })
 })
+
+test('Reply#compileSerializationSchema omits absent metadata instead of passing null', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.setSerializerCompiler(({ httpStatus, contentType }) => {
+    t.assert.strictEqual(httpStatus, undefined)
+    t.assert.strictEqual(contentType, undefined)
+
+    return input => JSON.stringify(input)
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.compileSerializationSchema(getDefaultSchema())
+    reply.send({ hello: 'world' })
+  })
+
+  await fastify.inject({ path: '/', method: 'GET' })
+})

package/test/internals/reply.test.js

@@ -35,7 +35,7 @@ const doGet = async function (url) {
 
 test('Once called, Reply should return an object with methods', t => {
   t.plan(16)
-  const response = { res: 'res' }
+  const response = { res: 'res', getHeader: () => undefined }
   const context = {
     config: { onSend: [] },
     schema: {},
@@ -1003,6 +1003,35 @@ test('reply can set multiple instances of same header', async t => {
   t.assert.deepStrictEqual(result.headers.getSetCookie(), ['one', 'two'])
 })
 
+test('reply.header does not mutate a set-cookie array passed by the caller', async t => {
+  t.plan(5)
+
+  const fastify = require('../../')()
+  const defaults = ['a=1']
+
+  fastify.get('/headers', function (req, reply) {
+    reply
+      .header('set-cookie', defaults)
+      .header('set-cookie', 'b=2')
+      .send({})
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const first = await fetch(`${fastifyServer}/headers`)
+  t.assert.deepStrictEqual(first.headers.getSetCookie(), ['a=1', 'b=2'])
+  const second = await fetch(`${fastifyServer}/headers`)
+  t.assert.deepStrictEqual(second.headers.getSetCookie(), ['a=1', 'b=2'])
+  t.assert.deepStrictEqual(defaults, ['a=1'])
+
+  const reply = new Reply({ setHeader () {}, removeHeader () {} }, {}, {})
+  const cookies = ['one']
+  reply.header('set-cookie', cookies).header('set-cookie', 'two')
+  t.assert.deepStrictEqual(reply.getHeader('set-cookie'), ['one', 'two'])
+  t.assert.deepStrictEqual(cookies, ['one'])
+})
+
 test('reply.hasHeader returns correct values', async t => {
   t.plan(2)
 

package/test/internals/request.test.js

@@ -402,6 +402,56 @@ test('Request with trust proxy - handles multiple entries in x-forwarded-host/pr
   t.assert.strictEqual(request.protocol, 'https')
 })
 
+test('Request with trust proxy - host getter reads the merged headers once', t => {
+  t.plan(2)
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: 'ip' },
+    headers: { host: 'fastify.test' }
+  }
+
+  const TpRequest = Request.buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  // the headers getter may allocate a new object once request.headers was
+  // assigned in a hook, so the host getter must read it once per access
+  const additional = { 'user-assigned': 'yes' }
+  let reads = 0
+  Object.defineProperty(request, 'headers', {
+    get () {
+      reads++
+      return Object.assign({}, req.headers, additional)
+    }
+  })
+  t.assert.strictEqual(request.host, 'fastify.test')
+  t.assert.strictEqual(reads, 1)
+})
+
+test('Request with trust proxy - protocol getter reads the merged headers once', t => {
+  t.plan(2)
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: 'ip' },
+    headers: { 'x-forwarded-proto': 'https' }
+  }
+
+  const TpRequest = Request.buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  // the headers getter may allocate a new object once request.headers was
+  // assigned in a hook, so the protocol getter must read it once per access
+  const additional = { 'user-assigned': 'yes' }
+  let reads = 0
+  Object.defineProperty(request, 'headers', {
+    get () {
+      reads++
+      return Object.assign({}, req.headers, additional)
+    }
+  })
+  t.assert.strictEqual(request.protocol, 'https')
+  t.assert.strictEqual(reads, 1)
+})
+
 test('Request with trust proxy - plain', t => {
   t.plan(1)
   const headers = {

package/test/internals/server.test.js

@@ -12,13 +12,15 @@ const handler = (req, res) => {
 }
 
 test('start listening', async t => {
+  t.plan(1)
   const { server, listen } = createServer({}, handler)
+  t.after(() => server.close())
   await listen.call(Fastify(), { port: 0, host: 'localhost' })
-  server.close()
-  t.assert.ok(true, 'server started')
+  t.assert.ok(server.listening, 'the server is listening')
 })
 
 test('DNS errors does not stop the main server on localhost - promise interface', async t => {
+  t.plan(1)
   const { createServer } = proxyquire('../../lib/server', {
     'node:dns': {
       lookup: (hostname, options, cb) => {
@@ -27,9 +29,9 @@ test('DNS errors does not stop the main server on localhost - promise interface'
     }
   })
   const { server, listen } = createServer({}, handler)
+  t.after(() => server.close())
   await listen.call(Fastify(), { port: 0, host: 'localhost' })
-  server.close()
-  t.assert.ok(true, 'server started')
+  t.assert.ok(server.listening, 'the DNS error did not stop the server listening')
 })
 
 test('DNS errors does not stop the main server on localhost - callback interface', (t, done) => {

package/test/reply-error.test.js

@@ -245,6 +245,35 @@ test('Error status code below 400 defaults to 500', (t, testDone) => {
   })
 })
 
+test('Error status code above 599 defaults to 500', (t, testDone) => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  const err = new Error('winter is coming')
+  err.statusCode = 600
+
+  fastify.get('/', () => {
+    return Promise.reject(err)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(
+      {
+        error: statusCodes['500'],
+        message: err.message,
+        statusCode: 500
+      },
+      JSON.parse(res.payload)
+    )
+    testDone()
+  })
+})
+
 test('Error.status property support', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
@@ -848,3 +877,56 @@ test('should catch error when setting invalid header on async onSend hook', asyn
   app.get('/', async () => ({ ok: true }))
   await app.inject({ method: 'GET', path: '/' })
 })
+
+// The fallback error handler must not try to write a new response once the
+// current one has started transmitting: that would raise an uncaught
+// ERR_HTTP_HEADERS_SENT and terminate the process. It aborts the response.
+test('fallback error handler aborts the response when headers were already sent', async (t) => {
+  t.plan(2)
+
+  const app = Fastify()
+  app.addHook('onSend', async (request, reply) => {
+    if (reply.raw.headersSent === false) {
+      reply.raw.writeHead(200, { 'content-type': 'text/plain' })
+      reply.raw.write('partial')
+    }
+    throw new Error('kaboom')
+  })
+  app.get('/', async () => 'ok')
+
+  await app.listen({ port: 0 })
+  t.after(() => app.close())
+
+  const base = `http://127.0.0.1:${app.server.address().port}`
+  await t.assert.rejects(async () => {
+    const res = await fetch(`${base}/`)
+    await res.text()
+  })
+
+  // The server must not have crashed.
+  t.assert.strictEqual(app.server.listening, true)
+})
+
+test('fallback error handler aborts the response when writeHead throws ERR_HTTP_HEADERS_SENT', async (t) => {
+  t.plan(2)
+
+  const app = Fastify()
+  app.addHook('onSend', async (request, reply, payload) => {
+    reply.raw.writeHead = function () {
+      const err = new Error('Cannot write headers after they are sent to the client')
+      err.code = 'ERR_HTTP_HEADERS_SENT'
+      throw err
+    }
+    return payload
+  })
+  app.get('/', async () => 'ok')
+
+  await app.listen({ port: 0 })
+  t.after(() => app.close())
+
+  const base = `http://127.0.0.1:${app.server.address().port}`
+  await t.assert.rejects(fetch(`${base}/`))
+
+  // The server must not have crashed.
+  t.assert.strictEqual(app.server.listening, true)
+})

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

@@ -129,3 +129,60 @@ test('reply.mediaType should reflect the last type set', async (t) => {
   const body = response.body
   t.assert.strictEqual(body, 'mediaType = text/plain')
 })
+
+test('reply.mediaType should match the content-type set via raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('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 match case-insensitive content-type set via raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('Content-Type', 'text/html; charset=utf-8')
+    t.assert.strictEqual(reply.mediaType, 'text/html')
+    reply.send(reply.mediaType)
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.strictEqual(response.body, 'text/html')
+})
+
+test('reply.mediaType should prioritize reply.type over raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('content-type', 'application/xml')
+    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')
+})

package/test/reply-trailers.test.js

@@ -4,7 +4,28 @@ const { test, describe } = require('node:test')
 const Fastify = require('..')
 const { Readable } = require('node:stream')
 const { createHash } = require('node:crypto')
-const { sleep } = require('./helper')
+const { sleep, getServerUrl } = require('./helper')
+const http = require('node:http')
+
+function getWithTrailers (url) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(url, (res) => {
+      const chunks = []
+      res.on('data', (chunk) => chunks.push(chunk))
+      res.on('end', () => {
+        resolve({
+          statusCode: res.statusCode,
+          headers: res.headers,
+          trailers: res.trailers,
+          body: Buffer.concat(chunks).toString()
+        })
+      })
+      res.on('error', reject)
+    })
+    req.on('error', reject)
+    req.end()
+  })
+}
 
 test('send trailers when payload is empty string', (t, testDone) => {
   t.plan(5)
@@ -142,6 +163,143 @@ test('send trailers when payload is stream', (t, testDone) => {
   })
 })
 
+// fastify.inject() never touches a real socket, so it cannot observe
+// the res.end() race between Readable#pipe() and the trailer flush.
+describe('trailers over a real socket', () => {
+  test('send trailers when payload is a Readable stream', async (t) => {
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('ETag', function (reply, payload, done) {
+        done(null, 'custom-etag')
+      })
+      const stream = Readable.from([JSON.stringify({ hello: 'world' })])
+      reply.send(stream)
+    })
+
+    await fastify.listen({ port: 0 })
+    t.after(() => fastify.close())
+
+    const res = await getWithTrailers(getServerUrl(fastify))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+    t.assert.strictEqual(res.headers.trailer, 'etag')
+    t.assert.strictEqual(res.trailers.etag, 'custom-etag')
+    t.assert.strictEqual(res.body, JSON.stringify({ hello: 'world' }))
+  })
+
+  test('send trailers when payload is a web ReadableStream', async (t) => {
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('ETag', function (reply, payload, done) {
+        done(null, 'custom-etag')
+      })
+      const webStream = new ReadableStream({
+        start (controller) {
+          controller.enqueue(Buffer.from(JSON.stringify({ hello: 'world' })))
+          controller.close()
+        }
+      })
+      reply.send(webStream)
+    })
+
+    await fastify.listen({ port: 0 })
+    t.after(() => fastify.close())
+
+    const res = await getWithTrailers(getServerUrl(fastify))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.trailer, 'etag')
+    t.assert.strictEqual(res.trailers.etag, 'custom-etag')
+    t.assert.strictEqual(res.body, JSON.stringify({ hello: 'world' }))
+  })
+
+  test('send trailers when payload is a pre-ended Readable stream', async (t) => {
+    const fastify = Fastify()
+
+    // drain the stream and let 'end' pass before it is ever handed to
+    // send(), so sendStream() attaches its listeners after the stream
+    // is already done. the route handler stays synchronous so fastify's
+    // async "did the handler forget to send" rescue in wrap-thenable
+    // never gets a chance to paper over a stuck response.
+    const stream = Readable.from([JSON.stringify({ hello: 'world' })])
+    stream.resume()
+    await new Promise((resolve) => stream.on('end', resolve))
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('ETag', function (reply, payload, done) {
+        done(null, 'custom-etag')
+      })
+      reply.send(stream)
+    })
+
+    await fastify.listen({ port: 0 })
+    t.after(() => fastify.close())
+
+    const res = await Promise.race([
+      getWithTrailers(getServerUrl(fastify)),
+      new Promise((resolve, reject) => {
+        const hangTimer = setTimeout(() => reject(new Error('response hung')), 2000)
+        t.after(() => clearTimeout(hangTimer))
+      })
+    ])
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.trailer, 'etag')
+    t.assert.strictEqual(res.trailers.etag, 'custom-etag')
+    t.assert.strictEqual(res.body, '')
+  })
+
+  test('stream response with no trailers registered ends normally', async (t) => {
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      const stream = Readable.from(['no-trailer-payload'])
+      reply.send(stream)
+    })
+
+    await fastify.listen({ port: 0 })
+    t.after(() => fastify.close())
+
+    const res = await getWithTrailers(getServerUrl(fastify))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.trailers, {})
+    t.assert.strictEqual(res.body, 'no-trailer-payload')
+  })
+
+  test('stream error before end does not hang the response', async (t) => {
+    const fastify = Fastify({ logger: false })
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('ETag', function (reply, payload, done) {
+        done(null, 'custom-etag')
+      })
+      const stream = new Readable({
+        read () {
+          this.push('partial-data')
+          process.nextTick(() => this.destroy(new Error('boom')))
+        }
+      })
+      reply.send(stream)
+    })
+
+    await fastify.listen({ port: 0 })
+    t.after(() => fastify.close())
+
+    await new Promise((resolve, reject) => {
+      const req = http.request(getServerUrl(fastify), (res) => {
+        res.on('data', () => {})
+        res.on('error', () => resolve())
+        res.on('close', () => resolve())
+        res.on('end', () => resolve())
+      })
+      req.on('error', () => resolve())
+      req.end()
+      const hangTimer = setTimeout(() => reject(new Error('response hung')), 2000)
+      t.after(() => clearTimeout(hangTimer))
+    })
+  })
+})
+
 test('remove trailer while stream is being consumed', (t, testDone) => {
   t.plan(5)
 

package/test/rfc-10008.test.js

@@ -99,12 +99,9 @@ describe('RFC 10008', () => {
     t.assert.equal(res.json().code, 'FST_ERR_CTP_INVALID_JSON_BODY')
   })
 
-  test('should return 400 if no content is provided for QUERY method', async (t) => {
-    // If a media type is specified but is inconsistent
-    // with the actual request content, a 400 (Bad Request)
-    // can be returned. That is, a server is not allowed to
-    // infer a media type from the request content and then
-    // override a missing or "erroneous" value (i.e., "content sniffing").
+  test('should return 200 if body is empty but media type allows it for QUERY method', async (t) => {
+    // If a media type is set and allows the body to be empty,
+    // the server must allow it.
     t.plan(2)
 
     const fastify = Fastify()
@@ -116,11 +113,11 @@ describe('RFC 10008', () => {
     const res = await fastify.inject({
       method: 'QUERY',
       url: '/query',
-      headers: { 'Content-Type': 'application/json' }
+      headers: { 'Content-Type': 'text/plain' }
     })
 
-    t.assert.equal(res.statusCode, 400)
-    t.assert.equal(res.json().code, 'FST_ERR_ROUTE_MISSING_CONTENT')
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.body, '')
   })
 
   test('should return 415 if unsupported media type is provided for QUERY method', async (t) => {