@fastify/reply-from 7.0.0

package/test/full-rewrite-body-to-empty-string.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 instance = Fastify()
+instance.register(From, {
+  http: true
+})
+
+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'], 'application/json')
+  t.equal(req.headers['content-length'], '2')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.same(JSON.parse(data), '')
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ hello: 'fastify' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    body: ''
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      json: true,
+      body: {
+        hello: 'world'
+      }
+    }, (err, res, data) => {
+      t.error(err)
+      t.same(data, { hello: 'fastify' })
+    })
+  })
+})

package/test/full-rewrite-body-to-null.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 instance = Fastify()
+instance.register(From, {
+  http: true
+})
+
+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.notOk('content-type' in req.headers)
+  t.equal(req.headers['content-length'], '0')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.equal(data.length, 0)
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ hello: 'fastify' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    body: null
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      json: true,
+      body: {
+        hello: 'world'
+      }
+    }, (err, res, data) => {
+      t.error(err)
+      t.same(data, { hello: 'fastify' })
+    })
+  })
+})

package/test/full-rewrite-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 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'], 'application/json')
+  t.equal(req.headers['content-length'], '20')
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.same(JSON.parse(data), { something: 'else' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ hello: 'fastify' }))
+  })
+})
+
+instance.post('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    body: {
+      something: 'else'
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'POST',
+      json: true,
+      body: {
+        hello: 'world'
+      }
+    }, (err, res, data) => {
+      t.error(err)
+      t.same(data, { hello: 'fastify' })
+    })
+  })
+})

package/test/get-upstream-http.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()
+const instanceWithoutBase = Fastify()
+instance.register(From, {
+  base: 'http://localhost',
+  http: true,
+  disableCache: true
+})
+
+instanceWithoutBase.register(From, {
+  http: true,
+  disableCache: true
+})
+
+t.plan(13)
+t.teardown(instance.close.bind(instance))
+t.teardown(instanceWithoutBase.close.bind(instanceWithoutBase))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.end(req.headers.host)
+})
+
+instance.get('/test', (request, reply) => {
+  reply.from('/test', {
+    getUpstream: (req, base) => {
+      t.pass('getUpstream called')
+      return `${base}:${target.address().port}`
+    }
+  })
+})
+
+instanceWithoutBase.get('/test2', (request, reply) => {
+  reply.from('/test2', {
+    getUpstream: () => {
+      t.pass('getUpstream called')
+      return `http://localhost:${target.address().port}`
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+  instanceWithoutBase.listen(0, (err) => {
+    t.error(err)
+    target.listen(0, (err) => {
+      t.error(err)
+
+      get(`http://localhost:${instance.server.address().port}/test`, (err, res) => {
+        t.error(err)
+        t.equal(res.statusCode, 200)
+      })
+
+      get(`http://localhost:${instanceWithoutBase.server.address().port}/test2`, (err, res) => {
+        t.error(err)
+        t.equal(res.statusCode, 200)
+      })
+    })
+  })
+})

package/test/get-upstream-undici.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, {
+  disableCache: true
+})
+
+t.plan(7)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.end(req.headers.host)
+})
+
+instance.get('/test', (request, reply) => {
+  reply.from('/test', {
+    getUpstream: () => {
+      t.pass('getUpstream called')
+      return `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(`http://localhost:${instance.server.address().port}/test`, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+    })
+  })
+})

package/test/get-with-body.js

@@ -0,0 +1,55 @@
+'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, '/')
+  t.equal(req.body, undefined)
+  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}`,
+    // Use node core HTTP, Undici requires spec compliance
+    http: {}
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'GET',
+      body: 'this is get body'
+    }, (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/head-with-body.js

@@ -0,0 +1,57 @@
+'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(13)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'HEAD')
+  t.equal(req.url, '/')
+  t.equal(req.headers['content-length'], '16')
+  t.equal(req.body, undefined)
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.head('/', (request, reply) => {
+  t.pass('head received')
+  reply.from()
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen(0, (err) => {
+  t.error(err)
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    // Use node core HTTP, Undici requires spec compliance
+    http: {}
+  })
+
+  instance.listen(0, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'HEAD',
+      body: 'this is get body'
+    }, (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(), '')
+    })
+  })
+})

package/test/host-header.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const nock = require('nock')
+const got = require('got')
+
+test('hostname', async (t) => {
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  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' }
+    })
+
+  instance.get('*', (request, reply) => {
+    reply.from()
+  })
+
+  instance.register(From, {
+    base: 'http://httpbin.org',
+    http: {} // force the use of Node.js core
+  })
+
+  await instance.listen(0)
+
+  const res = await got.get(`http://localhost:${instance.server.address().port}/ip`, {
+    retry: 0
+  })
+  t.equal(res.statusCode, 200)
+  t.equal(res.headers['content-type'], 'application/json')
+  t.equal(typeof JSON.parse(res.body).origin, 'string')
+})
+
+test('hostname and port', async (t) => {
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  nock('http://httpbin.org:8080')
+    .get('/ip')
+    .reply(200, function (uri, requestBody) {
+      t.equal(this.req.headers.host, 'httpbin.org:8080')
+      return { origin: '127.0.0.1' }
+    })
+
+  instance.register(From, {
+    base: 'http://httpbin.org:8080',
+    http: true
+  })
+
+  instance.get('*', (request, reply) => {
+    reply.from()
+  })
+
+  await instance.listen(0)
+
+  const res = await got.get(`http://localhost:${instance.server.address().port}/ip`, {
+    retry: 0
+  })
+  t.equal(res.statusCode, 200)
+  t.equal(res.headers['content-type'], 'application/json')
+  t.equal(typeof JSON.parse(res.body).origin, 'string')
+})

package/test/http-agents.js

@@ -0,0 +1,55 @@
+'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 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}`,
+    http: {
+      agents: {
+        'http:': new http.Agent({}),
+        'https:': new https.Agent({})
+      }
+    }
+  })
+
+  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/http-http2.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http -> http2', 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(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
+  })
+
+  await instance.listen(0)
+
+  try {
+    await got(`http://localhost:${instance.server.address().port}`)
+  } 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()
+})

package/test/http-invalid-target.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http 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'
+  })
+
+  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()
+})