fastify 3.26.0 → 4.0.0-alpha.1

package/test/internals/reply.test.js

@@ -15,6 +15,21 @@ const {
   kReplyIsError,
   kReplySerializerDefault
 } = require('../../lib/symbols')
+const fs = require('fs')
+const path = require('path')
+const warning = require('../../lib/warnings')
+
+const doGet = function (url) {
+  return new Promise((resolve, reject) => {
+    sget({ method: 'GET', url, followRedirects: false }, (err, response, body) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve({ response, body })
+      }
+    })
+  })
+}
 
 test('Once called, Reply should return an object with methods', t => {
   t.plan(13)
@@ -37,7 +52,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.equal(reply.request, request)
 })
 
-test('reply.send will logStream error and destroy the stream', { only: true }, t => {
+test('reply.send will logStream error and destroy the stream', t => {
   t.plan(1)
   let destroyCalled
   const payload = new EventEmitter()
@@ -452,8 +467,6 @@ test('stream with content type should not send application/octet-stream', t => {
   t.plan(4)
 
   const fastify = require('../..')()
-  const fs = require('fs')
-  const path = require('path')
 
   const streamPath = path.join(__dirname, '..', '..', 'package.json')
   const stream = fs.createReadStream(streamPath)
@@ -477,6 +490,32 @@ test('stream with content type should not send application/octet-stream', t => {
   })
 })
 
+test('stream without content type should not send application/octet-stream', t => {
+  t.plan(4)
+
+  const fastify = require('../..')()
+
+  const stream = fs.createReadStream(__filename)
+  const buf = fs.readFileSync(__filename)
+
+  fastify.get('/', function (req, reply) {
+    reply.send(stream)
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.headers['content-type'], undefined)
+      t.same(body, buf)
+    })
+  })
+})
+
 test('stream using reply.raw.writeHead should return customize headers', t => {
   t.plan(6)
 
@@ -1301,6 +1340,34 @@ test('reply.header setting multiple cookies as multiple Set-Cookie headers', t =
   })
 })
 
+test('should emit deprecation warning when trying to modify the reply.sent property', t => {
+  t.plan(4)
+  const fastify = require('../..')()
+
+  const deprecationCode = 'FSTDEP010'
+  warning.emitted.delete(deprecationCode)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.code, deprecationCode)
+  }
+
+  fastify.get('/', (req, reply) => {
+    reply.sent = true
+
+    reply.raw.end()
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.pass()
+
+    process.removeListener('warning', onWarning)
+  })
+})
+
 test('should throw error when passing falsy value to reply.sent', t => {
   t.plan(4)
   const fastify = require('../..')()
@@ -1329,6 +1396,7 @@ test('should throw error when attempting to set reply.sent more than once', t =>
     reply.sent = true
     try {
       reply.sent = true
+      t.fail('must throw')
     } catch (err) {
       t.equal(err.code, 'FST_ERR_REP_ALREADY_SENT')
       t.equal(err.message, 'Reply was already sent.')
@@ -1342,6 +1410,23 @@ test('should throw error when attempting to set reply.sent more than once', t =>
   })
 })
 
+test('should not throw error when attempting to set reply.sent if the underlining request was sent', t => {
+  t.plan(3)
+  const fastify = require('../..')()
+
+  fastify.get('/', function (req, reply) {
+    reply.raw.end()
+    t.doesNotThrow(() => {
+      reply.sent = true
+    })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.pass()
+  })
+})
+
 test('reply.getResponseTime() should return 0 before the timer is initialised on the reply by setting up response listeners', t => {
   t.plan(1)
   const response = { statusCode: 200 }
@@ -1727,3 +1812,160 @@ test('reply.then', t => {
     response.destroy(_err)
   })
 })
+
+test('reply.sent should read from response.writableEnded if it is defined', t => {
+  t.plan(1)
+
+  const reply = new Reply({ writableEnded: true }, {}, {})
+
+  t.equal(reply.sent, true)
+})
+
+test('redirect to an invalid URL should not crash the server', async t => {
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/redirect',
+    handler: (req, reply) => {
+      reply.log.warn = function mockWarn (obj, message) {
+        t.equal(message, 'Invalid character in header content ["location"]')
+      }
+
+      switch (req.query.useCase) {
+        case '1':
+          reply.redirect('/?key=a’b')
+          break
+
+        case '2':
+          reply.redirect(encodeURI('/?key=a’b'))
+          break
+
+        default:
+          reply.redirect('/?key=ab')
+          break
+      }
+    }
+  })
+
+  await fastify.listen(0)
+
+  {
+    const { response, body } = await doGet(`http://localhost:${fastify.server.address().port}/redirect?useCase=1`)
+    t.equal(response.statusCode, 500)
+    t.same(JSON.parse(body), {
+      statusCode: 500,
+      code: 'ERR_INVALID_CHAR',
+      error: 'Internal Server Error',
+      message: 'Invalid character in header content ["location"]'
+    })
+  }
+  {
+    const { response } = await doGet(`http://localhost:${fastify.server.address().port}/redirect?useCase=2`)
+    t.equal(response.statusCode, 302)
+    t.equal(response.headers.location, '/?key=a%E2%80%99b')
+  }
+
+  {
+    const { response } = await doGet(`http://localhost:${fastify.server.address().port}/redirect?useCase=3`)
+    t.equal(response.statusCode, 302)
+    t.equal(response.headers.location, '/?key=ab')
+  }
+
+  await fastify.close()
+})
+
+test('invalid response headers should not crash the server', async t => {
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/bad-headers',
+    handler: (req, reply) => {
+      reply.log.warn = function mockWarn (obj, message) {
+        t.equal(message, 'Invalid character in header content ["smile-encoded"]', 'only the first invalid header is logged')
+      }
+
+      reply.header('foo', '$')
+      reply.header('smile-encoded', '\uD83D\uDE00')
+      reply.header('smile', '😄')
+      reply.header('bar', 'ƒ∂å')
+
+      reply.send({})
+    }
+  })
+
+  await fastify.listen(0)
+
+  const { response, body } = await doGet(`http://localhost:${fastify.server.address().port}/bad-headers`)
+  t.equal(response.statusCode, 500)
+  t.same(JSON.parse(body), {
+    statusCode: 500,
+    code: 'ERR_INVALID_CHAR',
+    error: 'Internal Server Error',
+    message: 'Invalid character in header content ["smile-encoded"]'
+  })
+
+  await fastify.close()
+})
+
+test('invalid response headers when sending back an error', async t => {
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/bad-headers',
+    handler: (req, reply) => {
+      reply.log.warn = function mockWarn (obj, message) {
+        t.equal(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
+      }
+
+      reply.header('smile', '😄')
+      reply.send(new Error('user land error'))
+    }
+  })
+
+  await fastify.listen(0)
+
+  const { response, body } = await doGet(`http://localhost:${fastify.server.address().port}/bad-headers`)
+  t.equal(response.statusCode, 500)
+  t.same(JSON.parse(body), {
+    statusCode: 500,
+    code: 'ERR_INVALID_CHAR',
+    error: 'Internal Server Error',
+    message: 'Invalid character in header content ["smile"]'
+  })
+
+  await fastify.close()
+})
+
+test('invalid response headers and custom error handler', async t => {
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/bad-headers',
+    handler: (req, reply) => {
+      reply.log.warn = function mockWarn (obj, message) {
+        t.equal(message, 'Invalid character in header content ["smile"]', 'only the first invalid header is logged')
+      }
+
+      reply.header('smile', '😄')
+      reply.send(new Error('user land error'))
+    }
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.equal(error.message, 'user land error', 'custom error handler receives the error')
+    reply.status(500).send({ ops: true })
+  })
+
+  await fastify.listen(0)
+
+  const { response, body } = await doGet(`http://localhost:${fastify.server.address().port}/bad-headers`)
+  t.equal(response.statusCode, 500)
+  t.same(JSON.parse(body), {
+    statusCode: 500,
+    code: 'ERR_INVALID_CHAR',
+    error: 'Internal Server Error',
+    message: 'Invalid character in header content ["smile"]'
+  })
+
+  await fastify.close()
+})

package/test/internals/request.test.js

@@ -4,8 +4,9 @@ const { test } = require('tap')
 
 const Request = require('../../lib/request')
 
+process.removeAllListeners('warning')
+
 test('Regular request', t => {
-  t.plan(15)
   const headers = {
     host: 'hostname'
   }
@@ -15,22 +16,27 @@ test('Regular request', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
+  req.connection = req.socket
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
   t.equal(request.id, 'id')
   t.equal(request.params, 'params')
-  t.same(request.raw, req)
+  t.equal(request.raw, req)
   t.equal(request.query, 'query')
   t.equal(request.headers, headers)
   t.equal(request.log, 'log')
   t.equal(request.ip, 'ip')
   t.equal(request.ips, undefined)
   t.equal(request.hostname, 'hostname')
-  t.equal(request.body, null)
+  t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
+  t.equal(request.socket, req.socket)
   t.equal(request.protocol, 'http')
-  t.same(request.socket, req.socket)
+
+  // This will be removed, it's deprecated
+  t.equal(request.connection, req.connection)
+  t.end()
 })
 
 test('Regular request - hostname from authority', t => {
@@ -92,11 +98,11 @@ test('Request with trust proxy', t => {
   t.equal(request.ip, '2.2.2.2')
   t.same(request.ips, ['ip', '1.1.1.1', '2.2.2.2'])
   t.equal(request.hostname, 'example.com')
-  t.equal(request.body, null)
+  t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
+  t.equal(request.socket, req.socket)
   t.equal(request.protocol, 'http')
-  t.same(request.socket, req.socket)
 })
 
 test('Request with trust proxy, encrypted', t => {
@@ -236,7 +242,7 @@ test('Request with undefined socket', t => {
   t.equal(request.ip, undefined)
   t.equal(request.ips, undefined)
   t.equal(request.hostname, 'hostname')
-  t.equal(request.body, null)
+  t.same(request.body, null)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
   t.equal(request.protocol, undefined)

package/test/internals/server.test.js

@@ -0,0 +1,88 @@
+'use strict'
+
+const { test } = require('tap')
+const proxyquire = require('proxyquire')
+
+const Fastify = require('../../fastify')
+const createServer = require('../../lib/server')
+
+const handler = (req, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify({ data: 'Hello World!' }))
+}
+
+test('start listening', async t => {
+  const { server, listen } = createServer({}, handler)
+  await listen.call(Fastify(), 0, 'localhost')
+  server.close()
+  t.pass('server started')
+})
+
+test('DNS errors does not stop the main server on localhost - promise interface', async t => {
+  const createServer = proxyquire('../../lib/server', {
+    dns: {
+      lookup: (hostname, options, cb) => {
+        cb(new Error('DNS error'))
+      }
+    }
+  })
+  const { server, listen } = createServer({}, handler)
+  await listen.call(Fastify(), 0, 'localhost')
+  server.close()
+  t.pass('server started')
+})
+
+test('DNS errors does not stop the main server on localhost - callback interface', t => {
+  t.plan(2)
+  const createServer = proxyquire('../../lib/server', {
+    dns: {
+      lookup: (hostname, options, cb) => {
+        cb(new Error('DNS error'))
+      }
+    }
+  })
+  const { server, listen } = createServer({}, handler)
+  listen.call(Fastify(), 0, 'localhost', (err) => {
+    t.error(err)
+    server.close()
+    t.pass('server started')
+  })
+})
+
+test('DNS returns empty binding', t => {
+  t.plan(2)
+  const createServer = proxyquire('../../lib/server', {
+    dns: {
+      lookup: (hostname, options, cb) => {
+        cb(null, [])
+      }
+    }
+  })
+  const { server, listen } = createServer({}, handler)
+  listen.call(Fastify(), 0, 'localhost', (err) => {
+    t.error(err)
+    server.close()
+    t.pass('server started')
+  })
+})
+
+test('DNS returns more than two binding', t => {
+  t.plan(2)
+  const createServer = proxyquire('../../lib/server', {
+    dns: {
+      lookup: (hostname, options, cb) => {
+        cb(null, [
+          { address: '::1', family: 6 },
+          { address: '127.0.0.1', family: 4 },
+          { address: '0.0.0.0', family: 4 }
+        ])
+      }
+    }
+  })
+  const { server, listen } = createServer({}, handler)
+  listen.call(Fastify(), 0, 'localhost', (err) => {
+    t.error(err)
+    server.close()
+    t.pass('server started')
+  })
+})

package/test/listen.test.js

@@ -4,8 +4,10 @@ const os = require('os')
 const path = require('path')
 const fs = require('fs')
 const { test, before } = require('tap')
-const Fastify = require('..')
 const dns = require('dns').promises
+const dnsCb = require('dns')
+const sget = require('simple-get').concat
+const Fastify = require('..')
 
 let localhost
 let localhostForURL
@@ -393,3 +395,84 @@ test('listen when firstArg is string(pipe) and with backlog', async t => {
   const address = await fastify.listen('\\\\.\\pipe\\testPipe', 511)
   t.equal(address, '\\\\.\\pipe\\testPipe')
 })
+
+test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
+  const lookups = await dns.lookup('localhost', { all: true })
+  t.plan(2 * lookups.length)
+
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+  t.teardown(app.close.bind(app))
+  await app.listen(0, 'localhost')
+
+  for (const lookup of lookups) {
+    await new Promise((resolve, reject) => {
+      sget({
+        method: 'GET',
+        url: getUrl(app, lookup)
+      }, (err, response, body) => {
+        if (err) { return reject(err) }
+        t.equal(response.statusCode, 200)
+        t.same(body.toString(), 'hello localhost')
+        resolve()
+      })
+    })
+  }
+})
+
+test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', t => {
+  dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
+    t.plan(2 + (3 * lookups.length))
+    t.error(err)
+
+    const app = Fastify()
+    app.get('/', async () => 'hello localhost')
+    app.listen(0, 'localhost', (err) => {
+      t.error(err)
+      t.teardown(app.close.bind(app))
+
+      for (const lookup of lookups) {
+        sget({
+          method: 'GET',
+          url: getUrl(app, lookup)
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+          t.same(body.toString(), 'hello localhost')
+        })
+      }
+    })
+  })
+})
+
+test('addresses getter', async t => {
+  t.plan(4)
+  const app = Fastify()
+  app.get('/', async () => 'hello localhost')
+
+  t.same(app.addresses(), [], 'before ready')
+  await app.ready()
+
+  t.same(app.addresses(), [], 'after ready')
+  await app.listen(0, 'localhost')
+  const { port } = app.server.address()
+  const localAddresses = await dns.lookup('localhost', { all: true })
+  for (const address of localAddresses) {
+    address.port = port
+    address.family = 'IPv' + address.family
+  }
+  localAddresses.sort((a, b) => a.address.localeCompare(b.address))
+  t.same(app.addresses().sort((a, b) => a.address.localeCompare(b.address)), localAddresses, 'after listen')
+
+  await app.close()
+  t.same(app.addresses(), [], 'after close')
+})
+
+function getUrl (fastify, lookup) {
+  const { port } = fastify.server.address()
+  if (lookup.family === 6) {
+    return `http://[${lookup.address}]:${port}/`
+  } else {
+    return `http://${lookup.address}:${port}/`
+  }
+}