@fastify/reply-from 7.0.0

package/test/async-route-handler.js

@@ -0,0 +1,50 @@
+'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(11)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((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('/', async (request, reply) => {
+  const p = reply.from()
+  t.equal(p, reply)
+  return p
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.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/base-get.js

@@ -0,0 +1,48 @@
+'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(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((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: `http://localhost:${target.address().port}`
+  })
+
+  instance.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/base-path.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const get = require('simple-get').concat
+const nock = require('nock')
+
+const instance = Fastify()
+
+nock('http://httpbin.org')
+  .get('/ip')
+  .reply(200, function (uri, requestBody) {
+    t.equal(this.req.headers.host, 'httpbin.org')
+    return { origin: '127.0.0.1' }
+  })
+
+t.plan(6)
+t.teardown(instance.close.bind(instance))
+
+instance.get('/', (request, reply) => {
+  reply.from('http://httpbin.org/ip')
+})
+
+instance.register(From, {
+  undici: false
+})
+
+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(res.headers['content-type'], 'application/json')
+    t.equal(typeof JSON.parse(data).origin, 'string')
+  })
+})

package/test/base-querystring.js

@@ -0,0 +1,48 @@
+'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(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/hello?a=b')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.get('/hello', (request, reply) => {
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}/hello?a=b`, (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/build-url.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { test } = require('tap')
+const { buildURL } = require('../lib/utils')
+
+test('should produce valid URL', (t) => {
+  t.plan(1)
+  const url = buildURL('/hi', 'http://localhost')
+  t.equal(url.href, 'http://localhost/hi')
+})
+
+test('should produce valid URL', (t) => {
+  t.plan(1)
+  const url = buildURL('http://localhost/hi', 'http://localhost')
+  t.equal(url.href, 'http://localhost/hi')
+})
+
+test('should return same source when base is not specified', (t) => {
+  t.plan(1)
+  const url = buildURL('http://localhost/hi')
+  t.equal(url.href, 'http://localhost/hi')
+})
+
+test('should handle lack of trailing slash in base', (t) => {
+  t.plan(3)
+  let url = buildURL('hi', 'http://localhost/hi')
+  t.equal(url.href, 'http://localhost/hi')
+
+  url = buildURL('hi/', 'http://localhost/hi')
+  t.equal(url.href, 'http://localhost/hi/')
+
+  url = buildURL('hi/more', 'http://localhost/hi')
+  t.equal(url.href, 'http://localhost/hi/more')
+})
+
+test('should handle default port in base', (t) => {
+  t.plan(2)
+  let url = buildURL('/hi', 'http://localhost:80/hi')
+  t.equal(url.href, 'http://localhost/hi')
+
+  url = buildURL('/hi', 'https://localhost:443/hi')
+  t.equal(url.href, 'https://localhost/hi')
+})
+
+const errorInputs = [
+  { source: '//10.0.0.10/hi', base: 'http://localhost' },
+  { source: 'http://10.0.0.10/hi', base: 'http://localhost' },
+  { source: 'https://10.0.0.10/hi', base: 'http://localhost' },
+  { source: 'blah://10.0.0.10/hi', base: 'http://localhost' },
+  { source: '//httpbin.org/hi', base: 'http://localhost' },
+  { source: 'urn:foo:bar', base: 'http://localhost' },
+  { source: 'http://localhost/private', base: 'http://localhost/exposed/' },
+  { source: 'http://localhost/exposed-extra', base: 'http://localhost/exposed' },
+  { source: '/private', base: 'http://localhost/exposed/' },
+  { source: '/exposed-extra', base: 'http://localhost/exposed' },
+  { source: '../private', base: 'http://localhost/exposed/' },
+  { source: 'exposed-extra', base: 'http://localhost/exposed' }
+]
+
+test('should throw when trying to override base', (t) => {
+  t.plan(errorInputs.length)
+
+  errorInputs.forEach(({ source, base }) => {
+    t.test(source, (t) => {
+      t.plan(1)
+      t.throws(() => buildURL(source, base))
+    })
+  })
+})

package/test/core-with-path-in-base.js

@@ -0,0 +1,50 @@
+'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(11)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/hello')
+  t.equal(req.headers.connection, 'close')
+  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('/hello')
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}/hello`,
+    http: true
+  })
+
+  instance.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/custom-undici-instance.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const undici = require('undici')
+const http = require('http')
+const get = require('simple-get').concat
+const From = require('..')
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/')
+  t.equal(req.headers.connection, 'keep-alive')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+t.test('use a custom instance of \'undici\'', async t => {
+  t.teardown(target.close.bind(target))
+
+  await new Promise((resolve, reject) => target.listen(0, err => err ? reject(err) : resolve()))
+
+  t.test('custom Pool', t => {
+    const instance = Fastify()
+    t.teardown(instance.close.bind(instance))
+    instance.register(From, {
+      base: `http://localhost:${target.address().port}`,
+      undici: new undici.Pool(`http://localhost:${target.address().port}`)
+    })
+
+    instance.get('/', (request, reply) => {
+      reply.from()
+    })
+
+    instance.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')
+        t.end()
+      })
+    })
+  })
+
+  t.test('custom Client', t => {
+    const instance = Fastify()
+    t.teardown(instance.close.bind(instance))
+    instance.register(From, {
+      base: `http://localhost:${target.address().port}`,
+      undici: new undici.Client(`http://localhost:${target.address().port}`)
+    })
+
+    instance.get('/', (request, reply) => {
+      reply.from()
+    })
+
+    instance.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')
+        t.end()
+      })
+    })
+  })
+})

package/test/fastify-multipart-incompatibility.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const Multipart = require('fastify-multipart')
+const http = require('http')
+const get = require('simple-get').concat
+const FormData = require('form-data')
+
+const split = require('split2')
+const logStream = split(JSON.parse)
+
+const instance = Fastify({
+  logger: {
+    level: 'warn',
+    stream: logStream
+  }
+})
+
+instance.register(Multipart)
+instance.register(From)
+
+t.plan(12)
+
+t.teardown(instance.close.bind(instance))
+
+const filetPath = path.join(__dirname, 'fixtures', 'file.txt')
+const fileContent = fs.readFileSync(filetPath, { encoding: 'utf-8' })
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.match(req.headers['content-type'], /^multipart\/form-data/)
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.notMatch(data, 'Content-Disposition: form-data; name="key"')
+    t.notMatch(data, 'value')
+    t.notMatch(data, 'Content-Disposition: form-data; name="file"')
+    t.notMatch(data, fileContent)
+    res.setHeader('content-type', 'application/json')
+    res.statusCode = 200
+    res.end(JSON.stringify({ something: 'else' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  logStream.on('data', (log) => {
+    if (
+      log.level === 40 &&
+      log.msg.match(/fastify-reply-from might not behave as expected when used with fastify-multipart/)
+    ) {
+      t.pass('incompatibility warn message logged')
+    }
+  })
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    const form = new FormData()
+    form.append('key', 'value')
+    form.append('file', fs.createReadStream(filetPath, { encoding: 'utf-8' }))
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      headers: {
+        ...form.getHeaders()
+      },
+      body: form
+    }, (err, res, data) => {
+      t.error(err)
+      t.same(JSON.parse(data), { something: 'else' })
+    })
+  })
+})

package/test/fixtures/fastify.cert

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDBzCCAe+gAwIBAgIJALbQMeb7k/WqMA0GCSqGSIb3DQEBBQUAMBoxGDAWBgNV
+BAMMD3d3dy5mYXN0aWZ5Lm9yZzAeFw0xNzAyMDcyMDE5NDJaFw0yNzAyMDUyMDE5
+NDJaMBoxGDAWBgNVBAMMD3d3dy5mYXN0aWZ5Lm9yZzCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBAKtfXzDMmU+n3A7oVVOiqp6Z5cgu1t+qgj7TadwXONvO
+RZvuOcE8BZpM9tQEDE5XEIdcszDx0tWKHHSobgZAxDaEuK1PMhh/RTNvw1KzYJFm
+2G38mqgm11JUni87xmIFqpgJfeCApHnWUv+3/npuQniOoVSL13jdXEifeFM8onQn
+R73TVDyvMOjljTulMo0n9V8pYhVSzPnm2uxTu03p5+HosQE2bU0QKj7k8/8dwRVX
+EqnTtbLoW+Wf7V2W3cr/UnfPH8JSaBWTqct0pgXqYIqOSTiWQkO7pE69mGPHrRlm
+7+whp4WRriTacB3Ul+Cbx28wHU+D83ver4A8LKGVDSECAwEAAaNQME4wHQYDVR0O
+BBYEFHVzTr/tNziIUrR75UHXXA84yqmgMB8GA1UdIwQYMBaAFHVzTr/tNziIUrR7
+5UHXXA84yqmgMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAKVSdGeF
+vYcZOi0TG2WX7O3tSmu4G4nGxTldFiEVF89G0AU+HhNy9iwKXQLjDB7zMe/ZKbtJ
+cQgc6s8eZWxBk/OoPD1WNFGstx2EO2kRkSUBKhwnOct7CIS5X+NPXyHx2Yi03JHX
+unMA4WaHyo0dK4vAuali4OYdQqajNwL74avkRIxXFnZQeHzaq6tc6gX+ryB4dDSr
+tYn46Lo14D5jH6PtZ8DlGK+jIzM4IE7TEp2iv0CgaTU4ryt/SHPnLxfwZUpl7gSO
+EqkMAy3TlRMpv0oXM2Vh/CsyJzq2P/nY/O3bolsashSPWo9WsQTH4giYVA51ZVDK
+lGksQD+oWpfa3X0=
+-----END CERTIFICATE-----

package/test/fixtures/fastify.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAq19fMMyZT6fcDuhVU6KqnpnlyC7W36qCPtNp3Bc4285Fm+45
+wTwFmkz21AQMTlcQh1yzMPHS1YocdKhuBkDENoS4rU8yGH9FM2/DUrNgkWbYbfya
+qCbXUlSeLzvGYgWqmAl94ICkedZS/7f+em5CeI6hVIvXeN1cSJ94UzyidCdHvdNU
+PK8w6OWNO6UyjSf1XyliFVLM+eba7FO7Tenn4eixATZtTRAqPuTz/x3BFVcSqdO1
+suhb5Z/tXZbdyv9Sd88fwlJoFZOpy3SmBepgio5JOJZCQ7ukTr2YY8etGWbv7CGn
+hZGuJNpwHdSX4JvHbzAdT4Pze96vgDwsoZUNIQIDAQABAoIBAG278ys/R8he1yVg
+lgqo9ZH7P8zwWTz9ZMsv+vAomor9SUtwvuDCO2AzejYGpY6gZ4AV1tQ3dOaxukjk
+9Rbh8AJs+AhZ1t0i2b/3B95z6BkS/vFmt+2GeYhJkMT0BLMNp9AU+9p+5VLy71C5
+k6T3525k/l8x8HZ/YDFMk/LQt8GhvM6A3J3BNElKraiDVO6ZIWgQQ5wiefJkApo1
+BsptHNTx83FbnkEbAahmOR8PfKcRdKY/mZDM2WrlfoU2uwVzPV0/KdYucpsfg2et
+jb5bdJzcvZDuDF4GsPi1asCSC1c403R0XGuPFW9TiBuOPxbfhYK2o60yTggX6H2X
+39WBc/ECgYEA3KNGgXEWzDSLpGciUisP+MzulOdQPawBTUHNykpQklEppnZbNWCX
+07dv6uasnp0pFHG4WlhZJ4+IQBpZH6xAVy9y68PvN7IDYdgMiEiYPSyqQu0rvJGa
+2ZR79SHDokZ8K5oofocC839RzleNRqWqxIwhHt29sxVs73kvml6OQm0CgYEAxtbA
+zbQwf6DXtFwutSgfOLgdXQK72beBdyeTcpUGbkonl5xHSbtz0CFmRpKiPnXfgg4W
+GXlTrqlYF/o048B7dU9+jCKY5DXx1Yzg/EFisEIClad3WXMhNOz1vBYVH6xU3Zq1
+YuYr5dcqiCWDv89e6Y6WJOhwIDZi6RqikD2EJQUCgYEAnWSAJFCnIa8OOo4z5oe/
+kg2m2GQWUphEKXeatQbEaUwquQvPTsmEJUzDMr+xPkkAiAwDpbdGijkSyh/Bmh2H
+nGpFwbf5CzMaxI6ZihK3P1SAdNO5koAQBcytjJW0eCtt4rDK2E+5pDgcBGVia5Y8
+to78BYfLDlhnaIF7mtR/CRUCgYEAvGCuzvOcUv4F/eirk5NMaQb9QqYZZD2XWVTU
+O2T2b7yvX9J+M1t1cESESe4X6cbwlp1T0JSCdGIZhLXWL8Om80/52zfX07VLxP6w
+FCy6G7SeEDxVNRh+6E5qzOO65YP17vDoUacxBZJgyBWKiUkkaW9dzd+sgsgj0yYZ
+xz+QlyUCgYEAxdNWQnz0pR5Rt2dbIedPs7wmiZ7eAe0VjCdhMa52IyJpejdeB6Bn
+Es+3lkHr0Xzty8XlQZcpbswhM8UZRgPVoBvvwQdQbv5yV+LdUu69pLM7InsdZy8u
+opPY/+q9lRdJt4Pbep3pOWYeLP7k5l4vei2vOEMHRjHnoqM5etSb6RU=
+-----END RSA PRIVATE KEY-----

package/test/fixtures/file.txt

@@ -0,0 +1 @@
+file content

package/test/full-get.js

@@ -0,0 +1,45 @@
+'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')
+  t.equal(req.url, '/hello')
+  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}/hello`)
+})
+
+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/full-https-get.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+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
+})
+instance.register(From)
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const target = https.createServer(certs, (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(`https://localhost:${target.address().port}`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.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')
+    })
+  })
+})

package/test/full-post-extended-content-type.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get')
+
+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, 'POST')
+  t.equal(req.headers['content-type'].startsWith('application/json'), true)
+  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))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get.concat({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      body: JSON.stringify({
+        hello: 'world'
+      }),
+      headers: {
+        'content-type': 'application/json;charset=utf-8'
+      }
+    }, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'application/json')
+      t.same(JSON.parse(data.toString()), { something: 'else' })
+    })
+  })
+})