fastify 6.0.0-alpha.5 → 6.0.0-alpha.6

package/test/handler-timeout.test.js

@@ -2,6 +2,7 @@
 
 const { test } = require('node:test')
 const net = require('node:net')
+const http2 = require('node:http2')
 const Fastify = require('..')
 const { Readable } = require('node:stream')
 const { kTimeoutTimer, kOnAbort } = require('../lib/symbols')
@@ -201,6 +202,229 @@ test('streaming response: timer clears when response finishes', async t => {
   t.assert.strictEqual(res.status, 200)
 })
 
+// Regression test for GHSA-3qgw-9275-xf8w:
+// a streaming response that has already transmitted its headers must not
+// crash the server when handlerTimeout expires. Instead of trying to send
+// an error response (which would raise an uncaught ERR_HTTP_HEADERS_SENT),
+// the in-flight response is aborted and the server stays alive.
+test('streaming response exceeding handlerTimeout aborts instead of crashing', async t => {
+  t.plan(4)
+
+  const fastify = Fastify({ handlerTimeout: 100 })
+
+  // A logical gate (a deferred promise) keeps the stream open. The gateway
+  // is only released during teardown, so the stream never ends on its own
+  // and the handlerTimeout is what terminates the response. Relying on a
+  // wall-clock setTimeout to control the stream would be flaky (it can fire
+  // after the stream has already been destroyed).
+  let release
+  const gate = new Promise((resolve) => { release = resolve })
+
+  fastify.get('/stream', async (request, reply) => {
+    let started = false
+    const stream = new Readable({
+      read () {
+        if (started) return
+        started = true
+        // Emit one chunk so the response headers are transmitted before the
+        // handler timeout fires, then hold the stream open on the gate until
+        // the timeout aborts the response.
+        this.push('first')
+        gate.then(() => {
+          if (!this.destroyed) this.push(null)
+        })
+      }
+    })
+    reply.type('text/plain').send(stream)
+    return reply
+  })
+
+  fastify.get('/after', async () => ({ ok: true }))
+
+  await fastify.listen({ port: 0 })
+  t.after(async () => {
+    release()
+    await fastify.close()
+  })
+
+  const base = `http://127.0.0.1:${fastify.server.address().port}`
+
+  // Headers and the first chunk are transmitted before the timeout expires, so
+  // the client observes a 200, but the body is aborted when the timeout fires.
+  const res = await fetch(`${base}/stream`)
+  t.assert.strictEqual(res.status, 200)
+  t.assert.strictEqual(res.headers.get('content-type'), 'text/plain')
+  await t.assert.rejects(() => res.text())
+
+  // The server must not have crashed and must still serve other requests.
+  const after = await fetch(`${base}/after`)
+  t.assert.strictEqual(after.status, 200)
+})
+
+// Over HTTP/2, payloads larger than 64 KiB are written in chunks and the
+// response is ended only after the last one. A client that never reads the
+// body keeps the response open with its headers already sent.
+test('HTTP/2 payload still being written when handlerTimeout fires aborts instead of crashing', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({ http2: true, handlerTimeout: 100 })
+  const big = Buffer.alloc(4 * 1024 * 1024, 'a')
+
+  fastify.get('/big', async (request, reply) => {
+    reply.type('text/plain')
+    return big
+  })
+
+  fastify.get('/after', async () => 'ok')
+
+  await fastify.listen({ port: 0 })
+
+  const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+  t.after(async () => {
+    client.destroy()
+    await fastify.close()
+  })
+
+  await new Promise((resolve) => {
+    const req = client.request({ ':path': '/big' })
+    req.on('response', (headers) => {
+      t.assert.strictEqual(headers[':status'], 200)
+      // Never read the body, so the flow-control window is never replenished.
+      req.pause()
+    })
+    req.on('error', () => {})
+    req.on('close', resolve)
+    req.end()
+  })
+
+  // The server must not have crashed and must still serve other requests.
+  const body = await new Promise((resolve, reject) => {
+    const req = client.request({ ':path': '/after' })
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (chunk) => { data += chunk })
+    req.on('end', () => resolve(data))
+    req.on('error', reject)
+    req.end()
+  })
+  t.assert.strictEqual(body, 'ok')
+})
+
+// Regression test for GHSA-3qgw-9275-xf8w:
+// aborting request.signal on timeout runs any application abort listener
+// synchronously. If that listener sends the response itself, the timeout path
+// must not then destroy it: doing so resets the keep-alive connection (and any
+// other in-flight requests on it). The connection must stay usable afterwards.
+test('handlerTimeout keeps the connection usable when an abort listener sends the response', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({ handlerTimeout: 100 })
+
+  // A deferred gate keeps the handler pending so the timeout is what ends the
+  // request, while the abort listener sends a complete 504 response.
+  let release
+  const gate = new Promise((resolve) => { release = resolve })
+
+  fastify.get('/timeout', async (request, reply) => {
+    request.signal.addEventListener('abort', () => {
+      reply.code(504).type('text/plain').send('handled by abort listener')
+    })
+    await gate
+  })
+  fastify.get('/after', async () => 'ok')
+
+  await fastify.listen({ port: 0 })
+  t.after(async () => {
+    release()
+    await fastify.close()
+  })
+
+  const socket = net.connect(fastify.server.address().port, '127.0.0.1')
+  t.after(() => socket.destroy())
+
+  const second = await new Promise((resolve, reject) => {
+    let buffer = ''
+    let reused = false
+    socket.setEncoding('utf8')
+    socket.on('connect', () => {
+      socket.write('GET /timeout HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n')
+    })
+    socket.on('data', (chunk) => {
+      buffer += chunk
+      if (!reused && buffer.includes('handled by abort listener')) {
+        // The abort listener's response arrived; reuse the same socket.
+        reused = true
+        buffer = ''
+        socket.write('GET /after HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
+      } else if (reused && buffer.includes('ok')) {
+        resolve(buffer)
+      }
+    })
+    socket.on('error', reject)
+    // Without the fix the server destroys the socket after the first response,
+    // so the follow-up request never completes.
+    socket.on('close', () => reject(new Error('connection was reset before the follow-up request completed')))
+  })
+
+  t.assert.strictEqual(second.startsWith('HTTP/1.1 200'), true)
+  t.assert.strictEqual(second.includes('ok'), true)
+})
+
+// A response can be ended (reply.sent === true) while its body is still being
+// flushed to a slow client, so 'finish' has not fired and the timer is still
+// pending. When it fires it must leave the response and request.signal alone.
+// 'finish' is held back explicitly so the test does not depend on how much
+// data the OS socket buffers absorb.
+test('handlerTimeout firing after the reply ended but before it finished is a no-op', async t => {
+  t.plan(4)
+
+  const fastify = Fastify({ handlerTimeout: 50 })
+
+  let signal
+  fastify.get('/', async (request, reply) => {
+    signal = request.signal
+    const res = reply.raw
+    const emit = res.emit
+    res.emit = function (event, ...args) {
+      if (event !== 'finish') return emit.call(this, event, ...args)
+      // Emit 'finish' only well after the handlerTimeout has fired.
+      setTimeout(() => {
+        t.assert.strictEqual(reply.sent, true)
+        t.assert.strictEqual(signal.aborted, false)
+        emit.call(this, event, ...args)
+      }, 200)
+      return true
+    }
+    return 'ok'
+  })
+
+  await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  // A raw keep-alive connection, so nothing but the timer can abort the
+  // request while 'finish' is pending.
+  const socket = net.connect(fastify.server.address().port, '127.0.0.1')
+  t.after(() => socket.destroy())
+
+  const response = await new Promise((resolve, reject) => {
+    let buffer = ''
+    socket.setEncoding('utf8')
+    socket.on('connect', () => {
+      socket.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
+    })
+    socket.on('data', (chunk) => {
+      buffer += chunk
+      if (buffer.endsWith('ok')) resolve(buffer)
+    })
+    socket.on('error', reject)
+  })
+  t.assert.strictEqual(response.startsWith('HTTP/1.1 200'), true)
+
+  // Wait for the deferred 'finish', then the request must still not be aborted.
+  await new Promise((resolve) => setTimeout(resolve, 300))
+  t.assert.strictEqual(signal.aborted, false)
+})
+
 // --- SSE with reply.hijack() ---
 
 test('reply.hijack() clears timeout timer', async t => {

package/test/internals/all.test.js

@@ -33,6 +33,11 @@ test('fastify.all should add all the methods to the same url', async t => {
     }
 
     const res = await fastify.inject(options)
+    if (method === 'HEAD') {
+      // A HEAD response has no body, only the headers of the GET-like response
+      t.assert.strictEqual(res.headers['content-length'], String(Buffer.byteLength(JSON.stringify({ method }))))
+      return
+    }
     const payload = JSON.parse(res.payload)
     t.assert.deepStrictEqual(payload, { method })
   }

package/test/internals/errors.test.js

@@ -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,13 +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)
+  t.assert.strictEqual(error.stack, undefined)
 })
 
 test('FST_ERR_REOPENED_CLOSE_SERVER', t => {
@@ -911,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/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-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)