@platformatic/watt-extra 0.1.0

package/test/auth.test.js

@@ -0,0 +1,128 @@
+import { test } from 'node:test'
+import { equal } from 'node:assert'
+import fastify from 'fastify'
+import { request } from 'undici'
+import { setUpEnvironment, createJwtToken } from './helper.js'
+import authPlugin from '../plugins/auth.js'
+
+const createMockApp = () => {
+  return {
+    log: {
+      info: () => {},
+      warn: () => {},
+      error: () => {}
+    }
+  }
+}
+
+test('auth plugin sets authorization header with token', async (t) => {
+  const originalEnv = { ...process.env }
+
+  t.after(() => {
+    process.env = originalEnv
+  })
+
+  const testToken = 'test-env-token-5678'
+  setUpEnvironment({ PLT_TEST_TOKEN: testToken })
+
+  const server = fastify()
+  server.get('/', async (request) => {
+    return { headers: request.headers }
+  })
+  await server.listen({ port: 0 })
+  const url = `http://localhost:${server.server.address().port}`
+
+  t.after(() => server.close())
+
+  const app = createMockApp()
+  await authPlugin(app)
+
+  const tokenResponse = await request(url, { dispatcher: app.dispatcher })
+  const tokenResponseBody = await tokenResponse.body.json()
+
+  equal(tokenResponse.statusCode, 200)
+  equal(tokenResponseBody.headers.authorization, `Bearer ${testToken}`)
+  equal(app.token, testToken)
+})
+
+test('auth plugin falls back to env variable when k8s token is not available', async (t) => {
+  const originalEnv = { ...process.env }
+
+  t.after(() => {
+    process.env = originalEnv
+  })
+
+  const testToken = 'test-env-token-5678'
+  setUpEnvironment({ PLT_TEST_TOKEN: testToken })
+
+  const server = fastify()
+  server.get('/', async (request) => {
+    return { headers: request.headers }
+  })
+  await server.listen({ port: 0 })
+  const url = `http://localhost:${server.server.address().port}`
+
+  t.after(() => server.close())
+
+  const app = createMockApp()
+  await authPlugin(app)
+
+  equal(app.token, testToken)
+
+  const tokenResponse = await request(url, { dispatcher: app.dispatcher })
+  const tokenResponseBody = await tokenResponse.body.json()
+
+  equal(tokenResponse.statusCode, 200)
+  equal(tokenResponseBody.headers.authorization, `Bearer ${testToken}`)
+})
+
+test('auth plugin reloads expired token', async (t) => {
+  const originalEnv = { ...process.env }
+
+  t.after(() => {
+    process.env = originalEnv
+  })
+
+  const expiredToken = createJwtToken(-10) // Already expired (by 10 seconds)
+  const validToken = createJwtToken(3600) // Valid for 1 hour
+
+  process.env.PLT_TEST_TOKEN = expiredToken
+
+  const logMessages = []
+  const app = {
+    log: {
+      info: (msg) => {
+        if (typeof msg === 'string') {
+          logMessages.push(msg)
+        }
+      },
+      warn: () => {},
+      error: () => {}
+    }
+  }
+
+  // Set up test server
+  const server = fastify()
+  server.get('/', async (request) => {
+    return { headers: request.headers }
+  })
+  await server.listen({ port: 0 })
+  const url = `http://localhost:${server.server.address().port}`
+
+  t.after(async () => server.close())
+
+  await authPlugin(app)
+
+  // The initial token is the expired one
+  equal(app.token, expiredToken, 'Should initially load the expired token')
+
+  // Now change the environment variable for the next token load
+  process.env.PLT_TEST_TOKEN = validToken
+
+  const response = await request(url, { dispatcher: app.dispatcher })
+  const responseBody = await response.body.json()
+  equal(app.token, validToken, 'Token should be reloaded with valid token')
+  equal(responseBody.headers.authorization, `Bearer ${validToken}`, 'Valid token should be used in authorization header')
+  const reloadLogMessage = logMessages.find(msg => msg === 'JWT token expired, reloading')
+  equal(!!reloadLogMessage, true, 'Should log message about token reload')
+})

package/test/auto-cache.test.js

@@ -0,0 +1,401 @@
+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
+} from './helper.js'
+import { start } from '../index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+test('should spawn an app with auto caching', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-domains')
+
+  await installDeps(t, applicationPath, ['@platformatic/composer'])
+
+  const savedRequestHashes = []
+  const savedRequests = []
+
+  const cacheConfig = {
+    rules: [{
+      routeToMatch: 'http://alpha.plt.local/counter',
+      headers: {
+        'cache-control': 'public, max-age=3',
+        'x-foo-bar': 'baz'
+      },
+      cacheTags: {
+        // eslint-disable-next-line
+        fgh: `'default', 'custom-cache-tag-' + .querystring["app-id"]`
+      }
+    }]
+  }
+
+  const iccConfig = {
+    httpCacheConfig: cacheConfig
+  }
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    iccConfig,
+    enableSlicerInterceptor: true,
+    enableTrafficInterceptor: true,
+    saveRequestHash: (data) => { savedRequestHashes.push(data) },
+    saveRequest: (data) => { savedRequests.push(data) }
+  })
+
+  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, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 0)
+
+    assert.strictEqual(headers['cache-control'], 'public, max-age=3')
+    assert.strictEqual(headers['x-foo-bar'], 'baz')
+    assert.strictEqual(headers['x-custom-cache-tags'], 'default,custom-cache-tag-123')
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  {
+    const { statusCode, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 0)
+
+    assert.strictEqual(headers['cache-control'], 'public, max-age=3')
+    assert.strictEqual(headers['x-foo-bar'], 'baz')
+    assert.strictEqual(headers['x-custom-cache-tags'], 'default,custom-cache-tag-123')
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  // Wait for the cache to expire
+  await sleep(3500)
+
+  {
+    const { statusCode, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 1)
+
+    assert.strictEqual(headers['cache-control'], 'public, max-age=3')
+    assert.strictEqual(headers['x-foo-bar'], 'baz')
+    assert.strictEqual(headers['x-custom-cache-tags'], 'default,custom-cache-tag-123')
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  {
+    const { statusCode, headers } = await request('http://127.0.0.1:3042/2/beta')
+    assert.strictEqual(statusCode, 200)
+
+    assert.strictEqual(headers['cache-control'], undefined)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+    assert.strictEqual(headers['x-custom-cache-tags'], undefined)
+
+    // Wait for interceptor to send data to the Trafficante
+    await sleep(1000)
+
+    assert.strictEqual(savedRequestHashes.length, 1)
+    assert.strictEqual(savedRequests.length, 1)
+
+    const savedRequestHash = savedRequestHashes[0]
+    assert.strictEqual(savedRequestHash.applicationId, applicationId)
+    assert.strictEqual(typeof savedRequestHash.timestamp, 'number')
+    assert.strictEqual(savedRequestHash.request.url, 'http://beta.plt.local/beta')
+
+    const savedRequest = savedRequests[0]
+    assert.strictEqual(savedRequest.applicationId, applicationId)
+    assert.strictEqual(savedRequest.request.url, 'http://beta.plt.local/beta')
+    assert.ok(savedRequest.request.headers)
+    assert.ok(savedRequest.response.headers)
+    assert.deepStrictEqual(savedRequest.response.body, { from: 'beta' })
+  }
+})
+
+test('should update the cache config at runtime', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-domains')
+
+  await installDeps(t, applicationPath, ['@platformatic/composer'])
+
+  const savedRequestHashes = []
+  const savedRequests = []
+
+  const initialIccConfig = {
+    httpCacheConfig: {
+      rules: [{
+        routeToMatch: 'http://alpha.plt.local/counter',
+        headers: { 'x-foo-bar': 'baz' }
+      }]
+    }
+  }
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    iccConfig: initialIccConfig,
+    enableSlicerInterceptor: true,
+    saveRequestHash: (data) => { savedRequestHashes.push(data) },
+    saveRequest: (data) => { savedRequests.push(data) }
+  })
+
+  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, headers } = await request('http://127.0.0.1:3042/1/counter')
+    assert.strictEqual(statusCode, 200)
+    assert.strictEqual(headers['x-foo-bar'], 'baz')
+  }
+
+  const updatedIccConfig = {
+    httpCacheConfig: {
+      rules: [{
+        routeToMatch: 'http://alpha.plt.local/counter',
+        headers: { 'x-foo-bar': 'updated-baz' }
+      }]
+    }
+  }
+
+  await icc.emitApplicationUpdate(applicationId, {
+    topic: 'config',
+    type: 'config-updated',
+    data: updatedIccConfig
+  })
+
+  {
+    const { statusCode, headers } = await request('http://127.0.0.1:3042/1/counter')
+    assert.strictEqual(statusCode, 200)
+    assert.strictEqual(headers['x-foo-bar'], 'updated-baz')
+  }
+})
+
+test('should set the cache config at runtime', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-domains')
+
+  await installDeps(t, applicationPath, ['@platformatic/composer'])
+
+  const savedRequestHashes = []
+  const savedRequests = []
+
+  const initialIccConfig = {
+    httpCacheConfig: null
+  }
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    iccConfig: initialIccConfig,
+    enableSlicerInterceptor: true,
+    saveRequestHash: (data) => { savedRequestHashes.push(data) },
+    saveRequest: (data) => { savedRequests.push(data) }
+  })
+
+  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, headers } = await request('http://127.0.0.1:3042/1/counter')
+    assert.strictEqual(statusCode, 200)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+  }
+
+  const updatedIccConfig = {
+    httpCacheConfig: {
+      rules: [{
+        routeToMatch: 'http://alpha.plt.local/counter',
+        headers: { 'x-foo-bar': 'updated-baz' }
+      }]
+    }
+  }
+
+  await icc.emitApplicationUpdate(applicationId, {
+    topic: 'config',
+    type: 'config-updated',
+    data: updatedIccConfig
+  })
+
+  {
+    const { statusCode, headers } = await request('http://127.0.0.1:3042/1/counter')
+    assert.strictEqual(statusCode, 200)
+    assert.strictEqual(headers['x-foo-bar'], 'updated-baz')
+  }
+})
+
+test('should not set auto cache if it is disabled', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-domains')
+
+  await installDeps(t, applicationPath, ['@platformatic/composer'])
+
+  const savedRequestHashes = []
+  const savedRequests = []
+
+  const cacheConfig = {
+    rules: [{
+      routeToMatch: 'http://alpha.plt.local/counter',
+      headers: {
+        'cache-control': 'public, max-age=3',
+        'x-foo-bar': 'baz'
+      },
+      cacheTags: {
+        // eslint-disable-next-line
+        fgh: `'default', 'custom-cache-tag-' + .querystring["app-id"]`
+      }
+    }]
+  }
+
+  const iccConfig = {
+    httpCacheConfig: cacheConfig
+  }
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    iccConfig,
+    enableSlicerInterceptor: false,
+    enableTrafficInterceptor: false,
+    saveRequestHash: (data) => { savedRequestHashes.push(data) },
+    saveRequest: (data) => { savedRequests.push(data) }
+  })
+
+  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, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 0)
+
+    assert.strictEqual(headers['cache-control'], undefined)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+    assert.strictEqual(headers['x-custom-cache-tags'], undefined)
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  {
+    const { statusCode, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 1)
+
+    assert.strictEqual(headers['cache-control'], undefined)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+    assert.strictEqual(headers['x-custom-cache-tags'], undefined)
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  // Wait for the cache to expire
+  await sleep(3500)
+
+  {
+    const { statusCode, headers, body } = await request('http://127.0.0.1:3042/1/counter', {
+      query: { 'app-id': '123' }
+    })
+    assert.strictEqual(statusCode, 200)
+
+    const { counter } = await body.json()
+    assert.strictEqual(counter, 2)
+
+    assert.strictEqual(headers['cache-control'], undefined)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+    assert.strictEqual(headers['x-custom-cache-tags'], undefined)
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+
+  {
+    const { statusCode, headers } = await request('http://127.0.0.1:3042/2/beta')
+    assert.strictEqual(statusCode, 200)
+
+    assert.strictEqual(headers['cache-control'], undefined)
+    assert.strictEqual(headers['x-foo-bar'], undefined)
+    assert.strictEqual(headers['x-custom-cache-tags'], undefined)
+
+    await sleep(1000)
+
+    assert.strictEqual(savedRequestHashes.length, 0)
+    assert.strictEqual(savedRequests.length, 0)
+  }
+})

package/test/cli.test.js

@@ -0,0 +1,75 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { spawn } from 'node:child_process'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+// Helper function to run CLI with arguments and capture output
+function runCLI (args = []) {
+  return new Promise((resolve, reject) => {
+    const cliPath = join(__dirname, '..', 'cli.js')
+    const proc = spawn('node', [cliPath, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    const stdout = []
+    const stderr = []
+
+    proc.stdout.on('data', (data) => {
+      stdout.push(data.toString())
+    })
+
+    proc.stderr.on('data', (data) => {
+      stderr.push(data.toString())
+    })
+
+    proc.on('error', reject)
+
+    proc.on('close', (code) => {
+      resolve({
+        code,
+        stdout: stdout.join(''),
+        stderr: stderr.join('')
+      })
+    })
+  })
+}
+
+test('CLI should exit with error code for non-existent command', async (t) => {
+  const { code } = await runCLI(['nonexistentcommand'])
+
+  // The important part is that a non-existent command exits with error code 1
+  assert.strictEqual(code, 1, 'Process should exit with code 1 for non-existent command')
+})
+
+test('CLI should show help when no arguments are provided', async (t) => {
+  const { code, stdout } = await runCLI([])
+
+  assert.strictEqual(code, 0, 'Process should exit with code 0')
+  assert.ok(
+    stdout.includes('WattExtra'),
+    'Help output should include application name'
+  )
+})
+
+test('CLI should show help with help command', async (t) => {
+  const { code, stdout } = await runCLI(['help'])
+
+  assert.strictEqual(code, 0, 'Process should exit with code 0')
+  assert.ok(
+    stdout.includes('WattExtra'),
+    'Help output should include application name'
+  )
+})
+
+test('CLI should show version with version command', async (t) => {
+  const { code, stdout } = await runCLI(['version'])
+  assert.strictEqual(code, 0, 'Process should exit with code 0')
+  assert.ok(
+    stdout.includes('WattExtra v'),
+    'Version output should include version number'
+  )
+})

package/test/compliancy.test.js

@@ -0,0 +1,87 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import { randomUUID } from 'node:crypto'
+import { start } from '../index.js'
+import {
+  setUpEnvironment,
+  startICC,
+  installDeps
+} from './helper.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 retrieve and send compliancy metadata', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  await installDeps(t, applicationPath, null, [
+    { name: '@foo/bar-1', version: '1.2.3' }
+  ])
+
+  const receivedMetadata = []
+
+  const icc = await startICC(t, {
+    applicationId,
+    saveComplianceMetadata: async (applicationId, data) => {
+      receivedMetadata.push({ applicationId, data })
+    },
+    getComplianceReport: async () => {
+      return { compliant: true }
+    }
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_DISABLE_COMPLIANCE_CHECK: false
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  assert.strictEqual(receivedMetadata.length, 1)
+
+  const [metadata] = receivedMetadata
+  assert.strictEqual(metadata.applicationId, applicationId)
+  assert.deepStrictEqual(metadata.data, {
+    npmDependencies: {
+      runtime: {
+        current: {
+          '@platformatic/runtime': platformaticVersion,
+          '@foo/bar-1': '1.2.3'
+        },
+        dependencies: {
+          '@platformatic/runtime': 'workspace:*',
+          '@foo/bar-1': '^1.0.0',
+          missing: '^1.33.3'
+        }
+      },
+      services: {
+        main: {
+          current: {
+            '@platformatic/runtime': platformaticVersion,
+            '@foo/bar-1': '1.2.3'
+          },
+          dependencies: {
+            '@platformatic/runtime': 'workspace:*',
+            '@foo/bar-1': '^1.0.0',
+            missing: '^1.33.3'
+          }
+        }
+      }
+    }
+  })
+})

package/test/fixtures/runtime-domains/alpha/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@platformatic/service": "workspace:*"
+  }
+}

package/test/fixtures/runtime-domains/alpha/platformatic.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/service/2.44.0.json",  
+  "plugins": {
+    "paths": ["./plugin.js"]    
+  }
+}