fastify 3.27.4 → 4.0.0-alpha.3

package/test/500s.test.js

@@ -40,7 +40,7 @@ test('custom 500', t => {
 
   fastify.setErrorHandler(function (err, request, reply) {
     t.type(request, 'object')
-    t.type(request, fastify[symbols.kRequest])
+    t.type(request, fastify[symbols.kRequest].parent)
     reply
       .code(500)
       .type('text/plain')
@@ -74,7 +74,7 @@ test('encapsulated 500', t => {
 
     f.setErrorHandler(function (err, request, reply) {
       t.type(request, 'object')
-      t.type(request, f[symbols.kRequest])
+      t.type(request, fastify[symbols.kRequest].parent)
       reply
         .code(500)
         .type('text/plain')
@@ -155,7 +155,7 @@ test('cannot set errorHandler after binding', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     try {

package/test/als.test.js

@@ -31,7 +31,7 @@ app.post('/', function (request, reply) {
   reply.send({ id })
 })
 
-app.listen(3000, function (err, address) {
+app.listen({ port: 0 }, function (err, address) {
   t.error(err)
 
   sget({

package/test/async-await.test.js

@@ -46,7 +46,7 @@ test('async await', t => {
     t.fail()
   }
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -79,12 +79,12 @@ 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))
 
-  server.listen(0, (err) => {
+  server.listen({ port: 0 }, (err) => {
     t.error(err)
     sget({
       method: 'GET',
@@ -104,13 +104,13 @@ 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' }
   })
 
   t.teardown(server.close.bind(server))
 
-  server.listen(0, (err) => {
+  server.listen({ port: 0 }, (err) => {
     t.error(err)
     sget({
       method: 'GET',
@@ -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,12 +160,12 @@ 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))
 
-  server.listen(0, (err) => {
+  server.listen({ port: 0 }, (err) => {
     t.error(err)
     sget({
       method: 'GET',
@@ -185,13 +185,13 @@ 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' }
   })
 
   t.teardown(server.close.bind(server))
 
-  server.listen(0, (err) => {
+  server.listen({ port: 0 }, (err) => {
     t.error(err)
     sget({
       method: 'GET',
@@ -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,48 +383,8 @@ 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,
-        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)
@@ -458,14 +402,13 @@ 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 => {
     t.fail('should not log an error')
   })
 
-  fastify.listen(0, (err) => {
+  fastify.listen({ port: 0 }, (err) => {
     t.error(err)
     fastify.server.unref()
 
@@ -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)
     })
   })
 })
@@ -506,7 +450,7 @@ test('error is not logged because promise was fulfilled with undefined but respo
     t.fail('should not log an error')
   })
 
-  fastify.listen(0, (err) => {
+  fastify.listen({ port: 0 }, (err) => {
     t.error(err)
     fastify.server.unref()
 
@@ -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/bodyLimit.test.js

@@ -28,7 +28,7 @@ test('bodyLimit', t => {
     reply.send({ error: 'handler should not be called' })
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     t.error(err)
     fastify.server.unref()
 

package/test/build-certificate.js

@@ -1,19 +1,18 @@
 'use strict'
 
-const util = require('util')
-const pem = require('pem')
-
-const createCertificate = util.promisify(pem.createCertificate)
+const selfCert = require('self-cert')
 
 async function buildCertificate () {
   // "global" is used in here because "t.context" is only supported by "t.beforeEach" and "t.afterEach"
   // For the test case which execute this code which will be using `t.before` and it can reduce the
   // number of times executing it.
   if (!global.context || !global.context.cert || !global.context.key) {
-    const keys = await createCertificate({ days: 1, selfSigned: true })
+    const certs = selfCert({
+      expires: new Date(Date.now() + 86400000)
+    })
     global.context = {
-      cert: keys.certificate,
-      key: keys.serviceKey
+      cert: certs.certificate,
+      key: certs.privateKey
     }
   }
 }

package/test/case-insensitive.test.js

@@ -17,7 +17,7 @@ test('case insensitive', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     sget({
@@ -45,7 +45,7 @@ test('case insensitive inject', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     fastify.inject({
@@ -74,7 +74,7 @@ test('case insensitive (parametric)', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     sget({
@@ -103,7 +103,7 @@ test('case insensitive (wildcard)', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     sget({

package/test/close-pipelining.test.js

@@ -15,7 +15,7 @@ test('Should return 503 while closing - pipelining', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, async err => {
+  fastify.listen({ port: 0 }, async err => {
     t.error(err)
 
     const instance = new Client('http://localhost:' + fastify.server.address().port, {
@@ -48,7 +48,7 @@ test('Should not return 503 while closing - pipelining - return503OnClosing', t
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     const instance = new Client('http://localhost:' + fastify.server.address().port, {

package/test/close.test.js

@@ -15,7 +15,7 @@ test('close callback', t => {
     done()
   }
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     fastify.close((err) => {
@@ -39,7 +39,7 @@ test('inside register', t => {
     done()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     fastify.close((err) => {
@@ -68,7 +68,7 @@ test('close order', t => {
     done()
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     fastify.close((err) => {
@@ -95,7 +95,7 @@ test('close order - async', async t => {
     t.equal(order.shift(), 2)
   })
 
-  await fastify.listen(0)
+  await fastify.listen({ port: 0 })
   await fastify.close()
 
   t.equal(order.shift(), 3)
@@ -211,7 +211,7 @@ t.test('Current opened connection should continue to work after closing and retu
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     const port = fastify.server.address().port
@@ -248,7 +248,7 @@ t.test('Current opened connection should not accept new incoming connections', t
     }, 250)
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     const instance = new Client('http://localhost:' + fastify.server.address().port)
     instance.request({ path: '/', method: 'GET' }).then(data => {
@@ -264,11 +264,11 @@ test('Cannot be reopened the closed server without listen callback', async t =>
   t.plan(2)
   const fastify = Fastify()
 
-  await fastify.listen(0)
+  await fastify.listen({ port: 0 })
   await fastify.close()
 
   try {
-    await fastify.listen(0)
+    await fastify.listen({ port: 0 })
   } catch (err) {
     t.ok(err)
     t.equal(err.code, 'FST_ERR_REOPENED_CLOSE_SERVER')
@@ -279,11 +279,11 @@ test('Cannot be reopened the closed server has listen callback', async t => {
   t.plan(2)
   const fastify = Fastify()
 
-  await fastify.listen(0)
+  await fastify.listen({ port: 0 })
   await fastify.close()
 
   await new Promise((resolve, reject) => {
-    fastify.listen(0, err => {
+    fastify.listen({ port: 0 }, err => {
       reject(err)
     })
   }).catch(err => {
@@ -305,7 +305,7 @@ test('shutsdown while keep-alive connections are active (non-async)', t => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.listen(0, (err, address) => {
+  fastify.listen({ port: 0 }, (err, address) => {
     t.error(err)
 
     const client = new Client(

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

@@ -119,3 +119,55 @@ test('config with exposeHeadRoutes', t => {
     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({
+    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' })
+  })
+})

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({ port: 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

@@ -24,7 +24,7 @@ test('contentTypeParser should add a custom async parser', t => {
     return res
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
 
     t.teardown(() => fastify.close())
@@ -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)
-      })
-    })
-  })
-})