@platformatic/generators 1.13.0

package/test/base-generator.test.js

@@ -0,0 +1,459 @@
+'use strict'
+
+const { readFile, rm } = require('node:fs/promises')
+const { test, afterEach, describe } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+
+const { fakeLogger, getTempDir } = require('./helpers')
+const { BaseGenerator } = require('../lib/base-generator')
+const { convertServiceNameToPrefix } = require('../lib/utils')
+
+afterEach(async () => {
+  try {
+    await rm(join(__dirname, 'tmp'), { recursive: true })
+  } catch (err) {
+    // do nothing
+  }
+})
+
+test('should write file and dirs', async (t) => {
+  const dir = await getTempDir()
+  const gen = new BaseGenerator({
+    logger: fakeLogger
+  })
+
+  gen.setConfig({
+    targetDirectory: dir
+  })
+
+  await gen.run()
+  // check files are created
+  const packageJson = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'))
+  assert.ok(packageJson.scripts)
+  assert.ok(packageJson.dependencies)
+  assert.ok(packageJson.engines)
+
+  const configFile = JSON.parse(await readFile(join(dir, 'platformatic.json'), 'utf8'))
+  assert.deepEqual(configFile, {})
+
+  const gitignore = await readFile(join(dir, '.gitignore'), 'utf8')
+  assert.ok(gitignore.length > 0) // file is created and not empty
+})
+
+test('extended class should generate config', async (t) => {
+  class ServiceClass extends BaseGenerator {
+    async _getConfigFileContents () {
+      // Implement when extending this class
+      return {
+        foo: 'bar'
+      }
+    }
+  }
+
+  const svc = new ServiceClass({
+    type: 'service',
+    logger: fakeLogger
+  })
+
+  await svc.prepare()
+
+  const configFile = svc.files[1]
+  assert.deepEqual(configFile, {
+    path: '',
+    file: 'platformatic.service.json',
+    contents: JSON.stringify({ foo: 'bar' }, null, 2)
+  })
+})
+
+test('setConfig', async (t) => {
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+
+  // should init the default config
+  await bg.prepare()
+
+  assert.deepEqual(bg.config, {
+    port: 3042,
+    hostname: '0.0.0.0',
+    plugin: false,
+    typescript: false,
+    initGitRepository: false,
+    staticWorkspaceGitHubActions: false,
+    dynamicWorkspaceGitHubActions: false,
+    env: {},
+    dependencies: {},
+    devDependencies: {},
+    isRuntimeContext: false,
+    serviceName: '',
+    envPrefix: '',
+    tests: false
+  })
+
+  // should not have undefined properties
+  Object.entries(bg.config).forEach((kv) => {
+    assert.notStrictEqual(undefined, kv[1])
+  })
+
+  // partial config with defaults
+  bg.setConfig({
+    port: 3084
+  })
+
+  assert.deepEqual(bg.config, {
+    port: 3084, // this is the only custom value
+    hostname: '0.0.0.0',
+    plugin: false,
+    typescript: false,
+    initGitRepository: false,
+    staticWorkspaceGitHubActions: false,
+    dynamicWorkspaceGitHubActions: false,
+    env: {},
+    dependencies: {},
+    devDependencies: {},
+    isRuntimeContext: false,
+    serviceName: '',
+    envPrefix: '',
+    tests: false
+  })
+
+  // reset config to defaults
+  bg.setConfig()
+  assert.deepEqual(bg.config, {
+    port: 3042,
+    hostname: '0.0.0.0',
+    plugin: false,
+    typescript: false,
+    initGitRepository: false,
+    staticWorkspaceGitHubActions: false,
+    dynamicWorkspaceGitHubActions: false,
+    env: {},
+    dependencies: {},
+    devDependencies: {},
+    isRuntimeContext: false,
+    serviceName: '',
+    envPrefix: '',
+    tests: false
+  })
+})
+
+test('should append env values', async (t) => {
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+  // partial config with defaults
+  bg.setConfig({
+    env: {
+      FOO: 'bar'
+    }
+  })
+
+  await bg.prepare()
+  const dotEnvFile = bg.getFileObject('.env')
+  assert.equal(dotEnvFile.contents, 'FOO=bar\n')
+})
+
+test('should return service metadata', async (t) => {
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+  // partial config with defaults
+  bg.setConfig({
+    targetDirectory: '/foo/bar',
+    env: {
+      FOO: 'bar'
+    }
+  })
+
+  const metadata = await bg.prepare()
+  assert.deepEqual(metadata, {
+    targetDirectory: '/foo/bar',
+    env: {
+      FOO: 'bar'
+    }
+  })
+})
+
+test('should generate javascript plugin, routes and tests', async (t) => {
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+  bg.setConfig({
+    plugin: true,
+    tests: true
+  })
+  await bg.prepare()
+  assert.ok(bg.getFileObject('example.js', 'plugins'))
+  assert.ok(bg.getFileObject('root.js', 'routes'))
+
+  assert.ok(bg.getFileObject('root.test.js', 'test/routes'))
+  assert.ok(bg.getFileObject('example.test.js', 'test/plugins'))
+})
+
+test('should generate tsConfig file and typescript files', async (t) => {
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+  bg.setConfig({
+    typescript: true,
+    plugin: true,
+    tests: true
+  })
+  const template = {
+    compilerOptions: {
+      module: 'commonjs',
+      esModuleInterop: true,
+      target: 'es2020',
+      sourceMap: true,
+      pretty: true,
+      noEmitOnError: true,
+      incremental: true,
+      strict: true,
+      outDir: 'dist'
+    },
+    watchOptions: {
+      watchFile: 'fixedPollingInterval',
+      watchDirectory: 'fixedPollingInterval',
+      fallbackPolling: 'dynamicPriority',
+      synchronousWatchDirectory: true,
+      excludeDirectories: ['**/node_modules', 'dist']
+    }
+  }
+  await bg.prepare()
+  const tsConfigFile = bg.getFileObject('tsconfig.json')
+  assert.deepEqual(JSON.parse(tsConfigFile.contents), template)
+
+  assert.ok(bg.getFileObject('example.ts', 'plugins'))
+  assert.ok(bg.getFileObject('root.ts', 'routes'))
+
+  assert.ok(bg.getFileObject('root.test.ts', 'test/routes'))
+  assert.ok(bg.getFileObject('example.test.ts', 'test/plugins'))
+})
+
+test('should generate platformatic.json file if no type is generated', async (t) => {
+  const bg = new BaseGenerator()
+  await bg.prepare()
+  const configFileObject = bg.getFileObject('platformatic.json')
+  assert.ok(configFileObject)
+})
+
+test('should add questions in the correct position (before)', async (t) => {
+  const question = {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  }
+
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+
+  await bg.prepare()
+  const originalQuestionsLength = bg.questions.length
+  bg.addQuestion(question, { before: 'typescript' }) // should add as second question
+
+  assert.equal(bg.questions.length, originalQuestionsLength + 1)
+  assert.deepEqual(bg.questions[1], {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  })
+})
+
+test('should add questions in the correct position (after)', async (t) => {
+  const question = {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  }
+
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+
+  await bg.prepare()
+  const originalQuestionsLength = bg.questions.length
+  bg.addQuestion(question, { after: 'typescript' }) // should add as third question
+
+  assert.equal(bg.questions.length, originalQuestionsLength + 1)
+  assert.deepEqual(bg.questions[2], {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  })
+})
+
+test('should add questions at the end', async (t) => {
+  const question = {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  }
+
+  const bg = new BaseGenerator({
+    type: 'service'
+  })
+
+  await bg.prepare()
+  const originalQuestionsLength = bg.questions.length
+  bg.addQuestion(question)
+
+  assert.equal(bg.questions.length, originalQuestionsLength + 1)
+  assert.deepEqual(bg.questions[originalQuestionsLength], {
+    type: 'input',
+    name: 'serviceName',
+    message: 'What is the name of the service?'
+  })
+})
+
+test('should remove question', async (t) => {
+  const bg = new BaseGenerator()
+
+  await bg.prepare()
+
+  bg.removeQuestion('typescript')
+
+  bg.questions.forEach((question) => {
+    if (question.name === 'typescript') {
+      assert.fail()
+    }
+  })
+})
+
+test('should throw if preapare fails', async (t) => {
+  const bg = new BaseGenerator()
+
+  bg._beforePrepare = async () => {
+    throw new Error('beforePrepare error')
+  }
+  try {
+    await bg.prepare()
+    assert.fail()
+  } catch (err) {
+    assert.equal(err.code, 'PLT_GEN_PREPARE_ERROR')
+    assert.equal(err.message, 'Error while generating the files: beforePrepare error.')
+  }
+})
+
+test('should throw if there is a missing env variable', async () => {
+  const bg = new BaseGenerator()
+
+  bg._getConfigFileContents = async () => {
+    return {
+      FOO: '{FOO}',
+      BAR: '{BAR}'
+    }
+  }
+
+  bg.setConfig({
+    env: {
+      FOO: 'foobar'
+    }
+  })
+
+  try {
+    await bg.prepare()
+    assert.fail()
+  } catch (err) {
+    assert.equal(err.code, 'PLT_GEN_MISSING_ENV_VAR')
+    assert.equal(err.message, 'Env variable BAR is defined in config file platformatic.json, but not in config.env object.')
+  }
+})
+
+describe('runtime context', () => {
+  test('should set config.envPrefix correctly', async (t) => {
+    const bg = new BaseGenerator()
+
+    bg.setConfig({
+      isRuntimeContext: true,
+      serviceName: 'sample-service'
+    })
+
+    assert.equal(bg.config.envPrefix, 'SAMPLE_SERVICE')
+
+    bg.setConfig({
+      isRuntimeContext: true,
+      serviceName: 'sample-service',
+      envPrefix: 'ANOTHER_PREFIX',
+      env: {
+        FOO: 'bar',
+        BAZ: 'baz'
+      }
+    })
+
+    assert.equal(bg.config.envPrefix, 'ANOTHER_PREFIX')
+    assert.deepEqual(bg.config.env, {
+      PLT_ANOTHER_PREFIX_FOO: 'bar',
+      PLT_ANOTHER_PREFIX_BAZ: 'baz'
+    })
+  })
+
+  test('should generate correct env file from config.env', async (t) => {
+    const bg = new BaseGenerator()
+
+    bg.setConfig({
+      isRuntimeContext: true,
+      serviceName: 'sample-service',
+      envPrefix: 'ANOTHER_PREFIX',
+      env: {
+        FOO: 'bar',
+        BAZ: 'baz'
+      }
+    })
+
+    const meta = await bg.prepare()
+
+    assert.deepEqual(meta.env, {
+      PLT_ANOTHER_PREFIX_FOO: 'bar',
+      PLT_ANOTHER_PREFIX_BAZ: 'baz'
+    })
+  })
+
+  test('should return service metadata', async (t) => {
+    const bg = new BaseGenerator({
+      type: 'service'
+    })
+    // partial config with defaults
+    bg.setConfig({
+      targetDirectory: '/foo/bar',
+      isRuntimeContext: true,
+      serviceName: 'my-service',
+      env: {
+        FOO: 'bar'
+      }
+    })
+
+    const metadata = await bg.prepare()
+    assert.deepEqual(metadata, {
+      targetDirectory: '/foo/bar',
+      env: {
+        PLT_MY_SERVICE_FOO: 'bar'
+      }
+    })
+  })
+
+  test('should generate service name if not provided', async () => {
+    const bg = new BaseGenerator({
+      type: 'service'
+    })
+    bg.setConfig({
+      targetDirectory: '/foo/bar',
+      isRuntimeContext: true,
+      env: {
+        FOO: 'bar'
+      }
+    })
+
+    const metadata = await bg.prepare()
+
+    assert.equal(bg.config.envPrefix, convertServiceNameToPrefix(bg.config.serviceName))
+    const envPrefix = bg.config.envPrefix
+    assert.deepEqual(metadata, {
+      targetDirectory: '/foo/bar',
+      env: {
+        [`PLT_${envPrefix}_FOO`]: 'bar'
+      }
+    })
+  })
+})

package/test/file-generator.test.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+const { FileGenerator } = require('../lib/file-generator')
+const { rm, readFile } = require('node:fs/promises')
+const { join } = require('node:path')
+const { tmpdir } = require('node:os')
+const { safeMkdir } = require('../lib/utils')
+
+let dirCount = 0
+describe('FileGenerator', () => {
+  test('should return null if file is not found', async () => {
+    const fg = new FileGenerator()
+    const fileObject = fg.getFileObject('sample', 'file')
+    assert.strictEqual(null, fileObject)
+  })
+  test('should throw if no targeDirectory is set', async (t) => {
+    const fg = new FileGenerator()
+    assert.rejects(async () => {
+      await fg.writeFiles()
+    })
+  })
+
+  test('should replace a file with same name and path', async (t) => {
+    const fg = new FileGenerator()
+    fg.addFile({ path: 'path', file: 'file', contents: 'hello world' })
+    fg.addFile({ path: 'path', file: 'file', contents: 'foobar' })
+
+    const fileObject = fg.getFileObject('file', 'path')
+    assert.equal(fileObject.contents, 'foobar')
+    assert.equal(fg.files.length, 1)
+  })
+
+  test('should list files', async (t) => {
+    const fg = new FileGenerator()
+    fg.addFile({ path: 'path', file: 'helloworld.txt', contents: 'hello world' })
+    fg.addFile({ path: 'path', file: 'foobar.txt', contents: 'foobar' })
+    fg.addFile({ path: '/anotherpath', file: 'foobar.txt', contents: 'foobar' })
+
+    assert.deepEqual(fg.listFiles(), [
+      'path/helloworld.txt',
+      'path/foobar.txt',
+      'anotherpath/foobar.txt'
+    ])
+  })
+  test('should append file content', async (t) => {
+    const fg = new FileGenerator()
+    fg.addFile({ path: 'path', file: 'helloworld.txt', contents: 'hello world' })
+
+    fg.appendfile({ path: '/path', file: 'helloworld.txt', contents: 'Welcome to plaftormatic' })
+
+    const fileObject = fg.getFileObject('helloworld.txt', 'path')
+    assert.equal(fileObject.contents, 'hello world\nWelcome to plaftormatic')
+
+    // new file
+    fg.appendfile({ path: '/path', file: 'foobar.txt', contents: 'foobar' })
+    const newFileObject = fg.getFileObject('foobar.txt', 'path')
+    assert.equal(newFileObject.contents, 'foobar')
+  })
+
+  test('should reset all files', async (t) => {
+    const fg = new FileGenerator()
+    fg.addFile({ path: 'path', file: 'file', contents: 'hello world' })
+    fg.addFile({ path: 'path', file: 'file', contents: 'foobar' })
+
+    fg.reset()
+    assert.equal(fg.files.length, 0)
+  })
+
+  test('should write files', async (t) => {
+    const tempDir = join(tmpdir(), `plt-file-generator-test-${dirCount++}`)
+    t.after(async () => {
+      await rm(tempDir, { recursive: true })
+    })
+
+    await safeMkdir(tempDir)
+    const fg = new FileGenerator()
+    fg.setTargetDirectory(tempDir)
+    fg.addFile({ path: 'myDir', file: 'helloworld.txt', contents: 'hello world' })
+
+    await fg.writeFiles()
+    const fileContents = await readFile(join(tempDir, 'myDir', 'helloworld.txt'), 'utf8')
+    assert.equal(fileContents, 'hello world')
+  })
+
+  test('should not write empty files', async (t) => {
+    const tempDir = join(tmpdir(), `plt-file-generator-test-${dirCount++}`)
+    t.after(async () => {
+      await rm(tempDir, { recursive: true })
+    })
+
+    await safeMkdir(tempDir)
+    const fg = new FileGenerator()
+    fg.setTargetDirectory(tempDir)
+    fg.addFile({ path: 'myDir', file: 'helloworld.txt', contents: '' })
+
+    await fg.writeFiles()
+    try {
+      await readFile(join(tempDir, 'myDir', 'helloworld.txt'), 'utf8')
+      assert.fail()
+    } catch (err) {
+      assert.equal(err.code, 'ENOENT')
+    }
+  })
+})

package/test/helpers.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { join } = require('node:path')
+const fs = require('node:fs/promises')
+const { safeMkdir } = require('../lib/utils')
+
+let counter = 0
+
+async function getTempDir (baseDir) {
+  if (baseDir === undefined) {
+    baseDir = __dirname
+  }
+  const dir = join(baseDir, 'tmp', `platformatic-generators-${process.pid}-${Date.now()}-${counter++}`)
+  await safeMkdir(dir)
+  return dir
+}
+async function moveToTmpdir (teardown) {
+  const cwd = process.cwd()
+  const tmp = join(__dirname, 'tmp')
+  try {
+    await fs.mkdir(tmp)
+  } catch {
+  }
+  const dir = await getTempDir(tmp)
+  await fs.mkdir(dir)
+  process.chdir(dir)
+  teardown(() => process.chdir(cwd))
+  if (!process.env.SKIP_RM_TMP) {
+    teardown(() => fs.rm(tmp, { recursive: true }).catch(() => {}))
+  }
+  return dir
+}
+
+module.exports = {
+  fakeLogger: {
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {}
+  },
+  getTempDir,
+  moveToTmpdir
+}

package/test/runner.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { tap, spec } = require('node:test/reporters')
+const { run } = require('node:test')
+const path = require('node:path')
+const glob = require('glob').globSync
+
+/* eslint-disable new-cap */
+const reporter = process.stdout.isTTY ? new spec() : tap
+
+const files = [
+  ...glob(path.join(__dirname, '*.test.js')),
+  ...glob(path.join(__dirname, 'cli', '*.test.mjs'))
+]
+
+run({
+  files,
+  concurrency: 1,
+  timeout: 30000
+}).compose(reporter).pipe(process.stdout)