@platformatic/watt-extra 0.1.0

package/test/helper.js

@@ -0,0 +1,274 @@
+import { Agent, setGlobalDispatcher } from 'undici'
+import { mkdir, symlink, writeFile, rm } from 'node:fs/promises'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import fastify from 'fastify'
+import fp from 'fastify-plugin'
+import why from 'why-is-node-running'
+import fastifyWebsocket from '@fastify/websocket'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+setInterval(why, 120000).unref()
+
+setGlobalDispatcher(new Agent({
+  keepAliveTimeout: 10,
+  keepAliveMaxTimeout: 10
+}))
+
+function setUpEnvironment (env = {}) {
+  const defaultEnv = {
+    PLT_ZIO_HOSTNAME: '127.0.0.1',
+    PLT_ZIO_PORT: 4042,
+    PLT_ZIO_LOG_LEVEL: 'debug',
+    PLT_APP_HOSTNAME: '127.0.0.1',
+    PLT_APP_PORT: 3042,
+    PLT_METRICS_PORT: 9090,
+    PLT_DISABLE_COMPLIANCE_CHECK: 'true',
+    PLT_DISABLE_FLAMEGRAPHS: 'true',
+    PLT_THROW_ON_COMPLIANCE_FAILURE: 'false',
+    PLT_TEST_TOKEN: createJwtToken(3600)
+  }
+  Object.assign(process.env, defaultEnv, env)
+}
+
+async function startICC (t, opts = {}) {
+  let {
+    applicationId,
+    applicationName,
+    iccServices,
+    iccConfig = {},
+    enableOpenTelemetry = false,
+    enableSlicerInterceptor = false,
+    enableTrafficInterceptor = false,
+    controlPlaneResponse
+  } = opts
+
+  iccServices = iccServices || {
+    riskEngine: {
+      url: 'http://127.0.0.1:3000/risk-service'
+    },
+    trafficante: {
+      url: 'http://127.0.0.1:3000/trafficante'
+    },
+    compliance: {
+      url: 'http://127.0.0.1:3000/compliance'
+    },
+    cron: {
+      url: 'http://127.0.0.1:3000/cron'
+    },
+    scaler: {
+      url: 'http://127.0.0.1:3000/scaler'
+    }
+  }
+
+  const icc = fastify({
+    keepAliveTimeout: 1,
+    forceCloseConnections: true
+  })
+
+  await icc.register(fastifyWebsocket)
+
+  // Main
+  await icc.register(fp(async (icc) => {
+    const connections = new Map()
+
+    icc.decorate('emitApplicationUpdate', (applicationId, config) => {
+      const appConnections = connections.get(applicationId)
+      if (appConnections) {
+        for (const connection of appConnections) {
+          connection.send(JSON.stringify(config))
+        }
+      }
+    })
+
+    icc.get('/api/updates/applications/:id', { websocket: true }, async (connection, req) => {
+      connection.on('message', (message) => {
+        const applicationId = req.params.id
+        const { command, topic } = JSON.parse(message.toString())
+
+        if (command === 'subscribe' && topic === '/config') {
+          connection.send(JSON.stringify({ command: 'ack' }))
+        }
+
+        let appConnections = connections.get(applicationId)
+        if (!appConnections) {
+          appConnections = []
+          connections.set(applicationId, appConnections)
+        }
+        appConnections.push(connection)
+      })
+    })
+  }))
+
+  // Control Plane
+  await icc.register(async (icc) => {
+    icc.post('/pods/:podId/instance', async (req) => {
+      if (typeof controlPlaneResponse === 'function') {
+        return controlPlaneResponse(req)
+      }
+      return controlPlaneResponse || {
+        applicationId,
+        applicationName,
+        iccServices,
+        config: iccConfig,
+        enableOpenTelemetry,
+        enableSlicerInterceptor,
+        enableTrafficInterceptor
+      }
+    })
+
+    icc.post('/applications/:id/metadata', async (req) => {
+      const { applicationId, data } = req.body
+      return opts.saveComplianceMetadata?.(applicationId, data)
+    })
+
+    icc.post('/pods/:id/instance/state', async (req) => {
+      const instanceId = req.params.id
+      const state = req.body
+
+      await opts.saveApplicationInstanceState?.({ instanceId, state })
+      return {}
+    })
+  }, { prefix: '/control-plane' })
+
+  // Compliance
+  await icc.register(async (icc) => {
+    icc.post('/metadata', async (req) => {
+      const { applicationId, data } = req.body
+      return opts.saveComplianceMetadata?.(applicationId, data)
+    })
+
+    icc.post('/compliance', async (req) => {
+      const { applicationId } = req.body
+      return opts.getComplianceReport?.(applicationId)
+    })
+  }, { prefix: '/compliance' })
+
+  // Trafficante
+  await icc.register(async (icc) => {
+    icc.post('/requests/hash', async (req) => {
+      const { taxonomyId, applicationId } = JSON.parse(req.headers['x-labels'])
+      const { timestamp, request, response } = req.body
+      opts.saveRequestHash?.({ taxonomyId, applicationId, timestamp, request, response })
+    })
+
+    icc.post('/requests', async (req) => {
+      const { taxonomyId, applicationId } = JSON.parse(req.headers['x-labels'])
+      const request = JSON.parse(req.headers['x-request-data'])
+      const response = JSON.parse(req.headers['x-response-data'])
+      response.body = req.body
+
+      opts.saveRequest?.({ taxonomyId, applicationId, request, response })
+    })
+  }, { prefix: '/trafficante' })
+
+  // Risk Service
+  await icc.register(async (icc) => {
+    icc.addContentTypeParser(
+      'application/x-protobuf',
+      (req, payload, done) => {
+        payload.resume()
+        payload.on('end', done)
+      }
+    )
+    icc.post('/v1/traces', async () => {})
+  }, { prefix: '/risk-service' })
+
+  // Scaler
+  await icc.register(async (icc) => {
+    icc.addContentTypeParser(
+      'application/octet-stream',
+      function (request, payload, done) {
+        const chunks = []
+        payload.on('data', chunk => chunks.push(chunk))
+        payload.on('end', () => {
+          done(null, Buffer.concat(chunks))
+        })
+        payload.on('error', done)
+      }
+    )
+    icc.post('/alerts', async (req) => {
+      return opts.processAlerts?.(req)
+    })
+    icc.post('/pods/:podId/services/:serviceId/flamegraph', async (req) => {
+      return opts.processFlamegraphs?.(req)
+    })
+  }, { prefix: '/scaler' })
+
+  // Cron
+  await icc.register(async (icc) => {
+    icc.put('/watt-jobs', async (req) => {
+      const body = req.body
+      opts.saveWattJob?.(body)
+    })
+  }, { prefix: '/cron' })
+
+  await icc.listen({ port: 3000 })
+  return icc
+}
+
+async function installDeps (t, appDir, packageNames, testDependencies = []) {
+  const appDepsDir = join(appDir, 'node_modules')
+  await rm(appDepsDir, { force: true, recursive: true }).catch(() => {})
+  await mkdir(appDepsDir, { recursive: true })
+  t.after(() => rm(appDepsDir, { force: true, recursive: true }))
+
+  const toInstall = Array.from(new Set([
+    ...packageNames ?? [],
+    '@platformatic/runtime',
+    '@platformatic/config',
+    '@platformatic/service',
+    '@platformatic/node',
+    'undici'
+  ]))
+
+  for (const packageName of toInstall) {
+    let targetDir = null
+    let packageDir = null
+
+    if (packageName.includes('/')) {
+      const [scope, name] = packageName.split('/')
+      await mkdir(join(appDepsDir, scope), { recursive: true })
+
+      targetDir = join(__dirname, '..', 'node_modules', scope, name)
+      packageDir = join(appDepsDir, scope, name)
+    } else {
+      packageDir = join(appDepsDir, packageName)
+      targetDir = join(__dirname, '..', 'node_modules', packageName)
+    }
+    await symlink(targetDir, packageDir)
+  }
+
+  for (const testDependency of testDependencies) {
+    const { name, version } = testDependency
+    const packageDir = join(appDepsDir, name)
+    await mkdir(packageDir, { recursive: true })
+
+    const packageJsonPath = join(packageDir, 'package.json')
+    const packageJsonFile = JSON.stringify({ name, version })
+    await writeFile(packageJsonPath, packageJsonFile)
+  }
+}
+
+function createJwtToken (expiresInSeconds) {
+  const header = { alg: 'HS256', typ: 'JWT' }
+  const currentTime = Math.floor(Date.now() / 1000)
+  const payload = {
+    sub: '1234567890',
+    iat: currentTime,
+    exp: currentTime + (expiresInSeconds || 3600) // Default 1 hour expiration
+  }
+  const base64Header = Buffer.from(JSON.stringify(header)).toString('base64').replace(/=/g, '')
+  const base64Payload = Buffer.from(JSON.stringify(payload)).toString('base64').replace(/=/g, '')
+  const signature = 'test_signature'
+  return `${base64Header}.${base64Payload}.${signature}`
+}
+
+export {
+  setUpEnvironment,
+  startICC,
+  installDeps,
+  createJwtToken
+}

package/test/init.test.js

@@ -0,0 +1,243 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import { hostname } from 'node:os'
+import { randomUUID } from 'node:crypto'
+import { startICC } from './helper.js'
+import initPlugin from '../plugins/init.js'
+
+const createMockApp = (env = {}) => {
+  const logMessages = []
+  return {
+    env: {
+      PLT_CONTROL_PLANE_URL: 'http://127.0.0.1:3000/control-plane',
+      PLT_ICC_URL: 'http://127.0.0.1:3000',
+      ...env
+    },
+    log: {
+      info: (msg) => {
+        logMessages.push(msg)
+      },
+      warn: () => {},
+      error: () => {}
+    },
+    getAuthorizationHeader: async () => 'Bearer test-token',
+    logMessages
+  }
+}
+
+test('init plugin with explicit PLT_APP_NAME', async (t) => {
+  const applicationName = 'test-app-explicit'
+  const applicationId = randomUUID()
+  const instanceId = hostname()
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName
+  })
+
+  t.after(async () => {
+    await icc.close()
+  })
+
+  const app = createMockApp({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: '/test/dir'
+  })
+
+  await initPlugin(app)
+
+  equal(app.applicationName, applicationName)
+  equal(app.instanceId, instanceId)
+  equal(app.instanceConfig.applicationId, applicationId)
+})
+
+test('init plugin with optional PLT_APP_NAME - uses ICC response', async (t) => {
+  const applicationName = 'test-app-from-icc'
+  const applicationId = randomUUID()
+  const instanceId = hostname()
+
+  const icc = await startICC(t, {
+    applicationId,
+    controlPlaneResponse: {
+      applicationId,
+      applicationName, // ICC returns the application name
+      iccServices: {
+        riskEngine: { url: 'http://127.0.0.1:3000/risk-service' },
+        trafficante: { url: 'http://127.0.0.1:3000/trafficante' },
+        compliance: { url: 'http://127.0.0.1:3000/compliance' },
+        cron: { url: 'http://127.0.0.1:3000/cron' },
+        scaler: { url: 'http://127.0.0.1:3000/scaler' }
+      },
+      config: {},
+      enableOpenTelemetry: false,
+      enableSlicerInterceptor: false,
+      enableTrafficInterceptor: false
+    }
+  })
+
+  t.after(async () => {
+    await icc.close()
+  })
+
+  const app = createMockApp({
+    // PLT_APP_NAME is not set
+    PLT_APP_DIR: '/test/dir'
+  })
+
+  await initPlugin(app)
+
+  equal(app.applicationName, applicationName)
+  equal(app.instanceId, instanceId)
+  equal(app.instanceConfig.applicationId, applicationId)
+
+  // Check that logging shows the resolved application name
+  const resolvedNameLog = app.logMessages.find(msg =>
+    typeof msg === 'object' && msg.applicationName === applicationName
+  )
+  equal(!!resolvedNameLog, true)
+})
+
+test('init plugin in standalone mode - no ICC URL', async (t) => {
+  const applicationName = 'test-app-standalone'
+  const instanceId = hostname()
+
+  const app = createMockApp({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: '/test/dir',
+    PLT_ICC_URL: undefined // No ICC URL set
+  })
+
+  await initPlugin(app)
+
+  equal(app.applicationName, applicationName)
+  equal(app.instanceId, instanceId)
+  equal(app.instanceConfig, null)
+
+  // Check that logging shows ICC initialization was skipped
+  const skipLog = app.logMessages.find(msg =>
+    typeof msg === 'string' && msg.includes('skipping ICC initialization')
+  )
+  equal(!!skipLog, true)
+})
+
+test('init plugin handles ICC connection failure gracefully', async (t) => {
+  const applicationName = 'test-app-failure'
+  const instanceId = hostname()
+
+  const app = createMockApp({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: '/test/dir',
+    PLT_ICC_URL: 'http://127.0.0.1:9999' // Non-existent ICC
+  })
+
+  // Override error logging to capture errors
+  const errorMessages = []
+  app.log.error = (err, msg) => {
+    errorMessages.push({ err, msg })
+  }
+
+  await initPlugin(app)
+
+  // Should still set applicationName and instanceId
+  equal(app.applicationName, applicationName)
+  equal(app.instanceId, instanceId)
+
+  // Should have logged an error
+  equal(errorMessages.length, 1)
+  equal(errorMessages[0].msg, 'Failed to get application information')
+})
+
+test('init plugin sends correct request structure when PLT_APP_NAME provided', async (t) => {
+  const applicationName = 'test-app-request'
+  const applicationId = randomUUID()
+  const instanceId = hostname()
+
+  let capturedRequest = null
+
+  const icc = await startICC(t, {
+    applicationId,
+    controlPlaneResponse: (req) => {
+      capturedRequest = {
+        params: req.params,
+        body: req.body
+      }
+      return {
+        applicationId,
+        applicationName,
+        iccServices: {
+          riskEngine: { url: 'http://127.0.0.1:3000/risk-service' },
+          trafficante: { url: 'http://127.0.0.1:3000/trafficante' },
+          compliance: { url: 'http://127.0.0.1:3000/compliance' },
+          cron: { url: 'http://127.0.0.1:3000/cron' },
+          scaler: { url: 'http://127.0.0.1:3000/scaler' }
+        },
+        config: {}
+      }
+    }
+  })
+
+  t.after(async () => {
+    await icc.close()
+  })
+
+  const app = createMockApp({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: '/test/dir'
+  })
+
+  await initPlugin(app)
+
+  // Verify request structure
+  equal(capturedRequest.params.podId, instanceId)
+  equal(capturedRequest.body.applicationName, applicationName)
+  equal(capturedRequest.body.podId, instanceId)
+})
+
+test('init plugin sends request without applicationName when not provided', async (t) => {
+  const applicationName = 'test-app-no-name'
+  const applicationId = randomUUID()
+  const instanceId = hostname()
+
+  let capturedRequest = null
+
+  const icc = await startICC(t, {
+    applicationId,
+    controlPlaneResponse: (req) => {
+      capturedRequest = {
+        params: req.params,
+        body: req.body
+      }
+      return {
+        applicationId,
+        applicationName, // ICC provides the name
+        iccServices: {
+          riskEngine: { url: 'http://127.0.0.1:3000/risk-service' },
+          trafficante: { url: 'http://127.0.0.1:3000/trafficante' },
+          compliance: { url: 'http://127.0.0.1:3000/compliance' },
+          cron: { url: 'http://127.0.0.1:3000/cron' },
+          scaler: { url: 'http://127.0.0.1:3000/scaler' }
+        },
+        config: {}
+      }
+    }
+  })
+
+  t.after(async () => {
+    await icc.close()
+  })
+
+  const app = createMockApp({
+    // PLT_APP_NAME is not provided
+    PLT_APP_DIR: '/test/dir'
+  })
+
+  await initPlugin(app)
+
+  // Verify request structure - should not contain applicationName
+  equal(capturedRequest.params.podId, instanceId)
+  equal(capturedRequest.body.podId, instanceId)
+  equal(capturedRequest.body.applicationName, undefined)
+
+  // But app should have the name from ICC response
+  equal(app.applicationName, applicationName)
+})