fastify 2.7.1 → 2.11.0

package/test/logger.test.js

@@ -567,6 +567,40 @@ test('Should set a custom logLevel for a plugin', t => {
   })
 })
 
+test('Should set a custom logSerializers for a plugin', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+  })
+
+  const logger = pino({ level: 'error' }, splitStream)
+
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/plugin', (req, reply) => {
+      req.log.info({ test: 'Hello' }) // we should see this log
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logLevel: 'info', logSerializers: { test: value => 'X' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/plugin'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
 test('Should set a custom logLevel for every plugin', t => {
   const lines = ['incoming request', 'request completed', 'info', 'debug']
   t.plan(18)
@@ -634,6 +668,281 @@ test('Should set a custom logLevel for every plugin', t => {
   })
 })
 
+test('Should set a custom logSerializers for every plugin', t => {
+  const lines = ['Hello', 'XHello', 'ZHello']
+  t.plan(9)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, lines.shift())
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.get('/', (req, reply) => {
+    req.log.warn({ test: 'Hello' })
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/test1', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/test2', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'Z' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/test1'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/test2'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should override serializers from route', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test: value => 'Z' + value // should override
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should override serializers from plugin', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.register(context1, {
+      logSerializers: {
+        test: value => 'Z' + value // should override
+      }
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers from plugin and route', t => {
+  t.plan(4)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+    if (line.test2) {
+      t.is(line.test2, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(context1, {
+    logSerializers: { test: value => 'X' + value }
+  })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test2: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers from instance fastify and route', t => {
+  t.plan(4)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+    if (line.test2) {
+      t.is(line.test2, 'ZHello')
+    }
+  })
+
+  const logger = pino({
+    level: 'info',
+    serializers: {
+      test: value => 'X' + value,
+      test2: value => 'This should be override - ' + value
+    }
+  }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.get('/', {
+    logSerializers: {
+      test2: value => 'Z' + value
+    }
+  }, (req, reply) => {
+    req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers inherit from contexts', t => {
+  t.plan(5)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test && line.test2 && line.test3) {
+      t.is(line.test, 'XHello')
+      t.is(line.test2, 'YHello')
+      t.is(line.test3, 'ZHello')
+    }
+  })
+
+  const logger = pino({
+    level: 'info',
+    serializers: {
+      test: value => 'X' + value
+    }
+  }, splitStream)
+
+  const fastify = Fastify({ logger })
+  fastify.register(context1, { logSerializers: { test2: value => 'Y' + value } })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test3: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello', test3: 'Hello' }) // { test: 'XHello', test2: 'YHello', test3: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
 test('Should increase the log level for a specific plugin', t => {
   t.plan(4)
 
@@ -783,7 +1092,11 @@ test('Should set a custom log level for a specific route', t => {
 test('The default 404 handler logs the incoming request', t => {
   t.plan(5)
 
-  const expectedMessages = ['incoming request', 'Not Found', 'request completed']
+  const expectedMessages = [
+    'incoming request',
+    'Route GET:/not-found not found',
+    'request completed'
+  ]
 
   const splitStream = split(JSON.parse)
   splitStream.on('data', (line) => {

package/test/plugin.test.js

@@ -18,6 +18,29 @@ test('require a plugin', t => {
   })
 })
 
+test('plugin metadata - ignore prefix', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  plugin[Symbol.for('skip-override')] = true
+  fastify.register(plugin, { prefix: 'foo' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, function (err, res) {
+    t.error(err)
+    t.equals(res.payload, 'hello')
+  })
+
+  function plugin (instance, opts, next) {
+    instance.get('/', function (request, reply) {
+      reply.send('hello')
+    })
+    next()
+  }
+})
+
 test('fastify.register with fastify-plugin should not incapsulate his code', t => {
   t.plan(10)
   const fastify = Fastify()
@@ -312,6 +335,154 @@ test('check dependencies - should throw', t => {
   })
 })
 
+test('set the plugin name based on the plugin displayName symbol', t => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.register(fp((fastify, opts, next) => {
+    t.strictEqual(fastify.pluginName, 'plugin-A')
+    fastify.register(fp((fastify, opts, next) => {
+      t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB')
+      next()
+    }, { name: 'plugin-AB' }))
+    fastify.register(fp((fastify, opts, next) => {
+      t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
+      next()
+    }, { name: 'plugin-AC' }))
+    next()
+  }, { name: 'plugin-A' }))
+
+  fastify.register(fp((fastify, opts, next) => {
+    t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
+    next()
+  }, { name: 'plugin-B' }))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
+test('plugin name will change when using no encapsulation', t => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.register(fp((fastify, opts, next) => {
+    // store it in a different variable will hold the correct name
+    const pluginName = fastify.pluginName
+    fastify.register(fp((fastify, opts, next) => {
+      t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB')
+      next()
+    }, { name: 'plugin-AB' }))
+    fastify.register(fp((fastify, opts, next) => {
+      t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
+      next()
+    }, { name: 'plugin-AC' }))
+    setImmediate(() => {
+      // normally we would expect the name plugin-A
+      // but we operate on the same instance in each plugin
+      t.strictEqual(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
+      t.strictEqual(pluginName, 'plugin-A')
+    })
+    next()
+  }, { name: 'plugin-A' }))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
+test('plugin name is undefined when accessing in no plugin context', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  t.strictEqual(fastify.pluginName, undefined)
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
+test('set the plugin name based on the plugin function name', t => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  fastify.register(function myPluginA (fastify, opts, next) {
+    t.strictEqual(fastify.pluginName, 'myPluginA')
+    fastify.register(function myPluginAB (fastify, opts, next) {
+      t.strictEqual(fastify.pluginName, 'myPluginAB')
+      next()
+    })
+    setImmediate(() => {
+      // exact name due to encapsulation
+      t.strictEqual(fastify.pluginName, 'myPluginA')
+    })
+    next()
+  })
+
+  fastify.register(function myPluginB (fastify, opts, next) {
+    t.strictEqual(fastify.pluginName, 'myPluginB')
+    next()
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
+test('approximate a plugin name when no meta data is available', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.register((fastify, opts, next) => {
+    // A
+    t.is(fastify.pluginName.startsWith('(fastify, opts, next)'), true)
+    t.is(fastify.pluginName.includes('// A'), true)
+    fastify.register((fastify, opts, next) => {
+      // B
+      t.is(fastify.pluginName.startsWith('(fastify, opts, next)'), true)
+      t.is(fastify.pluginName.includes('// B'), true)
+      next()
+    })
+    setImmediate(() => {
+      t.is(fastify.pluginName.startsWith('(fastify, opts, next)'), true)
+      t.is(fastify.pluginName.includes('// A'), true)
+    })
+    next()
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
+test('approximate a plugin name also when fastify-plugin has no meta data', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register(fp((fastify, opts, next) => {
+    t.is(fastify.pluginName, 'plugin.test')
+    fastify.register(fp(function B (fastify, opts, next) {
+      // function has name
+      t.is(fastify.pluginName, 'plugin.test -> B')
+      next()
+    }))
+    setImmediate(() => {
+      t.is(fastify.pluginName, 'plugin.test -> B')
+    })
+    next()
+  }))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.close()
+  })
+})
+
 test('plugin incapsulation', t => {
   t.plan(10)
   const fastify = Fastify()

package/test/promises.test.js

@@ -42,6 +42,24 @@ fastify.get('/double', function (req, reply) {
   return Promise.resolve({ hello: '42' })
 })
 
+fastify.get('/thenable', opts, function (req, reply) {
+  setImmediate(function () {
+    reply.send({ hello: 'world' })
+  })
+  return reply
+})
+
+fastify.get('/thenable-error', opts, function (req, reply) {
+  setImmediate(function () {
+    reply.send(new Error('kaboom'))
+  })
+  return reply
+})
+
+fastify.get('/return-reply', opts, function (req, reply) {
+  return reply.send({ hello: 'world' })
+})
+
 fastify.listen(0, err => {
   t.error(err)
   fastify.server.unref()
@@ -82,4 +100,41 @@ fastify.listen(0, err => {
       t.deepEqual(JSON.parse(body), { hello: '42' })
     })
   })
+
+  test('thenable', t => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/thenable'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+      t.strictEqual(response.headers['content-length'], '' + body.length)
+      t.deepEqual(JSON.parse(body), { hello: 'world' })
+    })
+  })
+
+  test('thenable (error)', t => {
+    t.plan(2)
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/thenable-error'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 500)
+    })
+  })
+
+  test('return-reply', t => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/return-reply'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+      t.strictEqual(response.headers['content-length'], '' + body.length)
+      t.deepEqual(JSON.parse(body), { hello: 'world' })
+    })
+  })
 })

package/test/proto-poisoning.test.js

@@ -81,3 +81,79 @@ test('proto-poisoning ignore', t => {
     })
   })
 })
+
+test('constructor-poisoning ignore (default in v2)', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    reply.send('ok')
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+    })
+  })
+})
+
+test('constructor-poisoning error', t => {
+  t.plan(3)
+
+  const fastify = Fastify({ onConstructorPoisoning: 'error' })
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    t.fail('handler should not be called')
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+    })
+  })
+})
+
+test('constructor-poisoning remove', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ onProtoPoisoning: 'remove' })
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    t.equal(undefined, Object.assign({}, request.body).foo)
+    reply.send({ ok: true })
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+    })
+  })
+})