@platformatic/watt-extra 0.1.0

package/test/shared-context.test.js

@@ -0,0 +1,82 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { randomUUID } from 'node:crypto'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { request } from 'undici'
+import {
+  startICC,
+  installDeps,
+  setUpEnvironment,
+  createJwtToken
+} from './helper.js'
+import { start } from '../index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+test('should propagete a jwt token via runtime shared context', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-domains')
+
+  await installDeps(t, applicationPath, ['@platformatic/composer'])
+
+  const expiresIn = 10
+  const jwt = createJwtToken(expiresIn)
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_TEST_TOKEN: jwt,
+    PLT_JWT_EXPIRATION_OFFSET_SEC: 1
+  })
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName
+  })
+
+  const app = await start()
+
+  let newToken = null
+  setTimeout(() => {
+    newToken = createJwtToken(expiresIn)
+    process.env.PLT_TEST_TOKEN = newToken
+  }, expiresIn * 1000)
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  {
+    const { statusCode, body } = await request('http://127.0.0.1:3042/1/shared-context')
+    assert.strictEqual(statusCode, 200)
+
+    const sharedContext = await body.json()
+
+    const { iccAuthHeaders } = sharedContext
+    const { authorization } = iccAuthHeaders
+    assert.strictEqual(authorization, `Bearer ${jwt}`)
+  }
+
+  // Wait for the token to expire
+  await sleep(expiresIn * 1000 + 1000)
+
+  {
+    const { statusCode, body } = await request('http://127.0.0.1:3042/1/shared-context')
+    assert.strictEqual(statusCode, 200)
+
+    const sharedContext = await body.json()
+
+    const { iccAuthHeaders } = sharedContext
+    const { authorization } = iccAuthHeaders
+    assert.strictEqual(authorization, `Bearer ${newToken}`)
+  }
+
+  assert.notStrictEqual(jwt, newToken)
+})

package/test/spawn.test.js

@@ -0,0 +1,110 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { hostname } from 'node:os'
+import { randomUUID } from 'node:crypto'
+import { request } from 'undici'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { setUpEnvironment, startICC } from './helper.js'
+import { start } from '../index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const require = createRequire(import.meta.url)
+const platformaticVersion = require('@platformatic/runtime/package.json').version
+
+test('should spawn a service app sending the state', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  const applicationStates = []
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    saveApplicationInstanceState: (state) => {
+      applicationStates.push(state)
+    },
+  })
+
+  process.env.PLT_TEST_APP_1_URL = 'http://test-app-1:3042'
+  t.after(() => {
+    delete process.env.PLT_TEST_APP_1_URL
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  {
+    const { statusCode, body } = await request('http://127.0.0.1:3042/example')
+    assert.strictEqual(statusCode, 200)
+
+    const data = await body.json()
+    assert.deepStrictEqual(data, { hello: 'world' })
+  }
+
+  assert.strictEqual(applicationStates.length, 1)
+  const [state] = applicationStates
+  assert.strictEqual(state.instanceId, hostname())
+  assert.deepStrictEqual(state.state.applications.length, 1)
+  assert.strictEqual(
+    state.state.metadata.platformaticVersion,
+    platformaticVersion
+  )
+})
+
+test('should not fail on worker error', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-3')
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  {
+    const { statusCode, body } = await request('http://127.0.0.1:3042/example')
+    assert.strictEqual(statusCode, 200)
+
+    const data = await body.json()
+    assert.deepStrictEqual(data, { hello: 'world' })
+  }
+
+  // Await for runtime to crash and restart
+  await sleep(4000)
+
+  {
+    const { statusCode, body } = await request('http://127.0.0.1:3042/example')
+    assert.strictEqual(statusCode, 200)
+
+    const data = await body.json()
+    assert.deepStrictEqual(data, { hello: 'world' })
+  }
+})

package/test/trigger-flamegraphs.test.js

@@ -0,0 +1,226 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import { once } from 'node:events'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { WebSocketServer } from 'ws'
+import { setUpEnvironment } from './helper.js'
+import updatePlugin from '../plugins/update.js'
+import flamegraphsPlugin from '../plugins/flamegraphs.js'
+
+function setupMockIccServer (wss, receivedMessages, validateAuth = false) {
+  let ws = null
+
+  const waitForClientSubscription = once(wss, 'connection').then(
+    ([socket, req]) => {
+      ws = socket
+
+      if (validateAuth) {
+        equal(req.headers.authorization, 'Bearer test-token')
+      }
+
+      return new Promise((resolve) => {
+        socket.on('message', (data) => {
+          const message = JSON.parse(data.toString())
+          receivedMessages.push(message)
+
+          if (message.command === 'subscribe' && message.topic === '/config') {
+            socket.send(JSON.stringify({ command: 'ack' }))
+            resolve()
+          }
+        })
+      })
+    }
+  )
+
+  return { waitForClientSubscription, getWs: () => ws }
+}
+
+function createMockApp (port, includeScalerUrl = true) {
+  const mockWattPro = {
+    runtime: {
+      getApplications: () => ({
+        applications: [{ id: 'service-1' }, { id: 'service-2' }],
+      }),
+    },
+  }
+
+  const app = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+      debug: () => {},
+    },
+    instanceConfig: {
+      applicationId: 'test-application-id',
+    },
+    instanceId: 'test-pod-123',
+    getAuthorizationHeader: async () => {
+      return { Authorization: 'Bearer test-token' }
+    },
+    env: {
+      PLT_APP_NAME: 'test-app',
+      PLT_APP_DIR: '/path/to/app',
+      PLT_ICC_URL: `http://localhost:${port}`,
+      PLT_DISABLE_FLAMEGRAPHS: false,
+      PLT_FLAMEGRAPHS_INTERVAL_SEC: 1
+    },
+    wattpro: mockWattPro,
+  }
+
+  if (includeScalerUrl) {
+    app.instanceConfig.iccServices = {
+      scaler: {
+        url: `http://localhost:${port}/scaler`,
+      },
+    }
+  }
+
+  return app
+}
+
+const port = 14000
+
+test('should handle trigger-flamegraph command and upload flamegraphs from services', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+  const getFlamegraphReqs = []
+  let uploadResolve
+  const allUploadsComplete = new Promise((resolve) => {
+    uploadResolve = resolve
+  })
+
+  const wss = new WebSocketServer({ port })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription, getWs } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    true
+  )
+
+  const app = createMockApp(port)
+
+  app.wattpro.runtime.sendCommandToApplication = async (
+    serviceId,
+    command
+  ) => {
+    if (command === 'getLastProfile') {
+      getFlamegraphReqs.push({ serviceId })
+      if (getFlamegraphReqs.length === 2) {
+        uploadResolve()
+      }
+      return { success: true }
+    }
+    return { success: false }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  await waitForClientSubscription
+
+  const triggerFlamegraphMessage = {
+    command: 'trigger-flamegraph',
+  }
+
+  getWs().send(JSON.stringify(triggerFlamegraphMessage))
+
+  await allUploadsComplete
+
+  equal(getFlamegraphReqs.length, 2)
+
+  const service1Req = getFlamegraphReqs.find(
+    (f) => f.serviceId === 'service-1'
+  )
+  const service2Req = getFlamegraphReqs.find(
+    (f) => f.serviceId === 'service-2'
+  )
+
+  equal(service1Req.serviceId, 'service-1')
+  equal(service2Req.serviceId, 'service-2')
+
+  await app.closeUpdates()
+})
+
+test('should handle trigger-flamegraph when no runtime is available', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+
+  const wss = new WebSocketServer({ port: port + 1 })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription, getWs } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    false
+  )
+
+  const app = createMockApp(port + 1)
+  app.wattpro.runtime = null
+
+  await updatePlugin(app)
+  await app.connectToUpdates()
+  await waitForClientSubscription
+
+  const triggerFlamegraphMessage = {
+    command: 'trigger-flamegraph',
+  }
+
+  getWs().send(JSON.stringify(triggerFlamegraphMessage))
+
+  await sleep(100)
+
+  await app.closeUpdates()
+})
+
+test('should handle trigger-flamegraph when flamegraph upload fails', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+
+  const wss = new WebSocketServer({ port: port + 2 })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription, getWs } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    false
+  )
+
+  const app = createMockApp(port + 2)
+
+  app.wattpro.runtime.sendCommandToApplication = async (
+    serviceId,
+    command,
+    options
+  ) => {
+    if (command === 'sendFlamegraph' && options.url && options.headers) {
+      throw new Error('Flamegraph upload failed')
+    }
+    return { success: false }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  await waitForClientSubscription
+
+  const triggerFlamegraphMessage = {
+    command: 'trigger-flamegraph',
+  }
+
+  getWs().send(JSON.stringify(triggerFlamegraphMessage))
+
+  await sleep(100)
+
+  await app.closeUpdates()
+})