@fastify/reply-from 7.0.0

package/test/http-retry.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+const { test } = require('tap')
+
+let retryNum = 1
+
+const target = require('http').createServer(function (req, res) {
+  if (retryNum % 2 !== 0) {
+    req.socket.destroy()
+  } else {
+    res.statusCode = 200
+    res.setHeader('Content-Type', 'text/plain')
+    res.end('hello world')
+  }
+
+  retryNum += 1
+})
+
+test('Will retry', async function (t) {
+  t.teardown(() => { retryNum = 1 })
+
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, { http: true })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 1,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'ECONNRESET')
+        reply.send(error)
+      }
+    })
+  })
+
+  await instance.listen(0)
+  t.teardown(instance.close.bind(instance))
+
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  t.equal(statusCode, 200)
+})
+
+test('will not retry', async function (t) {
+  t.teardown(() => { retryNum = 1 })
+
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, { http: true })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 0,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'ECONNRESET')
+        reply.send(error)
+      }
+    })
+  })
+
+  await instance.listen(0)
+  t.teardown(instance.close.bind(instance))
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+    t.fail()
+  } catch (err) {
+    t.equal(err.response.statusCode, 500)
+  }
+})
+
+test('will not retry unsupported method', async function (t) {
+  t.teardown(() => { retryNum = 1 })
+
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, { http: true, retryMethods: ['DELETE'] })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 1,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'ECONNRESET')
+        reply.send(error)
+      }
+    })
+  })
+
+  await instance.listen(0)
+  t.teardown(instance.close.bind(instance))
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+    t.fail()
+  } catch (err) {
+    t.equal(err.response.statusCode, 500)
+  }
+})

package/test/http-timeout.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+const FakeTimers = require('@sinonjs/fake-timers')
+
+const clock = FakeTimers.createClock()
+
+t.autoend(false)
+
+const target = Fastify()
+t.teardown(target.close.bind(target))
+
+target.get('/', (request, reply) => {
+  t.pass('request arrives')
+
+  clock.setTimeout(() => {
+    reply.status(200).send('hello world')
+    t.end()
+  }, 200)
+})
+
+async function main () {
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen(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,
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
+    clock.tick(200)
+    return
+  }
+
+  t.fail()
+}
+
+main()

package/test/http2-http2.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const h2url = require('h2url')
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('fs')
+const path = require('path')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+t.test('http2 -> http2', async (t) => {
+  const instance = Fastify({
+    http2: true,
+    https: certs
+  })
+
+  t.teardown(instance.close.bind(instance))
+
+  const target = Fastify({
+    http2: true
+  })
+
+  target.get('/', (request, reply) => {
+    t.pass('request proxied')
+    reply.code(404).header('x-my-header', 'hello!').send({
+      hello: 'world'
+    })
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(target.close.bind(target))
+
+  await target.listen(0)
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: true,
+    rejectUnauthorized: false
+  })
+
+  await instance.listen(0)
+
+  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' })
+})

package/test/http2-https.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const h2url = require('h2url')
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+const fs = require('fs')
+const path = require('path')
+const certs = {
+  allowHTTP1: true, // fallback support for HTTP1
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+const instance = Fastify({
+  http2: true,
+  https: certs
+})
+
+t.plan(4)
+t.teardown(instance.close.bind(instance))
+
+const target = Fastify({
+  https: certs
+})
+
+target.get('/', (request, reply) => {
+  t.pass('request proxied')
+  reply.code(404).header('x-my-header', 'hello!').send({
+    hello: 'world'
+  })
+})
+
+instance.get('/', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+async function run () {
+  await target.listen(0)
+
+  instance.register(From, {
+    base: `https://localhost:${target.server.address().port}`,
+    rejectUnauthorized: false
+  })
+
+  await instance.listen(0)
+
+  t.test('http2 -> https', async (t) => {
+    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.test('https -> https', async (t) => {
+    try {
+      await got(`https://localhost:${instance.server.address().port}`, {
+        https: {
+          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()
+  })
+}
+
+run()

package/test/http2-invalid-target.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http2 invalid target', async (t) => {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+  instance.register(From, {
+    base: 'http://abc.xyz1',
+    http2: true
+  })
+
+  await instance.listen(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,
+      error: 'Service Unavailable',
+      message: 'Service Unavailable'
+    })
+    return
+  }
+  t.fail()
+})

package/test/http2-target-crash.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http -> http2 crash', async (t) => {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  const target = Fastify({
+    http2: true
+  })
+
+  target.get('/', (request, reply) => {
+    t.pass('request proxied')
+    reply.code(200).send({
+      hello: 'world'
+    })
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(target.close.bind(target))
+
+  await target.listen(0)
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: true
+  })
+
+  await instance.listen(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,
+      error: 'Service Unavailable',
+      message: 'Service Unavailable'
+    })
+    return
+  }
+  t.fail()
+})

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

@@ -0,0 +1,60 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http -> http2 crash multiple times', async (t) => {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  instance.register(From, {
+    base: 'http://localhost:3128',
+    http2: true,
+    sessionTimeout: 200
+  })
+
+  await instance.listen(0)
+
+  try {
+    let target = setupTarget()
+    await target.listen(3128)
+    await got(`http://localhost:${instance.server.address().port}`)
+    await target.close()
+    target = setupTarget()
+    await target.listen(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,
+      error: 'Service Unavailable',
+      message: 'Service Unavailable'
+    })
+    return
+  }
+  t.fail()
+
+  function setupTarget () {
+    const target = Fastify({
+      http2: true
+    })
+
+    target.get('/', (request, reply) => {
+      t.pass('request proxied')
+      reply.code(200).send({
+        hello: 'world'
+      })
+    })
+    return target
+  }
+})

package/test/http2-timeout.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http2 request timeout', async (t) => {
+  const target = Fastify({ http2: true, sessionTimeout: 0 })
+  t.teardown(target.close.bind(target))
+
+  target.get('/', () => {
+    t.pass('request arrives')
+  })
+
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { requestTimeout: 100 }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen(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,
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
+
+    return
+  }
+
+  t.fail()
+})
+
+test('http2 session timeout', async (t) => {
+  const target = Fastify({ http2: true, sessionTimeout: 0 })
+  t.teardown(target.close.bind(target))
+
+  target.get('/', () => {
+    t.pass('request arrives')
+  })
+
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { sessionTimeout: 100 }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen(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,
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
+
+    return
+  }
+
+  t.fail()
+})

package/test/https-agents.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const https = require('https')
+const get = require('simple-get').concat
+
+const fs = require('fs')
+const path = require('path')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+const instance = Fastify({
+  https: certs
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const target = https.createServer(certs, (req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `https://localhost:${target.address().port}`,
+    http: {
+      agents: {
+        'http:': new http.Agent({}),
+        'https:': new https.Agent({})
+      }
+    }
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `https://localhost:${instance.server.address().port}`,
+      rejectUnauthorized: false
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.headers['x-my-header'], 'hello!')
+      t.equal(res.statusCode, 205)
+      t.equal(data.toString(), 'hello world')
+    })
+  })
+})