@platformatic/runtime 0.26.0

package/test/cli/validations.test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert'
+import { readFile } from 'node:fs/promises'
+import { test } from 'node:test'
+import { join } from 'desm'
+import { execa } from 'execa'
+import { cliPath } from './helper.mjs'
+
+const version = JSON.parse(await readFile(join(import.meta.url, '..', '..', 'package.json'))).version
+
+test('version', async () => {
+  const { stdout } = await execa(process.execPath, [cliPath, '--version'])
+
+  assert.strictEqual(stdout.trim(), `v${version}`)
+})
+
+test('missing config', async () => {
+  await assert.rejects(execa(process.execPath, [cliPath, 'start']))
+})
+
+test('no services specified by config', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'no-services.config.json')
+
+  await assert.rejects(execa(process.execPath, [cliPath, 'start', '--config', config]))
+})
+
+test('no services or autoload specified by config', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'no-sources.config.json')
+
+  await assert.rejects(execa(process.execPath, [cliPath, 'start', '--config', config]))
+})
+
+test('print validation errors', async () => {
+  let error
+
+  try {
+    const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'missing-property.config.json')
+
+    await execa(process.execPath, [cliPath, 'start', '--config', config])
+  } catch (err) {
+    error = err
+  }
+
+  assert(error)
+  assert.strictEqual(error.exitCode, 1)
+  assert.strictEqual(error.stdout, `
+┌─────────┬─────────────┬─────────────────────────────────────────────────────────────────┐
+│ (index) │    path     │                             message                             │
+├─────────┼─────────────┼─────────────────────────────────────────────────────────────────┤
+│    0    │ '/autoload' │ \`must have required property 'path' {"missingProperty":"path"}\` │
+└─────────┴─────────────┴─────────────────────────────────────────────────────────────────┘
+`.trim())
+})

package/test/cli/watch.test.mjs

@@ -0,0 +1,131 @@
+import assert from 'node:assert'
+import { cp, writeFile, mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { setTimeout as sleep } from 'node:timers/promises'
+import desm from 'desm'
+import { request } from 'undici'
+import { start } from './helper.mjs'
+const fixturesDir = join(desm(import.meta.url), '..', '..', 'fixtures')
+const undiciPath = join(desm(import.meta.url), '..', '..', 'node_modules', 'undici')
+
+function createCjsLoggingPlugin (text, reloaded) {
+  return `\
+    module.exports = async (app) => {
+      if (${reloaded}) {
+        app.log.info('RELOADED ' + '${text}')
+      }
+      app.get('/version', () => '${text}')
+    }
+  `
+}
+
+function createEsmLoggingPlugin (text, reloaded) {
+  return `\
+    import fs from 'fs' // No node: scheme. Coverage for the loader.
+    import dns from 'node:dns' // With node: scheme. Coverage for the loader.
+
+    try {
+      await import('./relative.mjs') // Relative path. Coverage for the loader.
+    } catch {
+      // Ignore err. File does not exist.
+    }
+
+    export default async function (app) {
+      if (${reloaded}) {
+        app.log.info('RELOADED ' + '${text}')
+      }
+      app.get('/version', () => '${text}')
+    }
+  `
+}
+
+test('watches CommonJS files', async (t) => {
+  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  t.diagnostic(`using ${tmpDir}`)
+  const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
+  const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
+  const appSrc = join(fixturesDir, 'monorepo')
+  const appDst = join(tmpDir, 'monorepo')
+  const cjsPluginFilePath = join(appDst, 'serviceAppWithLogger', 'plugin.js')
+
+  await Promise.all([
+    cp(configFileSrc, configFileDst),
+    cp(appSrc, appDst, { recursive: true })
+  ])
+
+  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
+
+  await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v1', false))
+  const { child } = await start('-c', configFileDst)
+  t.after(() => child.kill('SIGINT'))
+  child.stdout.pipe(process.stderr)
+  child.stderr.pipe(process.stderr)
+
+  await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v2', true))
+
+  for await (const log of child.ndj) {
+    if (log.msg === 'RELOADED v2') {
+      break
+    }
+  }
+})
+
+test('watches ESM files', async (t) => {
+  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  t.diagnostic(`using ${tmpDir}`)
+  const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
+  const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
+  const appSrc = join(fixturesDir, 'monorepo')
+  const appDst = join(tmpDir, 'monorepo')
+  const esmPluginFilePath = join(appDst, 'serviceAppWithMultiplePlugins', 'plugin2.mjs')
+
+  await Promise.all([
+    cp(configFileSrc, configFileDst),
+    cp(appSrc, appDst, { recursive: true })
+  ])
+
+  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
+
+  await writeFile(esmPluginFilePath, createEsmLoggingPlugin('v1', false))
+  const { child } = await start('-c', configFileDst)
+  t.after(() => child.kill('SIGINT'))
+  child.stdout.pipe(process.stderr)
+  child.stderr.pipe(process.stderr)
+  await writeFile(esmPluginFilePath, createEsmLoggingPlugin('v2', true))
+
+  for await (const log of child.ndj) {
+    if (log.msg === 'RELOADED v2') {
+      break
+    }
+  }
+})
+
+test('should not hot reload files with `--hot-reload false', async (t) => {
+  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  t.diagnostic(`using ${tmpDir}`)
+  const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
+  const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
+  const appSrc = join(fixturesDir, 'monorepo')
+  const appDst = join(tmpDir, 'monorepo')
+  const cjsPluginFilePath = join(appDst, 'serviceApp', 'plugin.js')
+
+  await Promise.all([
+    cp(configFileSrc, configFileDst),
+    cp(appSrc, appDst, { recursive: true })
+  ])
+
+  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
+
+  await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v1', false))
+  const { child, url } = await start('-c', configFileDst, '--hot-reload', 'false')
+  t.after(() => child.kill('SIGINT'))
+  child.stdout.pipe(process.stderr)
+  child.stderr.pipe(process.stderr)
+  await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v2', true))
+  await sleep(5000)
+  const res = await request(`${url}/version`)
+  const version = await res.body.text()
+  assert.strictEqual(version, 'v1')
+})

package/test/config.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+const { loadConfig } = require('@platformatic/service')
+const { platformaticRuntime } = require('../lib/config')
+const fixturesDir = join(__dirname, '..', 'fixtures')
+
+test('throws if no entrypoint is found', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'invalid-entrypoint.json')
+
+  platformaticRuntime() // Coverage cheat.
+
+  await assert.rejects(async () => {
+    await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  }, /invalid entrypoint: 'invalid' does not exist/)
+})
+
+test('throws if a config file is not found for an individual service', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'missing-service-config.json')
+
+  await assert.rejects(async () => {
+    await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  }, /no config file found for service 'docs'/)
+})
+
+test('performs a topological sort on services depending on allowCycles', async (t) => {
+  await t.test('does not sort if allowCycles is true', async () => {
+    const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+    const loaded = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+    const services = loaded.configManager.current.services
+
+    assert.strictEqual(services.length, 3)
+    assert.strictEqual(services[0].id, 'serviceApp')
+    assert.strictEqual(services[1].id, 'with-logger')
+    assert.strictEqual(services[2].id, 'multi-plugin-service')
+  })
+
+  await t.test('sorts if allowCycles is false', async () => {
+    const configFile = join(fixturesDir, 'configs', 'monorepo-no-cycles.json')
+    const loaded = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+    const services = loaded.configManager.current.services
+
+    assert.strictEqual(services.length, 3)
+    assert.strictEqual(services[0].id, 'with-logger')
+    assert.strictEqual(services[1].id, 'serviceApp')
+    assert.strictEqual(services[2].id, 'multi-plugin-service')
+  })
+
+  await t.test('throws if a cycle is present when not allowed', async () => {
+    const configFile = join(fixturesDir, 'configs', 'monorepo-create-cycle.json')
+
+    await assert.rejects(async () => {
+      await loadConfig({}, ['-c', configFile], platformaticRuntime)
+    })
+  })
+})

package/test/schema.test.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+const { schema } = require('../lib/schema')
+
+test('schema output', async (t) => {
+  const { execa } = await import('execa')
+  const { stdout } = await execa(process.execPath, [join(__dirname, '..', 'lib', 'schema.js')])
+
+  assert.deepStrictEqual(stdout, JSON.stringify(schema, null, 2))
+})

package/test/start.test.js

@@ -0,0 +1,101 @@
+'use strict'
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+const { request } = require('undici')
+const { loadConfig } = require('@platformatic/service')
+const { buildServer, platformaticRuntime } = require('..')
+const fixturesDir = join(__dirname, '..', 'fixtures')
+
+test('can start applications programmatically from object', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+  const entryUrl = await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const res = await request(entryUrl)
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.json(), { hello: 'hello123' })
+})
+
+test('can start applications programmatically from string', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const app = await buildServer(configFile)
+  const entryUrl = await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  {
+    // Basic URL on the entrypoint.
+    const res = await request(entryUrl)
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { hello: 'hello123' })
+  }
+
+  {
+    // URL on the entrypoint that uses internal message passing.
+    const res = await request(entryUrl + '/upstream')
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { hello: 'world' })
+  }
+})
+
+test('composer', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo-composer.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+  const entryUrl = await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  {
+    const res = await request(entryUrl)
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { message: 'Welcome to Platformatic! Please visit https://oss.platformatic.dev' })
+  }
+
+  {
+    const res = await request(entryUrl + '/service-app/')
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { hello: 'hello123' })
+  }
+})
+
+test('can restart the runtime apps', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const app = await buildServer(configFile)
+  const entryUrl = await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  {
+    const res = await request(entryUrl + '/upstream')
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { hello: 'world' })
+  }
+
+  await app.restart()
+
+  {
+    const res = await request(entryUrl + '/upstream')
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(await res.body.json(), { hello: 'world' })
+  }
+})

package/test/worker.test.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const assert = require('node:assert')
+const { once } = require('node:events')
+const { join } = require('node:path')
+const { test } = require('node:test')
+const { Worker } = require('node:worker_threads')
+
+test('throws if unknown messages are received', async (t) => {
+  const workerFile = join(__dirname, '..', 'lib', 'worker.js')
+  const worker = new Worker(workerFile, {
+    execArgv: [],
+    workerData: { config: { services: [] } }
+  })
+
+  const [msg] = await once(worker, 'message')
+  assert.strictEqual(msg, 'plt:init')
+  worker.postMessage({ msg: 'unknown-message-type' })
+  const [err] = await once(worker, 'error')
+  assert.strictEqual(err.message, 'unknown message type: \'unknown-message-type\'')
+})