codify-plugin-test 0.0.33 → 0.0.35

package/src/plugin-process.ts

@@ -0,0 +1,183 @@
+import Ajv from 'ajv';
+import {
+  ApplyRequestData, ImportRequestData, ImportResponseData,
+  InitializeResponseData,
+  IpcMessageSchema,
+  IpcMessageV2,
+  MessageCmd, PlanRequestData, PlanResponseData,
+  SpawnStatus,
+  SudoRequestData,
+  SudoRequestDataSchema, ValidateRequestData, ValidateResponseData
+} from 'codify-schemas';
+import { nanoid } from 'nanoid';
+import { ChildProcess, SpawnOptions, fork, spawn } from 'node:child_process';
+import path from 'node:path';
+
+import { CodifyTestUtils } from './test-utils.js';
+
+const ajv = new Ajv.default({
+  strict: true
+});
+
+const ipcMessageValidator = ajv.compile(IpcMessageSchema);
+const sudoRequestValidator = ajv.compile(SudoRequestDataSchema);
+
+export class PluginProcess {
+  childProcess: ChildProcess
+  
+  /**
+   * PluginTester is a helper class to integration test plugins. It launches plugins via fork() just like CodifyCLI does.
+   *
+   * @param pluginPath A fully qualified path
+   */
+  constructor(pluginPath: string) {
+    if (!path.isAbsolute(pluginPath)) {
+      throw new Error('A fully qualified path must be supplied to PluginTester');
+    }
+
+    this.childProcess = fork(
+      pluginPath,
+      [],
+      {
+        // Use default true to test plugins in secure mode (un-able to request sudo directly)
+        // detached: true,
+        env: { ...process.env },
+        execArgv: ['--import', 'tsx/esm'],
+        stdio: 'pipe',
+      },
+    )
+
+    this.childProcess.stderr?.pipe(process.stderr);
+    this.childProcess.stdout?.pipe(process.stdout);
+
+    this.handleSudoRequests(this.childProcess);
+  }
+
+  async initialize(): Promise<InitializeResponseData> {
+    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
+      cmd: 'initialize',
+      data: {},
+      requestId: nanoid(6),
+    });
+  }
+
+  async validate(data: ValidateRequestData): Promise<ValidateResponseData> {
+    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
+      cmd: 'validate',
+      data,
+      requestId: nanoid(6),
+    });
+  }
+
+  async plan(data: PlanRequestData): Promise<PlanResponseData> {
+    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
+      cmd: 'plan',
+      data,
+      requestId: nanoid(6),
+    });
+  }
+
+  async apply(data: ApplyRequestData): Promise<void> {
+    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
+      cmd: 'apply',
+      data,
+      requestId: nanoid(6),
+    });
+  }
+
+  async import(data: ImportRequestData): Promise<ImportResponseData> {
+    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
+      cmd: 'import',
+      data,
+      requestId: nanoid(6),
+    });
+  }
+
+  kill() {
+    this.childProcess.kill();
+  }
+
+  private handleSudoRequests(process: ChildProcess) {
+    // Listen for incoming sudo incoming sudo requests
+    process.on('message', async (message) => {
+      if (!ipcMessageValidator(message)) {
+        throw new Error(`Invalid message from plugin. ${JSON.stringify(message, null, 2)}`);
+      }
+
+      if (message.cmd === MessageCmd.SUDO_REQUEST) {
+        const { data, requestId } = message;
+        if (!sudoRequestValidator(data)) {
+          throw new Error(`Invalid sudo request from plugin. ${JSON.stringify(sudoRequestValidator.errors, null, 2)}`);
+        }
+
+        const { command, options } = data as unknown as SudoRequestData;
+
+        console.log(`Running command with sudo: 'sudo ${command}'`)
+        const result = await sudoSpawn(command, options);
+
+        process.send(<IpcMessageV2>{
+          cmd: MessageCmd.SUDO_REQUEST + '_Response',
+          data: result,
+          requestId,
+        })
+      }
+    })
+  }
+  
+}
+
+type CodifySpawnOptions = {
+  cwd?: string;
+  throws?: boolean,
+} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>
+
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Options for spawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+async function sudoSpawn(
+  cmd: string,
+  opts: CodifySpawnOptions,
+): Promise<{ data: string, status: SpawnStatus }> {
+  return new Promise((resolve) => {
+    const output: string[] = [];
+
+    const _cmd = `sudo ${cmd}`;
+
+    // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+    // Ignore all stdin
+    const _process = spawn(`source ~/.zshrc; ${_cmd}`, [], {
+      ...opts,
+      shell: 'zsh',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const { stderr, stdout } = _process
+    stdout.setEncoding('utf8');
+    stderr.setEncoding('utf8');
+
+    stdout.on('data', (data) => {
+      output.push(data.toString());
+    })
+
+    stderr.on('data', (data) => {
+      output.push(data.toString());
+    })
+
+    stdout.pipe(process.stdout);
+    stderr.pipe(process.stderr);
+
+    _process.on('close', (code) => {
+      resolve({
+        data: output.join(''),
+        status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+      })
+    })
+  })
+}

package/src/plugin-tester.ts

@@ -1,64 +1,17 @@
-import Ajv from 'ajv';
+import chalk from 'chalk';
 import {
-  ApplyRequestData,
-  ImportRequestData,
   ImportResponseData,
-  InitializeResponseData,
-  IpcMessageSchema,
-  IpcMessageV2,
-  MessageCmd,
-  PlanRequestData,
   PlanResponseData,
   ResourceConfig,
   ResourceOperation,
-  SpawnStatus,
-  SudoRequestData,
-  SudoRequestDataSchema,
-  ValidateRequestData,
-  ValidateResponseData
 } from 'codify-schemas';
 import unionBy from 'lodash.unionby';
-import { nanoid } from 'nanoid';
-import { ChildProcess, SpawnOptions, fork, spawn } from 'node:child_process';
-import path from 'node:path';
-
-import { CodifyTestUtils } from './test-utils.js';
-
-const ajv = new Ajv.default({
-  strict: true
-});
-const ipcMessageValidator = ajv.compile(IpcMessageSchema);
-const sudoRequestValidator = ajv.compile(SudoRequestDataSchema);
 
+import { PluginProcess } from './plugin-process.js';
 
 export class PluginTester {
-  childProcess: ChildProcess
-
-  /**
-   * PluginTester is a helper class to integration test plugins. It launches plugins via fork() just like CodifyCLI does.
-   *
-   * @param pluginPath A fully qualified path
-   */
-  constructor(pluginPath: string) {
-    if (!path.isAbsolute(pluginPath)) {
-      throw new Error('A fully qualified path must be supplied to PluginTester');
-    }
-
-    this.childProcess = fork(
-      pluginPath,
-      [],
-      {
-        // Use default true to test plugins in secure mode (un-able to request sudo directly)
-        // detached: true,
-        env: { ...process.env },
-        execArgv: ['--import', 'tsx/esm', '--inspect=9221'],
-      },
-    )
-
-    this.handleSudoRequests(this.childProcess);
-  }
-
-  async fullTest(
+  static async fullTest(
+    pluginPath: string,
     configs: ResourceConfig[],
     options?: {
       skipUninstall?: boolean,
@@ -71,91 +24,110 @@ export class PluginTester {
         validateModify?: (plans: PlanResponseData[]) => Promise<void> | void,
       }
   }): Promise<void> {
+    const ids = configs.map((c) => c.name ? `${c.type}.${c.name}` : c.type).join(', ')
+    console.info(chalk.cyan(`Starting full test of [ ${ids} ]...`))
+
     const {
       skipUninstall = false,
     } = options ?? {}
 
-    const ids = configs.map((c) => c.name ? `${c.type}.${c.name}` : c.type).join(',')
 
-    console.info(`Testing initialization for ${ids}...`)
-    const initializeResult = await this.initialize();
+    const plugin = new PluginProcess(pluginPath);
+    try {
+      console.info(chalk.cyan('Testing initialization...'))
+      const initializeResult = await plugin.initialize();
 
-    const unsupportedConfigs = configs.filter((c)  =>
-      !initializeResult.resourceDefinitions.some((rd) => rd.type === c.type)
-    )
-    if (unsupportedConfigs.length > 0) {
-      throw new Error(`The plugin does not support the following configs supplied:\n ${JSON.stringify(unsupportedConfigs, null, 2)}\n Initialize result: ${JSON.stringify(initializeResult)}`)
-    }
+      const unsupportedConfigs = configs.filter((c) =>
+        !initializeResult.resourceDefinitions.some((rd) => rd.type === c.type)
+      )
+      if (unsupportedConfigs.length > 0) {
+        throw new Error(`The plugin does not support the following configs supplied:\n ${JSON.stringify(unsupportedConfigs, null, 2)}\n Initialize result: ${JSON.stringify(initializeResult)}`)
+      }
 
-    console.info(`Testing validate for ${ids}...`)
-    const validate = await this.validate({ configs });
+      console.info(chalk.cyan('Testing validate...'))
+      const validate = await plugin.validate({ configs });
 
-    const invalidConfigs = validate.resourceValidations.filter((v) => !v.isValid)
-    if (invalidConfigs.length > 0) {
-      throw new Error(`The following configs did not validate:\n ${JSON.stringify(invalidConfigs, null, 2)}`)
-    }
+      const invalidConfigs = validate.resourceValidations.filter((v) => !v.isValid)
+      if (invalidConfigs.length > 0) {
+        throw new Error(`The following configs did not validate:\n ${JSON.stringify(invalidConfigs, null, 2)}`)
+      }
 
-    console.info(`Testing plan for ${ids}...`)
-    const plans = [];
-    for (const config of configs) {
-      plans.push(await this.plan({
-        desired: config,
-        isStateful: false,
-        state: undefined,
-      }));
-    }
+      console.info(chalk.cyan('Testing plan...'))
+      const plans = [];
+      for (const config of configs) {
+        plans.push(await plugin.plan({
+          desired: config,
+          isStateful: false,
+          state: undefined,
+        }));
+      }
 
-    if (options?.validatePlan) {
-      await options.validatePlan(plans);
-    }
+      if (options?.validatePlan) {
+        await options.validatePlan(plans);
+      }
 
-    console.info(`Testing apply for ${ids}...`)
-    for (const plan of plans) {
-      await this.apply({
-        planId: plan.planId
-      });
-    }
+      console.info(chalk.cyan('Testing apply...'))
+      for (const plan of plans) {
+        await plugin.apply({
+          planId: plan.planId
+        });
+      }
 
-    if (options?.validateApply) {
-      await options.validateApply(plans);
+      if (options?.validateApply) {
+        await options.validateApply(plans);
+      }
+    } finally {
+      plugin.kill();
     }
 
-    console.info(`Testing import for ${ids}...`)
-    const importResults = [];
-    for (const config of configs) {
-      const importResult = await this.import({ config })
-      importResults.push(importResult);
-    }
+    const importPlugin = new PluginProcess(pluginPath);
+    try {
+      console.info(chalk.cyan('Testing import...'))
+
+      const importResults = [];
+      for (const config of configs) {
+        const importResult = await importPlugin.import({ config })
+        importResults.push(importResult);
+      }
 
-    if (options?.validateImport) {
-      await options.validateImport(importResults.map((r) => r.result[0]));
+      if (options?.validateImport) {
+        await options.validateImport(importResults.map((r) => r.result[0]));
+      }
+    } finally {
+      importPlugin.kill();
     }
 
     if (options?.testModify) {
-      console.info(`Testing modify for ${ids}...`)
-
-      const modifyPlans = [];
-      for (const config of options.testModify.modifiedConfigs) {
-        modifyPlans.push(await this.plan({
-          desired: config,
-          isStateful: false,
-          state: undefined,
-        }));
-      }
+      const modifyPlugin = new PluginProcess(pluginPath);
+
+      try {
+        console.info(chalk.cyan('Testing modify...'))
+
+        const modifyPlans = [];
+        for (const config of options.testModify.modifiedConfigs) {
+          modifyPlans.push(await modifyPlugin.plan({
+            desired: config,
+            isStateful: false,
+            state: undefined,
+          }));
+        }
 
-      if (modifyPlans.some((p) => p.operation !== ResourceOperation.MODIFY)) {
-        throw new Error(`Error while testing modify. Non-modify results were found in the plan: 
+        if (modifyPlans.some((p) => p.operation !== ResourceOperation.MODIFY)) {
+          throw new Error(`Error while testing modify. Non-modify results were found in the plan: 
 ${JSON.stringify(modifyPlans, null, 2)}`)
-      }
+        }
 
-      for (const plan of modifyPlans) {
-        await this.apply({
-          planId: plan.planId
-        });
-      }
+        for (const plan of modifyPlans) {
+          await modifyPlugin.apply({
+            planId: plan.planId
+          });
+        }
 
-      if (options.testModify.validateModify) {
-        await options.testModify.validateModify(modifyPlans);
+        if (options.testModify.validateModify) {
+          await options.testModify.validateModify(modifyPlans);
+        }
+      } finally {
+        modifyPlugin.kill();
       }
     }
 
@@ -167,112 +139,46 @@ ${JSON.stringify(modifyPlans, null, 2)}`)
       const id = (config: ResourceConfig) => config.type + (config.name ? `.${config.name}` : '')
 
       const configsToDestroy = unionBy(modifiedConfigs, configsWithNames, id);
-      await this.uninstall(configsToDestroy.toReversed(), options);
+      await this.uninstall(pluginPath, configsToDestroy.toReversed(), options);
     }
   }
 
-  async uninstall(configs: ResourceConfig[], options?: {
+  static async uninstall(pluginPath: string, configs: ResourceConfig[], options?: {
     validateDestroy?: (plans: PlanResponseData[]) => Promise<void> | void
   }) {
-    const ids = configs.map((c) => c.name ? `${c.type}.${c.name}` : c.type).join(',')
-    console.info(`Testing initialization for ${ids}...`)
-
-    const plans = [];
-    for (const config of configs) {
-      plans.push(await this.plan({
-        desired: undefined,
-        isStateful: true,
-        state: config
-      }))
-    }
-
-    for (const plan of plans) {
-      if (plan.operation !== ResourceOperation.DESTROY) {
-        throw new Error(`Expect resource operation to be 'destroy' but instead received plan: \n ${JSON.stringify(plan, null, 2)}`)
-      }
-
-      await this.apply({
-        planId: plan.planId
-      });
-    }
-
-    if (options?.validateDestroy) {
-      await options.validateDestroy(plans);
-    }
-  }
-
-  async initialize(): Promise<InitializeResponseData> {
-    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
-      cmd: 'initialize',
-      data: {},
-      requestId: nanoid(6),
-    });
-  }
-
-  async validate(data: ValidateRequestData): Promise<ValidateResponseData> {
-    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
-      cmd: 'validate',
-      data,
-      requestId: nanoid(6),
-    });
-  }
-
-  async plan(data: PlanRequestData): Promise<PlanResponseData> {
-    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
-      cmd: 'plan',
-      data,
-      requestId: nanoid(6),
-    });
-  }
-
-  async apply(data: ApplyRequestData): Promise<void> {
-    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
-      cmd: 'apply',
-      data,
-      requestId: nanoid(6),
-    });
-  }
-
-  async import(data: ImportRequestData): Promise<ImportResponseData> {
-    return CodifyTestUtils.sendMessageAndAwaitResponse(this.childProcess, {
-      cmd: 'import',
-      data,
-      requestId: nanoid(6),
-    });
-  }
-
-  kill() {
-    this.childProcess.kill();
-  }
-  
-  private handleSudoRequests(process: ChildProcess) {
-    // Listen for incoming sudo incoming sudo requests
-    process.on('message', async (message) => {
-      if (!ipcMessageValidator(message)) {
-        throw new Error(`Invalid message from plugin. ${JSON.stringify(message, null, 2)}`);
+    const destroyPlugin = new PluginProcess(pluginPath);
+
+    try {
+      console.info(chalk.cyan('Testing destroy...'))
+
+      const plans = [];
+      for (const config of configs) {
+        plans.push(await destroyPlugin.plan({
+          isStateful: true,
+          state: config,
+          desired: undefined
+        }))
       }
 
-      if (message.cmd === MessageCmd.SUDO_REQUEST) {
-        const { data, requestId } = message;
-        if (!sudoRequestValidator(data)) {
-          throw new Error(`Invalid sudo request from plugin. ${JSON.stringify(sudoRequestValidator.errors, null, 2)}`);
+      for (const plan of plans) {
+        if (plan.operation !== ResourceOperation.DESTROY) {
+          throw new Error(`Expect resource operation to be 'destroy' but instead received plan: \n ${JSON.stringify(plans, null, 2)}`)
         }
 
-        const { command, options } = data as unknown as SudoRequestData;
-
-        console.log(`Running command with sudo: 'sudo ${command}'`)
-        const result = await sudoSpawn(command, options);
+        await destroyPlugin.apply({
+          planId: plan.planId
+        });
+      }
 
-        process.send(<IpcMessageV2>{
-          cmd: MessageCmd.SUDO_REQUEST + '_Response',
-          data: result,
-          requestId,
-        })
+      if (options?.validateDestroy) {
+        await options.validateDestroy(plans);
       }
-    })
+    } finally {
+      destroyPlugin.kill();
+    }
   }
 
-  private addNamesToConfigs(configs: ResourceConfig[]): ResourceConfig[] {
+  private static addNamesToConfigs(configs: ResourceConfig[]): ResourceConfig[] {
     const configsWithNames = new Array<ResourceConfig>();
 
     const typeSet = new Set(configs.map((c) => c.type));
@@ -289,59 +195,3 @@ ${JSON.stringify(modifyPlans, null, 2)}`)
   }
 }
 
-
-type CodifySpawnOptions = {
-  cwd?: string;
-  throws?: boolean,
-} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>
-
-/**
- *
- * @param cmd Command to run. Ex: `rm -rf`
- * @param opts Options for spawn
- *
- * @see promiseSpawn
- * @see spawn
- *
- * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
- */
-async function sudoSpawn(
-  cmd: string,
-  opts: CodifySpawnOptions,
-): Promise<{ data: string, status: SpawnStatus }> {
-  return new Promise((resolve) => {
-    const output: string[] = [];
-
-    const _cmd = `sudo ${cmd}`;
-
-    // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
-    // Ignore all stdin
-    const _process = spawn(`source ~/.zshrc; ${_cmd}`, [], {
-      ...opts,
-      shell: 'zsh',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    const { stderr, stdout } = _process
-    stdout.setEncoding('utf8');
-    stderr.setEncoding('utf8');
-
-    stdout.on('data', (data) => {
-      output.push(data.toString());
-    })
-
-    stderr.on('data', (data) => {
-      output.push(data.toString());
-    })
-
-    stdout.pipe(process.stdout);
-    stderr.pipe(process.stderr);
-
-    _process.on('close', (code) => {
-      resolve({
-        data: output.join(''),
-        status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
-      })
-    })
-  })
-}