node-fastify 5.8.3

package/test/logger/request.test.js

@@ -0,0 +1,292 @@
+'use strict'
+
+const stream = require('node:stream')
+
+const t = require('node:test')
+const split = require('split2')
+
+const Fastify = require('../../fastify')
+const helper = require('../helper')
+const { on } = stream
+const { request } = require('./logger-test-utils')
+const { partialDeepStrictEqual } = require('../toolkit')
+
+t.test('request', { timeout: 60000 }, async (t) => {
+  let localhost
+
+  t.plan(7)
+  t.before(async function () {
+    [localhost] = await helper.getLoopbackHost()
+  })
+
+  await t.test('The request id header key can be customized', async (t) => {
+    const lines = ['incoming request', 'some log message', 'request completed']
+    t.plan(lines.length * 2 + 2)
+    const REQUEST_ID = '42'
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id'
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/', (req, reply) => {
+      t.assert.strictEqual(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'my-custom-request-id': REQUEST_ID } })
+    const body = await response.json()
+    t.assert.strictEqual(body.id, REQUEST_ID)
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.strictEqual(line.reqId, REQUEST_ID)
+      t.assert.strictEqual(line.msg, lines.shift(), 'message is set')
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('The request id header key can be ignored', async (t) => {
+    const lines = ['incoming request', 'some log message', 'request completed']
+    t.plan(lines.length * 2 + 2)
+    const REQUEST_ID = 'ignore-me'
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: false
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/', (req, reply) => {
+      t.assert.strictEqual(req.id, 'req-1')
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+    const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'request-id': REQUEST_ID } })
+    const body = await response.json()
+    t.assert.strictEqual(body.id, 'req-1')
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.strictEqual(line.reqId, 'req-1')
+      t.assert.strictEqual(line.msg, lines.shift(), 'message is set')
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('The request id header key can be customized along with a custom id generator', async (t) => {
+    const REQUEST_ID = '42'
+    const matches = [
+      { reqId: REQUEST_ID, msg: 'incoming request' },
+      { reqId: REQUEST_ID, msg: 'some log message' },
+      { reqId: REQUEST_ID, msg: 'request completed' },
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message 2' },
+      { reqId: 'foo', msg: 'request completed' }
+    ]
+    t.plan(matches.length + 4)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id',
+      genReqId (req) {
+        return 'foo'
+      }
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/one', (req, reply) => {
+      t.assert.strictEqual(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    fastify.get('/two', (req, reply) => {
+      t.assert.strictEqual(req.id, 'foo')
+      req.log.info('some log message 2')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.assert.strictEqual(body.id, REQUEST_ID)
+    }
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/two' })
+      const body = await response.json()
+      t.assert.strictEqual(body.id, 'foo')
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
+      if (matches.length === 0) break
+    }
+  })
+
+  await t.test('The request id header key can be ignored along with a custom id generator', async (t) => {
+    const REQUEST_ID = 'ignore-me'
+    const matches = [
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message' },
+      { reqId: 'foo', msg: 'request completed' },
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message 2' },
+      { reqId: 'foo', msg: 'request completed' }
+    ]
+    t.plan(matches.length + 4)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: false,
+      genReqId (req) {
+        return 'foo'
+      }
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/one', (req, reply) => {
+      t.assert.strictEqual(req.id, 'foo')
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    fastify.get('/two', (req, reply) => {
+      t.assert.strictEqual(req.id, 'foo')
+      req.log.info('some log message 2')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.assert.strictEqual(body.id, 'foo')
+    }
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/two' })
+      const body = await response.json()
+      t.assert.strictEqual(body.id, 'foo')
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
+      if (matches.length === 0) break
+    }
+  })
+
+  await t.test('The request id log label can be changed', async (t) => {
+    const REQUEST_ID = '42'
+    const matches = [
+      { traceId: REQUEST_ID, msg: 'incoming request' },
+      { traceId: REQUEST_ID, msg: 'some log message' },
+      { traceId: REQUEST_ID, msg: 'request completed' }
+    ]
+    t.plan(matches.length + 2)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id',
+      requestIdLogLabel: 'traceId'
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/one', (req, reply) => {
+      t.assert.strictEqual(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.assert.strictEqual(body.id, REQUEST_ID)
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
+      if (matches.length === 0) break
+    }
+  })
+
+  await t.test('should redact the authorization header if so specified', async (t) => {
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        redact: ['req.headers.authorization'],
+        level: 'info',
+        serializers: {
+          req (req) {
+            return {
+              method: req.method,
+              url: req.url,
+              headers: req.headers,
+              hostname: req.hostname,
+              remoteAddress: req.ip,
+              remotePort: req.socket.remotePort
+            }
+          }
+        }
+      }
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/', function (req, reply) {
+      t.assert.deepStrictEqual(req.headers.authorization, 'Bearer abcde')
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    const server = await fastify.listen({ port: 0, host: localhost })
+
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { req: { headers: { authorization: '[Redacted]' } }, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 3)
+
+    await request({
+      method: 'GET',
+      path: '/',
+      host: localhost,
+      port: fastify.server.address().port,
+      headers: {
+        authorization: 'Bearer abcde'
+      }
+    }, function (response, body) {
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body, JSON.stringify({ hello: 'world' }))
+    })
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('should not throw error when serializing custom req', (t) => {
+    t.plan(1)
+
+    const lines = []
+    const dest = new stream.Writable({
+      write: function (chunk, enc, cb) {
+        lines.push(JSON.parse(chunk))
+        cb()
+      }
+    })
+    const fastify = Fastify({ logger: { level: 'info', stream: dest } })
+    t.after(() => fastify.close())
+
+    fastify.log.info({ req: {} })
+
+    t.assert.deepStrictEqual(lines[0].req, {})
+  })
+})

package/test/logger/response.test.js

@@ -0,0 +1,183 @@
+'use strict'
+
+const stream = require('node:stream')
+
+const t = require('node:test')
+const split = require('split2')
+const pino = require('pino')
+
+const Fastify = require('../../fastify')
+const { partialDeepStrictEqual } = require('../toolkit')
+const { on } = stream
+
+t.test('response serialization', { timeout: 60000 }, async (t) => {
+  t.plan(4)
+
+  await t.test('Should use serializers from plugin and route', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const loggerInstance = pino({ level: 'info' }, stream)
+    const fastify = Fastify({
+      loggerInstance
+    })
+    t.after(() => fastify.close())
+
+    fastify.register(context1, {
+      logSerializers: { test: value => 'X' + value }
+    })
+
+    function context1 (instance, opts, done) {
+      instance.get('/', {
+        logSerializers: {
+          test2: value => 'Z' + value
+        }
+      }, (req, reply) => {
+        req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+        reply.send({ hello: 'world' })
+      })
+      done()
+    }
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.assert.deepStrictEqual(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('Should use serializers from instance fastify and route', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const loggerInstance = pino({
+      level: 'info',
+      serializers: {
+        test: value => 'X' + value,
+        test2: value => 'This should be override - ' + value
+      }
+    }, stream)
+    const fastify = Fastify({
+      loggerInstance
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/', {
+      logSerializers: {
+        test2: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.assert.deepStrictEqual(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('Should use serializers inherit from contexts', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'YHello', test3: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const loggerInstance = pino({
+      level: 'info',
+      serializers: {
+        test: value => 'X' + value
+      }
+    }, stream)
+
+    const fastify = Fastify({ loggerInstance })
+    t.after(() => fastify.close())
+
+    fastify.register(context1, { logSerializers: { test2: value => 'Y' + value } })
+
+    function context1 (instance, opts, done) {
+      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' })
+      })
+      done()
+    }
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.assert.deepStrictEqual(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
+  await t.test('should serialize request and response', async (t) => {
+    const lines = [
+      { req: { method: 'GET', url: '/500' }, msg: 'incoming request' },
+      { req: { method: 'GET', url: '/500' }, msg: '500 error' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({ logger: { level: 'info', stream } })
+    t.after(() => fastify.close())
+
+    fastify.get('/500', (req, reply) => {
+      reply.code(500).send(Error('500 error'))
+    })
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/500' })
+      t.assert.strictEqual(response.statusCode, 500)
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+})

package/test/max-requests-per-socket.test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const net = require('node:net')
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('maxRequestsPerSocket', (t, done) => {
+  t.plan(8)
+
+  const fastify = Fastify({ maxRequestsPerSocket: 2 })
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.assert.ifError(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port }, () => {
+      client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+      client.once('data', data => {
+        t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+        t.assert.match(data.toString(), /200 OK/i)
+
+        client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+        client.once('data', data => {
+          t.assert.match(data.toString(), /Connection:\s*close/i)
+          t.assert.match(data.toString(), /200 OK/i)
+
+          client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+          client.once('data', data => {
+            t.assert.match(data.toString(), /Connection:\s*close/i)
+            t.assert.match(data.toString(), /503 Service Unavailable/i)
+            client.end()
+            fastify.close()
+            done()
+          })
+        })
+      })
+    })
+  })
+})
+
+test('maxRequestsPerSocket zero should behave same as null', (t, done) => {
+  t.plan(10)
+
+  const fastify = Fastify({ maxRequestsPerSocket: 0 })
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.assert.ifError(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port }, () => {
+      client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+      client.once('data', data => {
+        t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+        t.assert.match(data.toString(), /200 OK/i)
+
+        client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+        client.once('data', data => {
+          t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+          t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+          t.assert.match(data.toString(), /200 OK/i)
+
+          client.write('GET / HTTP/1.1\r\nHost: fastify.test\r\n\r\n')
+
+          client.once('data', data => {
+            t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+            t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+            t.assert.match(data.toString(), /200 OK/i)
+            client.end()
+            fastify.close()
+            done()
+          })
+        })
+      })
+    })
+  })
+})
+
+test('maxRequestsPerSocket should be set', async (t) => {
+  t.plan(1)
+
+  const initialConfig = Fastify({ maxRequestsPerSocket: 5 }).initialConfig
+  t.assert.deepStrictEqual(initialConfig.maxRequestsPerSocket, 5)
+})
+
+test('maxRequestsPerSocket should 0', async (t) => {
+  t.plan(1)
+
+  const initialConfig = Fastify().initialConfig
+  t.assert.deepStrictEqual(initialConfig.maxRequestsPerSocket, 0)
+})
+
+test('requestTimeout passed to server', t => {
+  t.plan(2)
+
+  const httpServer = Fastify({ maxRequestsPerSocket: 5 }).server
+  t.assert.strictEqual(httpServer.maxRequestsPerSocket, 5)
+
+  const httpsServer = Fastify({ maxRequestsPerSocket: 5, https: true }).server
+  t.assert.strictEqual(httpsServer.maxRequestsPerSocket, 5)
+})

package/test/middleware.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const {
+  FST_ERR_DEC_ALREADY_PRESENT
+} = require('../lib/errors')
+
+test('Should be able to override the default use API', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.decorate('use', () => true)
+  t.assert.strictEqual(fastify.use(), true)
+})
+
+test('Cannot decorate use twice', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.decorate('use', () => true)
+  try {
+    fastify.decorate('use', () => true)
+  } catch (err) {
+    t.assert.ok(err instanceof FST_ERR_DEC_ALREADY_PRESENT)
+  }
+})
+
+test('Encapsulation works', t => {
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    instance.decorate('use', () => true)
+    t.assert.strictEqual(instance.use(), true)
+    done()
+  })
+
+  fastify.ready()
+})

package/test/noop-set.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('node:test')
+const noopSet = require('../lib/noop-set')
+
+test('does a lot of nothing', async t => {
+  const aSet = noopSet()
+  t.assert.ok(aSet, 'object')
+
+  const item = {}
+  aSet.add(item)
+  aSet.add({ another: 'item' })
+  aSet.delete(item)
+  t.assert.strictEqual(aSet.has(item), true)
+
+  for (const i of aSet) {
+    t.assert.fail('should not have any items: ' + i)
+  }
+})