fastify 3.27.3 → 4.0.0-alpha.2

package/test/internals/reply.test.js

@@ -5,9 +5,8 @@ const test = t.test
 const sget = require('simple-get').concat
 const http = require('http')
 const NotFound = require('http-errors').NotFound
-const EventEmitter = require('events').EventEmitter
 const Reply = require('../../lib/reply')
-const { Writable } = require('stream')
+const { Readable, Writable } = require('stream')
 const {
   kReplyErrorHandlerCalled,
   kReplyHeaders,
@@ -15,6 +14,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,33 +51,33 @@ 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()
+  const payload = new Readable({
+    read () {},
+    destroy (err, cb) {
+      destroyCalled = true
+      cb(err)
+    }
+  })
 
-  const response = {
+  const response = new Writable()
+  Object.assign(response, {
     setHeader: () => {},
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
-    end: () => {},
-    headersSent: true,
-    destroy: () => (destroyCalled = true),
-    on: () => {}
-  }
+    headersSent: true
+  })
 
   const log = {
     warn: () => {}
   }
 
-  Object.assign(payload, {
-    pipe: () => {},
-    destroy: () => {}
-  })
   const reply = new Reply(response, { context: { onSend: null } }, log)
   reply.send(payload)
-  payload.emit('error', new Error('stream error'))
+  payload.destroy(new Error('stream error'))
 
   t.equal(destroyCalled, true, 'Error not logged and not streamed')
 })
@@ -248,7 +262,7 @@ test('within an instance', t => {
     done()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -408,7 +422,7 @@ test('buffer without content type should send a application/octet-stream and raw
     reply.send(Buffer.alloc(1024))
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -433,7 +447,7 @@ test('buffer with content type should not send application/octet-stream', t => {
     reply.send(Buffer.alloc(1024))
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -452,8 +466,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)
@@ -463,7 +475,7 @@ test('stream with content type should not send application/octet-stream', t => {
     reply.header('Content-Type', 'text/plain').send(stream)
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -477,6 +489,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({ port: 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)
 
@@ -498,7 +536,7 @@ test('stream using reply.raw.writeHead should return customize headers', t => {
     reply.send(stream)
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -522,7 +560,7 @@ test('plain string without content type should send a text/plain', t => {
     reply.send('hello world!')
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -546,7 +584,7 @@ test('plain string with content type should be sent unmodified', t => {
     reply.type('text/css').send('hello world!')
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -573,7 +611,7 @@ test('plain string with content type and custom serializer should be serialized'
       .send('hello world!')
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -597,7 +635,7 @@ test('plain string with content type application/json should NOT be serialized a
     reply.type('application/json').send('{"key": "hello world!"}')
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -650,7 +688,7 @@ test('plain string with custom json content type should NOT be serialized as jso
     })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -676,7 +714,7 @@ test('non-string with content type application/json SHOULD be serialized as json
     reply.type('application/json').send({ key: 'hello world!' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -725,7 +763,7 @@ test('non-string with custom json content type SHOULD be serialized as json', t
     })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -790,7 +828,7 @@ test('undefined payload should be sent as-is', t => {
     reply.code(204).send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -835,7 +873,7 @@ test('for HEAD method, no body should be sent but content-length should be', t =
     reply.code(200).send(null)
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -882,7 +920,7 @@ test('reply.send(new NotFound()) should not invoke the 404 handler', t => {
     done()
   }, { prefix: '/prefixed' })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     fastify.server.unref()
@@ -929,7 +967,7 @@ test('reply can set multiple instances of same header', t => {
       .send({})
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -956,7 +994,7 @@ test('reply.hasHeader returns correct values', t => {
     reply.send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -985,7 +1023,7 @@ test('reply.getHeader returns correct values', t => {
     reply.send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -1055,7 +1093,7 @@ test('reply.removeHeader can remove the value', t => {
     reply.send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -1082,7 +1120,7 @@ test('reply.header can reset the value', t => {
     reply.send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -1111,7 +1149,7 @@ test('reply.hasHeader computes raw and fastify headers', t => {
     reply.send()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
     sget({
@@ -1280,7 +1318,7 @@ test('reply.header setting multiple cookies as multiple Set-Cookie headers', t =
       .send({})
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -1301,6 +1339,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 +1395,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 +1409,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 }
@@ -1607,7 +1691,7 @@ test('cannot set the replySerializer when the server is running', t => {
   const fastify = require('../..')()
   t.teardown(fastify.close.bind(fastify))
 
-  fastify.listen(err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     try {
       fastify.setReplySerializer(() => {})
@@ -1727,3 +1811,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({ port: 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({ port: 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({ port: 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({ port: 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(), { port: 0, host: '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(), { port: 0, host: '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(), { port: 0, host: '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(), { port: 0, host: '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(), { port: 0, host: 'localhost' }, (err) => {
+    t.error(err)
+    server.close()
+    t.pass('server started')
+  })
+})