@fastify/reply-from 12.0.2 → 12.2.0

package/test/http-timeout.test.js

@@ -1,30 +1,30 @@
 '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')
 
-const clock = FakeTimers.createClock()
-
 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')
 
-    clock.setTimeout(() => {
+    setTimeout(() => {
       reply.status(200).send('hello world')
-      t.end()
     }, 200)
+
+    clock.tick(200)
   })
 
   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,86 @@ 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
     })
+  })
+
+  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.after(() => target.close())
+
+  target.get('/', (_request, reply) => {
+    t.assert.ok('request arrives')
+
+    setTimeout(() => {
+      reply.status(200).send('hello world')
+    }, 200)
+
     clock.tick(200)
-    return
-  }
+  })
+
+  await target.listen({ port: 0 })
 
-  t.fail()
+  const instance = Fastify()
+  t.after(() => instance.close())
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/success', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 300
+    })
+  })
+  instance.get('/fail', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 50
+    })
+  })
+
+  await instance.listen({ port: 0 })
+  const result = await request(`http://localhost:${instance.server.address().port}/success`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+  t.assert.strictEqual(result.statusCode, 200)
+
+  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')
   })
@@ -65,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 } } })
 
@@ -75,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-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'
+  })
 })

package/test/http2-target-multi-crash.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('http -> http2 crash multiple times', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
     reply.from()
@@ -23,29 +23,24 @@ test('http -> http2 crash multiple times', async (t) => {
   })
 
   await instance.listen({ port: 0 })
-
-  try {
-    let target = setupTarget()
-    await target.listen({ port: 3128 })
-    await got(`http://localhost:${instance.server.address().port}`)
-    await target.close()
-    target = setupTarget()
-    await target.listen({ port: 3128 })
-    await got(`http://localhost:${instance.server.address().port}`)
-    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()
+  let target = setupTarget()
+  await target.listen({ port: 3128 })
+  await request(`http://localhost:${instance.server.address().port}`)
+  await target.close()
+  target = setupTarget()
+  await target.listen({ port: 3128 })
+  await request(`http://localhost:${instance.server.address().port}`)
+  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'
+  })
 
   function setupTarget () {
     const target = Fastify({
@@ -53,7 +48,7 @@ test('http -> http2 crash multiple times', async (t) => {
     })
 
     target.get('/', (request, reply) => {
-      t.pass('request proxied')
+      t.assert.ok('request proxied')
       reply.code(200).send({
         hello: 'world'
       })