@fastify/reply-from 7.0.0

package/test/undici-timeout-body.js

@@ -0,0 +1,63 @@
+'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.flushHeaders()
+    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.response.statusCode, 500)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 500,
+      code: 'UND_ERR_BODY_TIMEOUT',
+      error: 'Internal Server Error',
+      message: 'Body Timeout Error'
+    })
+    clock.tick(1000)
+    return
+  }
+
+  t.fail()
+}
+
+main()

package/test/undici-timeout.js

@@ -0,0 +1,61 @@
+'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()
+  }, 1000)
+})
+
+async function main () {
+  await target.listen(0)
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    undici: {
+      headersTimeout: 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.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(1000)
+    return
+  }
+
+  t.fail()
+}
+
+main()

package/test/undici-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, 'keep-alive')
+  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`,
+    undici: 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/undici.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, '/')
+  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')
+})
+
+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}`,
+    undici: 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/unexpected-error.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const got = require('got')
+const proxyquire = require('proxyquire')
+
+// Stub request to throw error 'foo'
+const From = proxyquire('..', {
+  './lib/request': function () {
+    return {
+      request: (opts, callback) => { callback(new Error('foo')) },
+      close: () => {}
+    }
+  }
+})
+
+test('unexpected error renders 500', async (t) => {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  instance.get('/', (request, reply) => {
+    reply.code(201)
+    reply.from()
+  })
+  instance.register(From, {
+    base: 'http://localhost'
+  })
+
+  await instance.listen(0)
+
+  try {
+    await got(`http://localhost:${instance.server.address().port}`)
+  } catch (err) {
+    t.equal(err.response.statusCode, 500)
+    t.match(err.response.headers['content-type'], /application\/json/)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'foo'
+    })
+    return
+  }
+  t.fail()
+})

package/test/unix-http-undici-from.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('fs')
+const querystring = require('querystring')
+const http = require('http')
+const get = require('simple-get').concat
+
+if (process.platform === 'win32') {
+  t.pass()
+  process.exit(0)
+}
+
+const instance = Fastify()
+instance.register(From)
+
+t.plan(4)
+t.teardown(instance.close.bind(instance))
+
+const socketPath = `${__filename}.socket`
+
+try {
+  fs.unlinkSync(socketPath)
+} catch (_) {
+}
+
+const target = http.createServer((req, res) => {
+  t.fail('no response')
+  res.end()
+})
+
+instance.get('/', (request, reply) => {
+  reply.from(`unix+http://${querystring.escape(socketPath)}/hello`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(socketPath, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 500)
+    })
+  })
+})

package/test/unix-http-undici.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('fs')
+const querystring = require('querystring')
+const http = require('http')
+const get = require('simple-get').concat
+
+if (process.platform === 'win32') {
+  t.pass()
+  process.exit(0)
+}
+
+const socketPath = `${__filename}.socket`
+const upstream = `unix+http://${querystring.escape(socketPath)}/`
+
+const instance = Fastify()
+instance.register(From, {
+  base: upstream
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+try {
+  fs.unlinkSync(socketPath)
+} catch (_) {
+}
+
+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('hello')
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(socketPath, (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/unix-http.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const fs = require('fs')
+const querystring = require('querystring')
+const http = require('http')
+const get = require('simple-get').concat
+
+if (process.platform === 'win32') {
+  t.pass()
+  process.exit(0)
+}
+
+const socketPath = `${__filename}.socket`
+const upstream = `unix+http://${querystring.escape(socketPath)}/`
+
+const instance = Fastify()
+instance.register(From, {
+  // Use node core http, unix sockets are not
+  // supported yet.
+  http: true,
+  base: upstream
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+try {
+  fs.unlinkSync(socketPath)
+} catch (_) {
+}
+
+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('hello')
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(socketPath, (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/unix-https-undici.js

@@ -0,0 +1,71 @@
+'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 querystring = require('querystring')
+const path = require('path')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+if (process.platform === 'win32') {
+  t.pass()
+  process.exit(0)
+}
+
+const socketPath = `${__filename}.socket`
+
+try {
+  fs.unlinkSync(socketPath)
+} catch (_) {
+}
+
+const instance = Fastify({
+  https: certs
+})
+instance.register(From, {
+  base: `unix+https://${querystring.escape(socketPath)}`
+})
+
+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, '/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('hello')
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(socketPath, (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/unix-https.js

@@ -0,0 +1,71 @@
+'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 querystring = require('querystring')
+const path = require('path')
+const certs = {
+  key: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.key')),
+  cert: fs.readFileSync(path.join(__dirname, 'fixtures', 'fastify.cert'))
+}
+
+if (process.platform === 'win32') {
+  t.pass()
+  process.exit(0)
+}
+
+const instance = Fastify({
+  https: certs
+})
+instance.register(From, {
+  http: true
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const socketPath = `${__filename}.socket`
+
+try {
+  fs.unlinkSync(socketPath)
+} catch (_) {
+}
+
+const target = https.createServer(certs, (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(`unix+https://${querystring.escape(socketPath)}/hello`)
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen(0, (err) => {
+  t.error(err)
+
+  target.listen(socketPath, (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')
+    })
+  })
+})