Aktueller Stand

backend/node_modules/fastify/test/diagnostics-channel/404.test.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', async t => {
+  t.plan(9)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      reply.callNotFound()
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
+  })
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 404)
+})

backend/node_modules/fastify/test/diagnostics-channel/async-delay-request.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const diagnostics = require('node:diagnostics_channel')
+const { test } = require('node:test')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel async events fire in expected order', async t => {
+  t.plan(19)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    t.assert.strictEqual(msg.async, true)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:asyncStart', (msg) => {
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:asyncEnd', (msg) => {
+    t.assert.strictEqual(callOrder++, 3)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: async function (req, reply) {
+      setImmediate(() => reply.send({ hello: 'world' }))
+      return reply
+    }
+  })
+
+  t.after(() => { fastify.close() })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer + '/')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+})

backend/node_modules/fastify/test/diagnostics-channel/async-request.test.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel async events fire in expected order', async t => {
+  t.plan(18)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:asyncStart', (msg) => {
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:asyncEnd', (msg) => {
+    t.assert.strictEqual(callOrder++, 3)
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: async function (req, reply) {
+      return { hello: 'world' }
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+})

backend/node_modules/fastify/test/diagnostics-channel/error-before-handler.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const diagnostics = require('node:diagnostics_channel')
+const { test } = require('node:test')
+require('../../lib/hooks').onSendHookRunner = function Stub () {}
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+const symbols = require('../../lib/symbols.js')
+const { preHandlerCallback } = require('../../lib/handle-request')[Symbol.for('internals')]
+
+test('diagnostics channel handles an error before calling context handler', t => {
+  t.plan(3)
+  let callOrder = 0
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg.error.message, 'oh no')
+  })
+
+  const error = new Error('oh no')
+  const request = new Request()
+  const reply = new Reply({}, request)
+  request[symbols.kRouteContext] = {
+    config: {
+      url: '/foo',
+      method: 'GET'
+    }
+  }
+
+  preHandlerCallback(error, request, reply)
+})

backend/node_modules/fastify/test/diagnostics-channel/error-request.test.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel events report on errors', async t => {
+  t.plan(14)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.ok(msg.error instanceof Error)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg.error.message, 'borked')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      throw new Error('borked')
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
+  })
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
+})

backend/node_modules/fastify/test/diagnostics-channel/error-status.test.js

@@ -0,0 +1,123 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../..')
+const statusCodes = require('node:http').STATUS_CODES
+const diagnostics = require('node:diagnostics_channel')
+
+test('diagnostics channel error event should report correct status code', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let diagnosticsStatusCode
+
+  const channel = diagnostics.channel('tracing:fastify.request.handler:error')
+  const handler = (msg) => {
+    diagnosticsStatusCode = msg.reply.statusCode
+  }
+  channel.subscribe(handler)
+  t.after(() => channel.unsubscribe(handler))
+
+  fastify.get('/', async () => {
+    const err = new Error('test error')
+    err.statusCode = 503
+    throw err
+  })
+
+  const res = await fastify.inject('/')
+
+  t.assert.strictEqual(res.statusCode, 503)
+  t.assert.strictEqual(diagnosticsStatusCode, 503, 'diagnostics channel should report correct status code')
+  t.assert.strictEqual(diagnosticsStatusCode, res.statusCode, 'diagnostics status should match response status')
+})
+
+test('diagnostics channel error event should report 500 for errors without status', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let diagnosticsStatusCode
+
+  const channel = diagnostics.channel('tracing:fastify.request.handler:error')
+  const handler = (msg) => {
+    diagnosticsStatusCode = msg.reply.statusCode
+  }
+  channel.subscribe(handler)
+  t.after(() => channel.unsubscribe(handler))
+
+  fastify.get('/', async () => {
+    throw new Error('plain error without status')
+  })
+
+  const res = await fastify.inject('/')
+
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.strictEqual(diagnosticsStatusCode, 500, 'diagnostics channel should report 500 for plain errors')
+  t.assert.strictEqual(diagnosticsStatusCode, res.statusCode, 'diagnostics status should match response status')
+})
+
+test('diagnostics channel error event should report correct status with custom error handler', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let diagnosticsStatusCode
+
+  const channel = diagnostics.channel('tracing:fastify.request.handler:error')
+  const handler = (msg) => {
+    diagnosticsStatusCode = msg.reply.statusCode
+  }
+  channel.subscribe(handler)
+  t.after(() => channel.unsubscribe(handler))
+
+  fastify.setErrorHandler((error, request, reply) => {
+    reply.status(503).send({ error: error.message })
+  })
+
+  fastify.get('/', async () => {
+    throw new Error('handler error')
+  })
+
+  const res = await fastify.inject('/')
+
+  // Note: The diagnostics channel fires before the custom error handler runs,
+  // so it reports 500 (default) rather than 503 (set by custom handler).
+  // This is expected behavior - the error channel reports the initial error state.
+  t.assert.strictEqual(res.statusCode, 503)
+  t.assert.strictEqual(diagnosticsStatusCode, 500, 'diagnostics channel reports status before custom handler')
+  t.assert.notStrictEqual(diagnosticsStatusCode, res.statusCode, 'custom handler can change status after diagnostics')
+})
+
+test('Error.status property support', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  const err = new Error('winter is coming')
+  err.status = 418
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.strictEqual(msg.error.message, 'winter is coming')
+  })
+
+  fastify.get('/', () => {
+    return Promise.reject(err)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 418)
+    t.assert.deepStrictEqual(
+      {
+        error: statusCodes['418'],
+        message: err.message,
+        statusCode: 418
+      },
+      JSON.parse(res.payload)
+    )
+    done()
+  })
+})

backend/node_modules/fastify/test/diagnostics-channel/init.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { test } = require('node:test')
+const proxyquire = require('proxyquire')
+
+test('diagnostics_channel when present and subscribers', t => {
+  t.plan(3)
+
+  let fastifyInHook
+
+  const diagnostics = {
+    channel (name) {
+      t.assert.strictEqual(name, 'fastify.initialization')
+      return {
+        hasSubscribers: true,
+        publish (event) {
+          t.assert.ok(event.fastify)
+          fastifyInHook = event.fastify
+        }
+      }
+    },
+    '@noCallThru': true
+  }
+
+  const fastify = proxyquire('../../fastify', {
+    'node:diagnostics_channel': diagnostics
+  })()
+  t.assert.strictEqual(fastifyInHook, fastify)
+})
+
+test('diagnostics_channel when present and no subscribers', t => {
+  t.plan(1)
+
+  const diagnostics = {
+    channel (name) {
+      t.assert.strictEqual(name, 'fastify.initialization')
+      return {
+        hasSubscribers: false,
+        publish () {
+          t.assert.fail('publish should not be called')
+        }
+      }
+    },
+    '@noCallThru': true
+  }
+
+  proxyquire('../../fastify', {
+    'node:diagnostics_channel': diagnostics
+  })()
+})

backend/node_modules/fastify/test/diagnostics-channel/sync-delay-request.test.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', async t => {
+  t.plan(10)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      setImmediate(() => reply.send({ hello: 'world' }))
+    }
+  })
+
+  t.after(() => { fastify.close() })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer + '/')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+})

backend/node_modules/fastify/test/diagnostics-channel/sync-request-reply.test.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', async t => {
+  t.plan(10)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
+  })
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+})

backend/node_modules/fastify/test/diagnostics-channel/sync-request.test.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', async t => {
+  t.plan(13)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.ok(msg.route)
+    t.assert.strictEqual(msg.route.url, '/:id')
+    t.assert.strictEqual(msg.route.method, 'GET')
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/:id',
+    handler: function (req, reply) {
+      return { hello: 'world' }
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer + '/7', {
+    method: 'GET'
+  })
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+})