@fastify/reply-from 7.0.0

package/test/retry-on-503.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const got = require('got')
+
+function createTargetServer (withRetryAfterHeader, stopAfter = 1) {
+  let requestCount = 0
+  return http.createServer((req, res) => {
+    if (requestCount++ < stopAfter) {
+      res.statusCode = 503
+      res.setHeader('Content-Type', 'text/plain')
+      if (withRetryAfterHeader) {
+        res.setHeader('Retry-After', 100)
+      }
+      return res.end('This Service is Unavailable')
+    }
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    return res.end(`Hello World ${requestCount}!`)
+  })
+}
+
+test('Should retry on 503 HTTP error', async function (t) {
+  t.plan(3)
+  const target = createTargetServer()
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(instance.close.bind(instance))
+  await instance.listen(0)
+
+  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
+  t.equal(res.headers['content-type'], 'text/plain')
+  t.equal(res.statusCode, 205)
+  t.equal(res.body.toString(), 'Hello World 2!')
+})
+
+test('Should retry on 503 HTTP error with Retry-After response header', async function (t) {
+  t.plan(3)
+  const target = createTargetServer(true)
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(instance.close.bind(instance))
+  await instance.listen(0)
+
+  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
+  t.equal(res.headers['content-type'], 'text/plain')
+  t.equal(res.statusCode, 205)
+  t.equal(res.body.toString(), 'Hello World 2!')
+})
+
+test('Should abort if server is always returning 503', async function (t) {
+  t.plan(2)
+  const target = createTargetServer(true, Number.MAX_SAFE_INTEGER)
+  await target.listen(0)
+  t.teardown(target.close.bind(target))
+
+  const instance = Fastify()
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(instance.close.bind(instance))
+  await instance.listen(0)
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
+    t.fail()
+  } catch (err) {
+    t.equal(err.response.statusCode, 503)
+    t.equal(err.response.body.toString(), 'This Service is Unavailable')
+  }
+})

package/test/rewrite-headers.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  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(`http://localhost:${target.address().port}`, {
+    rewriteHeaders: (headers, req) => {
+      t.pass('rewriteHeaders called')
+      return {
+        'content-type': headers['content-type'],
+        'x-another-header': 'so headers!'
+      }
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.headers['x-another-header'], 'so headers!')
+      t.notOk(res.headers['x-my-header'])
+      t.equal(res.statusCode, 205)
+    })
+  })
+})

package/test/rewrite-request-headers.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.end(req.headers.host)
+})
+
+instance.get('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    rewriteRequestHeaders: (originalReq, headers) => {
+      t.pass('rewriteRequestHeaders called')
+      return Object.assign(headers, { host: 'host-override' })
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.statusCode, 205)
+      t.equal(data.toString(), 'host-override')
+    })
+  })
+})

package/test/transform-body.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+const Transform = require('stream').Transform
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  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(`http://localhost:${target.address().port}`, {
+    onResponse: (request, reply, res) => {
+      reply.send(
+        res.pipe(
+          new Transform({
+            transform: function (chunk, enc, cb) {
+              this.push(chunk.toString().toUpperCase())
+              cb()
+            }
+          })
+        )
+      )
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, err => {
+  t.error(err)
+
+  target.listen(0, err => {
+    t.error(err)
+
+    get(
+      `http://localhost:${instance.server.address().port}`,
+      (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')
+      }
+    )
+  })
+})

package/test/undici-agent.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const proxyquire = require('proxyquire')
+const http = require('http')
+const get = require('simple-get').concat
+const undici = require('undici')
+const { getUndiciOptions } = require('../lib/request')
+
+t.plan(10)
+
+const instance = Fastify()
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  res.statusCode = 200
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, err => {
+  t.error(err)
+  let poolCreation = 0
+
+  const From = proxyquire('..', {
+    './lib/request.js': proxyquire('../lib/request.js', {
+      undici: proxyquire('undici', {
+        './lib/agent': proxyquire('undici/lib/agent.js', {
+          './pool': class Pool extends undici.Pool {
+            constructor (url, options) {
+              super(url, options)
+              poolCreation++
+            }
+          }
+        })
+      })
+    })
+  })
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: buildUndiciOptions()
+  })
+
+  instance.listen(0, err => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'hello world')
+      t.equal(poolCreation, 1)
+
+      get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+        t.error(err)
+        t.equal(res.statusCode, 200)
+        t.equal(data.toString(), 'hello world')
+        t.equal(poolCreation, 1)
+      })
+    })
+  })
+})
+
+function buildUndiciOptions () {
+  return getUndiciOptions({
+    connections: 42,
+    pipelining: 24,
+    keepAliveTimeout: 4242,
+    strictContentLength: false
+  })
+}

package/test/undici-body.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const bodyString = JSON.stringify({ hello: 'world' })
+
+const parsedLength = Buffer.byteLength(bodyString)
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'application/json')
+  t.same(req.headers['content-length'], parsedLength)
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.same(JSON.parse(data), { hello: 'world' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ something: 'else' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.addContentTypeParser('application/json', function (req, payload, done) {
+    done(null, payload)
+  })
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: true
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: bodyString
+    }, (err, res, data) => {
+      t.error(err)
+      const parsed = JSON.parse(data)
+      t.same(parsed, { something: 'else' })
+    })
+  })
+})

package/test/undici-options.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const proxyquire = require('proxyquire')
+const http = require('http')
+const get = require('simple-get').concat
+const undici = require('undici')
+const { getUndiciOptions } = require('../lib/request')
+
+const instance = Fastify()
+
+t.plan(6)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  res.statusCode = 200
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, err => {
+  t.error(err)
+
+  const From = proxyquire('..', {
+    './lib/request.js': proxyquire('../lib/request.js', {
+      undici: undiciProxy
+    })
+  })
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: buildUndiciOptions()
+  })
+
+  instance.listen(0, err => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'hello world')
+    })
+  })
+})
+
+function undiciProxy () {}
+undiciProxy.Agent = class Agent extends undici.Agent {
+  constructor (opts) {
+    super(opts)
+    t.strictSame(opts, buildUndiciOptions())
+  }
+}
+undiciProxy.Pool = class Pool extends undici.Pool {
+  constructor (url, options) {
+    super(url, options)
+    t.hasStrict(options, buildUndiciOptions())
+  }
+}
+
+function buildUndiciOptions () {
+  return getUndiciOptions({
+    connections: 42,
+    pipelining: 24,
+    keepAliveTimeout: 4242,
+    strictContentLength: false
+  })
+}

package/test/undici-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, { undici: true })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 1,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'UND_ERR_SOCKET')
+        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, { undici: true })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 0,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'UND_ERR_SOCKET')
+        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, { undici: true, retryMethods: ['DELETE'] })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/`, {
+      retriesCount: 1,
+      onError: (reply, { error }) => {
+        t.equal(error.code, 'UND_ERR_SOCKET')
+        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/undici-timeout-body-partial.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const t = require('tap')
+const http = require('http')
+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 = http.createServer((req, res) => {
+  t.pass('request proxied')
+  req.on('data', () => undefined)
+  req.on('end', () => {
+    res.writeHead(200)
+    res.flushHeaders()
+    res.write('test')
+    clock.setTimeout(() => {
+      res.end()
+      t.end()
+    }, 1000)
+  })
+})
+
+async function main () {
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+  t.teardown(target.close.bind(target))
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: {
+      bodyTimeout: 100
+    }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  await instance.listen(0)
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.code, 'ECONNRESET')
+    t.equal(err.response.statusCode, 200)
+    clock.tick(1000)
+    return
+  }
+
+  t.fail()
+}
+
+main()