fastify 3.26.0 → 4.0.0-alpha.1

package/test/async-await.test.js

@@ -79,7 +79,7 @@ test('ignore the result of the promise if reply.send is called beforehand (undef
   const payload = { hello: 'world' }
 
   server.get('/', async function awaitMyFunc (req, reply) {
-    reply.send(payload)
+    await reply.send(payload)
   })
 
   t.teardown(server.close.bind(server))
@@ -104,7 +104,7 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
   const payload = { hello: 'world2' }
 
   server.get('/', async function awaitMyFunc (req, reply) {
-    reply.send(payload)
+    await reply.send(payload)
     return { hello: 'world' }
   })
 
@@ -139,7 +139,7 @@ test('server logs an error if reply.send is called and a value is returned via a
   })
 
   fastify.get('/', async (req, reply) => {
-    reply.send({ hello: 'world' })
+    await reply.send({ hello: 'world' })
     return { hello: 'world2' }
   })
 
@@ -160,7 +160,7 @@ test('ignore the result of the promise if reply.send is called beforehand (undef
   const payload = { hello: 'world' }
 
   server.get('/', async function awaitMyFunc (req, reply) {
-    reply.send(payload)
+    await reply.send(payload)
   })
 
   t.teardown(server.close.bind(server))
@@ -185,7 +185,7 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
   const payload = { hello: 'world2' }
 
   server.get('/', async function awaitMyFunc (req, reply) {
-    reply.send(payload)
+    await reply.send(payload)
     return { hello: 'world' }
   })
 
@@ -279,11 +279,13 @@ test('support reply decorators with await', t => {
     setImmediate(() => {
       this.send({ hello: 'world' })
     })
+
+    return this
   })
 
   fastify.get('/', async (req, reply) => {
     await sleep(1)
-    reply.wow()
+    await reply.wow()
   })
 
   fastify.inject({
@@ -296,24 +298,6 @@ test('support reply decorators with await', t => {
   })
 })
 
-test('support 204', t => {
-  t.plan(2)
-
-  const fastify = Fastify()
-
-  fastify.get('/', async (req, reply) => {
-    reply.code(204)
-  })
-
-  fastify.inject({
-    method: 'GET',
-    url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 204)
-  })
-})
-
 test('inject async await', async t => {
   t.plan(1)
 
@@ -399,55 +383,15 @@ test('does not call reply.send() twice if 204 response equal already sent', t =>
   })
 })
 
-test('error is logged because promise was fulfilled with undefined', t => {
-  t.plan(3)
-
-  let fastify = null
-  const stream = split(JSON.parse)
-  try {
-    fastify = Fastify({
-      logger: {
-        stream: stream,
-        level: 'error'
-      }
-    })
-  } catch (e) {
-    t.fail()
-  }
-
-  t.teardown(fastify.close.bind(fastify))
-
-  fastify.get('/', async (req, reply) => {
-    reply.code(200)
-  })
-
-  stream.once('data', line => {
-    t.equal(line.msg, 'Promise may not be fulfilled with \'undefined\' when statusCode is not 204')
-  })
-
-  fastify.listen(0, (err) => {
-    t.error(err)
-    fastify.server.unref()
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/',
-      timeout: 500
-    }, (err, res, body) => {
-      t.equal(err.message, 'Request timed out')
-    })
-  })
-})
-
-test('error is not logged because promise was fulfilled with undefined but statusCode 204 was set', t => {
-  t.plan(3)
+test('promise was fulfilled with undefined', t => {
+  t.plan(4)
 
   let fastify = null
   const stream = split(JSON.parse)
   try {
     fastify = Fastify({
       logger: {
-        stream: stream,
+        stream,
         level: 'error'
       }
     })
@@ -458,7 +402,6 @@ test('error is not logged because promise was fulfilled with undefined but statu
   t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/', async (req, reply) => {
-    reply.code(204)
   })
 
   stream.once('data', line => {
@@ -474,7 +417,8 @@ test('error is not logged because promise was fulfilled with undefined but statu
       url: 'http://localhost:' + fastify.server.address().port + '/'
     }, (err, res, body) => {
       t.error(err)
-      t.equal(res.statusCode, 204)
+      t.equal(res.body, undefined)
+      t.equal(res.statusCode, 200)
     })
   })
 })
@@ -488,7 +432,7 @@ test('error is not logged because promise was fulfilled with undefined but respo
   try {
     fastify = Fastify({
       logger: {
-        stream: stream,
+        stream,
         level: 'error'
       }
     })
@@ -601,7 +545,7 @@ test('customErrorHandler support without throwing', t => {
 
   fastify.setErrorHandler(async (err, req, reply) => {
     t.equal(err.message, 'ouch')
-    reply.code(401).send('kaboom')
+    await reply.code(401).send('kaboom')
     reply.send = t.fail.bind(t, 'should not be called')
   })
 

package/test/close.test.js

@@ -215,7 +215,7 @@ t.test('Current opened connection should continue to work after closing and retu
     t.error(err)
 
     const port = fastify.server.address().port
-    const client = net.createConnection({ port: port }, () => {
+    const client = net.createConnection({ port }, () => {
       client.write('GET / HTTP/1.1\r\n\r\n')
 
       client.once('data', data => {
@@ -291,3 +291,41 @@ test('Cannot be reopened the closed server has listen callback', async t => {
     t.ok(err)
   })
 })
+
+test('shutsdown while keep-alive connections are active (non-async)', t => {
+  t.plan(5)
+
+  const timeoutTime = 2 * 60 * 1000
+  const fastify = Fastify({ forceCloseConnections: true })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen(0, (err, address) => {
+    t.error(err)
+
+    const client = new Client(
+      'http://localhost:' + fastify.server.address().port,
+      { keepAliveTimeout: 1 * 60 * 1000 }
+    )
+    client.request({ path: '/', method: 'GET' }, (err, response) => {
+      t.error(err)
+      t.equal(client.closed, false)
+
+      fastify.close((err) => {
+        t.error(err)
+
+        // Due to the nature of the way we reap these keep-alive connections,
+        // there hasn't been enough time before the server fully closed in order
+        // for the client to have seen the socket get destroyed. The mere fact
+        // that we have reached this callback is enough indication that the
+        // feature being tested works as designed.
+        t.equal(client.closed, false)
+      })
+    })
+  })
+})

package/test/content-parser.test.js

@@ -187,6 +187,38 @@ test('add', t => {
   t.end()
 })
 
+test('non-Error thrown from content parser is properly handled', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  const throwable = 'test'
+  const payload = 'error'
+
+  fastify.addContentTypeParser('text/test', (request, payload, done) => {
+    done(throwable)
+  })
+
+  fastify.post('/', (req, reply) => {
+  })
+
+  fastify.setErrorHandler((err, req, res) => {
+    t.equal(err, throwable)
+
+    res.send(payload)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: { 'Content-Type': 'text/test' },
+    body: 'some text'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, payload)
+  })
+})
+
 test('remove', t => {
   test('should remove default parser', t => {
     t.plan(2)

package/test/context-config.test.js

@@ -29,7 +29,7 @@ test('config', t => {
     method: 'GET',
     url: '/route',
     schema: schema.schema,
-    handler: handler,
+    handler,
     config: Object.assign({}, schema.config)
   })
 
@@ -37,7 +37,7 @@ test('config', t => {
     method: 'GET',
     url: '/no-config',
     schema: schema.schema,
-    handler: handler
+    handler
   })
 
   fastify.inject({
@@ -81,7 +81,7 @@ test('config with exposeHeadRoutes', t => {
     method: 'GET',
     url: '/route',
     schema: schema.schema,
-    handler: handler,
+    handler,
     config: Object.assign({}, schema.config)
   })
 
@@ -89,7 +89,59 @@ test('config with exposeHeadRoutes', t => {
     method: 'GET',
     url: '/no-config',
     schema: schema.schema,
-    handler: handler
+    handler
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/get'
+  }, (err, response) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(JSON.parse(response.payload), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/route'
+  }, (err, response) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(JSON.parse(response.payload), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/no-config'
+  }, (err, response) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(JSON.parse(response.payload), { url: '/no-config', method: 'GET' })
+  })
+})
+
+test('config without exposeHeadRoutes', t => {
+  t.plan(9)
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  fastify.get('/get', {
+    schema: schema.schema,
+    config: Object.assign({}, schema.config)
+  }, handler)
+
+  fastify.route({
+    method: 'GET',
+    url: '/route',
+    schema: schema.schema,
+    handler,
+    config: Object.assign({}, schema.config)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/no-config',
+    schema: schema.schema,
+    handler
   })
 
   fastify.inject({

package/test/custom-http-server.test.js

@@ -5,12 +5,15 @@ const test = t.test
 const Fastify = require('..')
 const http = require('http')
 const sget = require('simple-get').concat
+const dns = require('dns').promises
 
-test('Should support a custom http server', t => {
-  t.plan(6)
+test('Should support a custom http server', async t => {
+  const localAddresses = await dns.lookup('localhost', { all: true })
+
+  t.plan(localAddresses.length + 3)
 
   const serverFactory = (handler, opts) => {
-    t.ok(opts.serverFactory)
+    t.ok(opts.serverFactory, 'it is called twice for every HOST interface')
 
     const server = http.createServer((req, res) => {
       req.custom = true
@@ -29,16 +32,20 @@ test('Should support a custom http server', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
-    t.error(err)
+  await fastify.listen(0)
 
+  await new Promise((resolve, reject) => {
     sget({
       method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port
+      url: 'http://localhost:' + fastify.server.address().port,
+      rejectUnauthorized: false
     }, (err, response, body) => {
-      t.error(err)
+      if (err) {
+        return reject(err)
+      }
       t.equal(response.statusCode, 200)
       t.same(JSON.parse(body), { hello: 'world' })
+      resolve()
     })
   })
 })

package/test/custom-parser-async.test.js

@@ -64,68 +64,3 @@ test('contentTypeParser should add a custom async parser', t => {
     })
   })
 })
-
-test('contentTypeParser should add a custom async parser - deprecated syntax', t => {
-  t.plan(5)
-  const fastify = Fastify()
-
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.equal(warning.name, 'FastifyDeprecation')
-    t.equal(warning.code, 'FSTDEP003')
-  }
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.options('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser('application/jsoff', async function (req) {
-    const res = await new Promise((resolve, reject) => resolve(req))
-    return res
-  })
-
-  fastify.listen(0, err => {
-    t.error(err)
-
-    t.teardown(() => fastify.close())
-
-    t.test('in POST', t => {
-      t.plan(3)
-
-      sget({
-        method: 'POST',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'application/jsoff'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
-      })
-    })
-
-    t.test('in OPTIONS', t => {
-      t.plan(3)
-
-      sget({
-        method: 'OPTIONS',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'application/jsoff'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
-        process.removeListener('warning', onWarning)
-      })
-    })
-  })
-})