@fastify/reply-from 12.1.0 → 12.3.0

package/test/http-timeout.test.js

@@ -1,18 +1,18 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 test('http request timeout', async (t) => {
   const clock = FakeTimers.createClock()
   const target = Fastify()
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     setTimeout(() => {
       reply.status(200).send('hello world')
@@ -24,7 +24,7 @@ test('http request timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, { http: { requestOptions: { timeout: 100 } } })
 
@@ -34,30 +34,30 @@ test('http request timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}/`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    return
-  }
+  })
 
-  t.fail()
+  t.assert.strictEqual(result.statusCode, 504)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
+  clock.tick(200)
 })
 
 test('http request with specific timeout', async (t) => {
   const clock = FakeTimers.createClock()
   const target = Fastify()
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     setTimeout(() => {
       reply.status(200).send('hello world')
@@ -69,7 +69,7 @@ test('http request with specific timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, { http: { requestOptions: { timeout: 100 } } })
 
@@ -85,32 +85,35 @@ test('http request with specific timeout', async (t) => {
   })
 
   await instance.listen({ port: 0 })
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
-  t.equal(statusCode, 200)
-
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}/success`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    return
-  }
+  })
+  t.assert.strictEqual(result.statusCode, 200)
 
-  t.fail()
+  const result2 = await request(`http://localhost:${instance.server.address().port}/fail`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+
+  t.assert.strictEqual(result2.statusCode, 504)
+  t.assert.match(result2.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result2.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
 })
 
 test('http sse removes timeout test', async (t) => {
   const target = Fastify()
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     reply.header('content-type', 'text/event-stream').status(200).send('hello world')
   })
@@ -118,7 +121,7 @@ test('http sse removes timeout test', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, { http: { requestOptions: { timeout: 100 } } })
 
@@ -128,6 +131,10 @@ test('http sse removes timeout test', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  t.equal(statusCode, 200)
+  const { statusCode } = await request(`http://localhost:${instance.server.address().port}/`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+  t.assert.strictEqual(statusCode, 200)
 })

package/test/http2-canceled-streams-cleanup.test.js

@@ -0,0 +1,117 @@
+'use strict'
+
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('node:fs')
+const path = require('node:path')
+const http2 = require('node:http2')
+const { once } = require('events')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+const { HTTP2_HEADER_STATUS, HTTP2_HEADER_PATH } = http2.constants
+
+function makeRequest (client, counter) {
+  return new Promise((resolve, reject) => {
+    const controller = new AbortController()
+    const signal = controller.signal
+    const cancelRequestEarly = counter % 2 === 0  // cancel early every other request
+    let responseCounter = 0
+
+    const clientStream = client.request({ [HTTP2_HEADER_PATH]: '/' }, { signal })
+
+    clientStream.end()
+
+    clientStream.on('data', chunk => {
+      const s = chunk.toString()
+      // Sometimes we just get NGHTTP2_ENHANCE_YOUR_CALM internal server errors
+      if (s.startsWith('{"statusCode":500')) reject(new Error('got internal server error'))
+      else responseCounter++
+    })
+
+    clientStream.on('error', err => {
+      if (err instanceof Error && err.name === 'AbortError') {
+        if (responseCounter === 0 && !cancelRequestEarly) {
+          // if we didn´t cancel early we should have received at least one response from the target
+          // if not, this indicated the stream resource leak
+          reject(new Error('no response'))
+        } else resolve()
+      } else reject(err instanceof Error ? err : new Error(JSON.stringify(err)))
+    })
+
+    clientStream.on('end', () => { resolve() })
+
+    setTimeout(() => { controller.abort() }, cancelRequestEarly ? 20 : 200)
+  })
+}
+
+const httpsOptions = {
+  ...certs,
+  settings: {
+    maxConcurrentStreams: 10, // lower the default so we can reproduce the problem quicker
+  }
+}
+
+t.test('http2 -> http2', async (t) => {
+  const instance = Fastify({
+    http2: true,
+    https: httpsOptions
+  })
+
+  t.after(() => instance.close())
+
+  const target = http2.createSecureServer(httpsOptions)
+
+  target.on('stream', (stream, _headers, _flags) => {
+    let counter = 0
+    let headerSent = false
+
+    // deliberately delay sending the headers
+    const sendData = () => {
+      if (!headerSent) {
+        stream.respond({ [HTTP2_HEADER_STATUS]: 200, })
+        headerSent = true
+      }
+      stream.write(counter + '\n')
+      counter = counter + 1
+    }
+
+    const intervalId = setInterval(sendData, 50)
+
+    // ignore write after end errors
+    stream.on('error', _err => { })
+
+    stream.on('close', () => { clearInterval(intervalId) })
+  })
+
+  instance.get('/', (_request, reply) => {
+    reply.from()
+  })
+
+  t.after(() => target.close())
+
+  target.listen()
+  await once(target, 'listening')
+
+  instance.register(From, {
+    base: `https://localhost:${target.address().port}`,
+    http2: true,
+    rejectUnauthorized: false
+  })
+
+  const url = await instance.listen({ port: 0 })
+
+  const client = http2.connect(url, {
+    rejectUnauthorized: false,
+  })
+
+  // see https://github.com/fastify/fastify-reply-from/issues/424
+  // without the bug fix this will fail after about 15 requests
+  for (let i = 0; i < 30; i++) { await makeRequest(client, i) }
+
+  client.close()
+  instance.close()
+  target.close()
+})

package/test/http2-goaway.test.js

@@ -0,0 +1,126 @@
+'use strict'
+
+const h2url = require('h2url')
+const t = require('node:test')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('node:fs')
+const path = require('node:path')
+const http2 = require('node:http2')
+
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+t.test('http2 goaway handling - reproduces issue #409', async (t) => {
+  let requestCount = 0
+
+  // Create a custom HTTP/2 server that sends GOAWAY after first request
+  const targetServer = http2.createServer()
+
+  let sessionToClose = null
+
+  targetServer.on('session', (session) => {
+    // Store the first session to send GOAWAY later
+    if (!sessionToClose) {
+      sessionToClose = session
+    }
+  })
+
+  targetServer.on('stream', (stream, headers) => {
+    requestCount++
+
+    if (requestCount === 1) {
+      // First request: respond normally
+      stream.respond({
+        ':status': 200,
+        'content-type': 'application/json'
+      })
+      stream.end(JSON.stringify({ request: requestCount, message: 'first request' }))
+
+      // Send GOAWAY after response to close the HTTP/2 session gracefully
+      setTimeout(() => {
+        if (sessionToClose && !sessionToClose.destroyed) {
+          // Send GOAWAY with NO_ERROR to close gracefully
+          sessionToClose.goaway(0)
+        }
+      }, 50)
+    } else {
+      // Subsequent requests should work with a new session
+      stream.respond({
+        ':status': 200,
+        'content-type': 'application/json'
+      })
+      stream.end(JSON.stringify({ request: requestCount, message: 'subsequent request' }))
+    }
+  })
+
+  await new Promise((resolve) => {
+    targetServer.listen(0, resolve)
+  })
+
+  const targetPort = targetServer.address().port
+
+  // Create proxy server
+  const instance = Fastify({
+    http2: true,
+    https: certs
+  })
+
+  instance.register(From, {
+    base: `http://localhost:${targetPort}`,
+    http2: true,
+    rejectUnauthorized: false
+  })
+
+  instance.get('/', (_request, reply) => {
+    reply.from()
+  })
+
+  await instance.listen({ port: 0 })
+
+  const proxyPort = instance.server.address().port
+
+  // First request - should succeed
+  const firstResponse = await h2url.concat({
+    url: `https://localhost:${proxyPort}`
+  })
+
+  t.assert.strictEqual(firstResponse.headers[':status'], 200)
+  const firstBody = JSON.parse(firstResponse.body)
+  t.assert.strictEqual(firstBody.request, 1)
+  t.assert.strictEqual(firstBody.message, 'first request')
+
+  // Wait for GOAWAY to be sent and processed
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  // Second request - this should fail with current implementation but work with fix
+  try {
+    const secondResponse = await h2url.concat({
+      url: `https://localhost:${proxyPort}`,
+      timeout: 1000
+    })
+
+    // If we get here with the current code, the request succeeded
+    // which means the issue might not be reproduced
+    t.assert.strictEqual(secondResponse.headers[':status'], 200)
+    const secondBody = JSON.parse(secondResponse.body)
+    t.assert.strictEqual(secondBody.request, 2)
+    t.assert.strictEqual(secondBody.message, 'subsequent request')
+    console.log('Second request succeeded - issue may not be reproduced or fix is already in place')
+  } catch (err) {
+    // This is expected without the fix - the session is stuck in closed state
+    console.log(`Second request failed (expected without fix): ${err.code || err.message}`)
+    // This demonstrates the issue exists - session is stuck after GOAWAY
+  }
+
+  // Cleanup in correct order: clients first, then proxy, then server
+  await instance.close()
+  targetServer.close()
+
+  // Force exit after a short delay to ensure test completes
+  setTimeout(() => {
+    process.exit(0)
+  }, 100)
+})

package/test/http2-http2.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const h2url = require('h2url')
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
 const From = require('..')
 const fs = require('node:fs')
@@ -17,14 +17,14 @@ t.test('http2 -> http2', async (t) => {
     https: certs
   })
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = Fastify({
     http2: true
   })
 
   target.get('/', (_request, reply) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     reply.code(404).header('x-my-header', 'hello!').send({
       hello: 'world'
     })
@@ -34,7 +34,7 @@ t.test('http2 -> http2', async (t) => {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await target.listen({ port: 0 })
 
@@ -50,10 +50,10 @@ t.test('http2 -> http2', async (t) => {
     url: `https://localhost:${instance.server.address().port}`
   })
 
-  t.equal(headers[':status'], 404)
-  t.equal(headers['x-my-header'], 'hello!')
-  t.match(headers['content-type'], /application\/json/)
-  t.same(JSON.parse(body), { hello: 'world' })
+  t.assert.strictEqual(headers[':status'], 404)
+  t.assert.strictEqual(headers['x-my-header'], 'hello!')
+  t.assert.match(headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   instance.close()
   target.close()
 })

package/test/http2-https.test.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const h2url = require('h2url')
-const t = require('tap')
+const t = require('node:test')
+const assert = require('node:assert')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 const fs = require('node:fs')
 const path = require('node:path')
 const certs = {
@@ -18,15 +19,12 @@ const instance = Fastify({
   https: certs
 })
 
-t.plan(4)
-t.teardown(instance.close.bind(instance))
-
 const target = Fastify({
   https: certs
 })
 
 target.get('/', (_request, reply) => {
-  t.pass('request proxied')
+  assert.ok('request proxied')
   reply.code(404).header('x-my-header', 'hello!').send({
     hello: 'world'
   })
@@ -36,9 +34,7 @@ instance.get('/', (_request, reply) => {
   reply.from()
 })
 
-t.teardown(target.close.bind(target))
-
-async function run () {
+async function run (t) {
   await target.listen({ port: 0 })
 
   instance.register(From, {
@@ -48,33 +44,39 @@ async function run () {
 
   await instance.listen({ port: 0 })
 
-  t.test('http2 -> https', async (t) => {
+  await t.test('http2 -> https', async (t) => {
+    t.plan(4)
     const { headers, body } = await h2url.concat({
       url: `https://localhost:${instance.server.address().port}`
     })
 
-    t.equal(headers[':status'], 404)
-    t.equal(headers['x-my-header'], 'hello!')
-    t.match(headers['content-type'], /application\/json/)
-    t.same(JSON.parse(body), { hello: 'world' })
+    t.assert.strictEqual(headers[':status'], 404)
+    t.assert.strictEqual(headers['x-my-header'], 'hello!')
+    t.assert.match(headers['content-type'], /application\/json/)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  t.test('https -> https', async (t) => {
-    try {
-      await got(`https://localhost:${instance.server.address().port}`, {
-        https: {
+  await t.test('https -> https', async (t) => {
+    t.plan(4)
+    const result = await request(`https://localhost:${instance.server.address().port}`, {
+      dispatcher: new Agent({
+        connect: {
           rejectUnauthorized: false
         }
       })
-    } catch (err) {
-      t.equal(err.response.statusCode, 404)
-      t.equal(err.response.headers['x-my-header'], 'hello!')
-      t.match(err.response.headers['content-type'], /application\/json/)
-      t.same(JSON.parse(err.response.body), { hello: 'world' })
-      return
-    }
-    t.fail()
+    })
+
+    t.assert.strictEqual(result.statusCode, 404)
+    t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+    t.assert.match(result.headers['content-type'], /application\/json/)
+    t.assert.deepStrictEqual(await result.body.json(), { hello: 'world' })
   })
 }
 
-run()
+t.test('http2 -> https', async (t) => {
+  t.plan(2)
+  t.after(() => instance.close())
+  t.after(() => target.close())
+
+  await run(t)
+})

package/test/http2-invalid-base.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const From = require('../index')
 
 test('http2 invalid base', async (t) => {
   const instance = Fastify()
 
-  await t.rejects(async () => instance.register(From, {
+  await t.assert.rejects(async () => instance.register(From, {
     http2: { requestTimeout: 100 }
   }), new Error('Option base is required when http2 is true'))
 })

package/test/http2-invalid-target.test.js

@@ -1,14 +1,14 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
-const got = require('got')
 
 test('http2 invalid target', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
     reply.from()
@@ -20,18 +20,14 @@ test('http2 invalid target', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 503)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 503,
-      code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
-      error: 'Service Unavailable',
-      message: 'Service Unavailable'
-    })
-    return
-  }
-  t.fail()
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 503)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 503,
+    code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
+    error: 'Service Unavailable',
+    message: 'Service Unavailable'
+  })
 })

package/test/http2-target-crash.test.js

@@ -1,21 +1,21 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
-const got = require('got')
 
 test('http -> http2 crash', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = Fastify({
     http2: true
   })
 
   target.get('/', (_request, reply) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     reply.code(200).send({
       hello: 'world'
     })
@@ -25,7 +25,7 @@ test('http -> http2 crash', async (t) => {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await target.listen({ port: 0 })
 
@@ -36,19 +36,15 @@ test('http -> http2 crash', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await target.close()
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 503)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 503,
-      code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
-      error: 'Service Unavailable',
-      message: 'Service Unavailable'
-    })
-    return
-  }
-  t.fail()
+  await target.close()
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 503)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 503,
+    code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
+    error: 'Service Unavailable',
+    message: 'Service Unavailable'
+  })
 })