Refactor and added pre-requisite parameter to fullTest

kevinwang5658 · kevinwang5658 · commit e3fc9c8cecaa · 2026-04-22T16:03:43.000-04:00
diff --git a/src/plugin-tester.ts b/src/plugin-tester.ts
@@ -10,84 +10,54 @@ import unionBy from 'lodash.unionby';
 import { PluginProcess } from './plugin-process.js';
 import { getPlatformOs, splitUserConfig } from './utils.js';
 
+export interface FullTestOptions {
+  skipUninstall?: boolean,
+  skipImport?: boolean,
+
+  // Ensure these resources are installed before testing starts. Will install if missing, but never destroy after.
+  prerequisites?: ResourceConfig[],
+
+  validatePlan?: (plans: PlanResponseData[]) => Promise<void> | void
+  validateApply?: (plans: PlanResponseData[]) => Promise<void> | void,
+  validateDestroy?: (plans: PlanResponseData[]) => Promise<void> | void,
+  validateImport?: (importResults: (ImportResponseData['result'][0])[]) => Promise<void> | void,
+  testModify?: {
+    modifiedConfigs: ResourceConfig[],
+    validateModify?: (plans: PlanResponseData[]) => Promise<void> | void,
+  }
+}
+
 export class PluginTester {
   static async fullTest(
     pluginPath: string,
     configs: ResourceConfig[],
-    options?: {
-      skipUninstall?: boolean,
-      skipImport?: boolean,
-      validatePlan?: (plans: PlanResponseData[]) => Promise<void> | void
-      validateApply?: (plans: PlanResponseData[]) => Promise<void> | void,
-      validateDestroy?: (plans: PlanResponseData[]) => Promise<void> | void,
-      validateImport?: (importResults: (ImportResponseData['result'][0])[]) => Promise<void> | void,
-      testModify?: {
-        modifiedConfigs: ResourceConfig[],
-        validateModify?: (plans: PlanResponseData[]) => Promise<void> | void,
-      }
-    }): Promise<void> {
+    options?: FullTestOptions,
+  ): Promise<void> {
     configs = configs.filter((c) => !c.os || c.os.includes(getPlatformOs()));
     const ids = configs
       .map((c) => `${c.type}${c.name ? `.${c.name}` : ''}`)
       .join(', ')
     console.info(chalk.cyan(`Starting full test of [ ${ids} ]...`));
 
+    const { skipUninstall = false } = options ?? {}
 
-    const {
-      skipUninstall = false,
-    } = options ?? {}
-
+    if (options?.prerequisites?.length) {
+      await this.ensurePrerequisites(pluginPath, options.prerequisites);
+    }
 
     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)}`)
-      }
-
-      // configs = configs.filter((c) => initializeResult.resourceDefinitions.find((rd) => rd.type === c.type)?.operatingSystems?.includes(os.platform() as OS));
-
-      console.info(chalk.cyan('Testing validate...'))
-      const validate = await plugin.validate({
-        configs: configs.map((c) => {
-          const { coreParameters, parameters } = splitUserConfig(c)
-          return { core: coreParameters, parameters };
-        })
-      });
-
-      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)}`)
-      }
+      await this.initializeAndValidate(plugin, configs);
 
       console.info(chalk.cyan('Testing plan...'))
-      const plans = [];
-      for (const config of configs) {
-        const { coreParameters, parameters } = splitUserConfig(config);
-
-        plans.push(await plugin.plan({
-          core: coreParameters,
-          desired: parameters,
-          isStateful: false,
-          state: undefined,
-        }));
-      }
+      const plans = await this.planConfigs(plugin, configs);
 
       if (options?.validatePlan) {
         await options.validatePlan(plans);
       }
 
       console.info(chalk.cyan('Testing apply...'))
-      for (const plan of plans) {
-        await plugin.apply({
-          planId: plan.planId
-        });
-      }
+      await this.applyPlans(plugin, plans);
 
       if (options?.validateApply) {
         await options.validateApply(plans);
@@ -97,63 +67,11 @@ export class PluginTester {
     }
 
     if (!options?.skipImport) {
-      const importPlugin = new PluginProcess(pluginPath);
-      try {
-        await importPlugin.initialize();
-        console.info(chalk.cyan('Testing import...'))
-
-        const importResults = [];
-        for (const config of configs) {
-          const { coreParameters, parameters } = splitUserConfig(config);
-
-          const importResult = await importPlugin.import({ core: coreParameters, parameters })
-          importResults.push(importResult);
-        }
-
-        if (options?.validateImport) {
-          await options.validateImport(importResults.map((r) => r.result[0]));
-        }
-      } finally {
-        importPlugin.kill();
-      }
+      await this.runImportPhase(pluginPath, configs, options?.validateImport);
     }
 
     if (options?.testModify) {
-      const modifyPlugin = new PluginProcess(pluginPath);
-
-      try {
-        await modifyPlugin.initialize();
-        console.info(chalk.cyan('Testing modify...'))
-
-        const modifyPlans = [];
-        for (const config of options.testModify.modifiedConfigs) {
-          const { coreParameters, parameters } = splitUserConfig(config);
-
-          modifyPlans.push(await modifyPlugin.plan({
-            core: coreParameters,
-            desired: parameters,
-            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: 
-${JSON.stringify(modifyPlans, null, 2)}`)
-        }
-
-        for (const plan of modifyPlans) {
-          await modifyPlugin.apply({
-            planId: plan.planId
-          });
-        }
-
-        if (options.testModify.validateModify) {
-          await options.testModify.validateModify(modifyPlans);
-        }
-      } finally {
-        modifyPlugin.kill();
-      }
+      await this.runModifyPhase(pluginPath, options.testModify);
     }
 
     if (!skipUninstall) {
@@ -172,50 +90,13 @@ ${JSON.stringify(modifyPlans, null, 2)}`)
     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)}`)
-      }
-
-      // configs = configs.filter((c) => initializeResult.resourceDefinitions.find((rd) => rd.type === c.type)?.operatingSystems?.includes(os.platform() as OS));
-
-      console.info(chalk.cyan('Testing validate...'))
-      const validate = await plugin.validate({
-        configs: configs.map((c) => {
-          const { coreParameters, parameters } = splitUserConfig(c)
-          return { core: coreParameters, parameters };
-        })
-      });
-
-      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)}`)
-      }
+      await this.initializeAndValidate(plugin, configs);
 
       console.info(chalk.cyan('Testing plan...'))
-      const plans = [];
-      for (const config of configs) {
-        const { coreParameters, parameters } = splitUserConfig(config);
-
-        plans.push(await plugin.plan({
-          core: coreParameters,
-          desired: parameters,
-          isStateful: false,
-          state: undefined,
-        }));
-      }
+      const plans = await this.planConfigs(plugin, configs);
 
       console.info(chalk.cyan('Testing apply...'))
-      for (const plan of plans) {
-        await plugin.apply({
-          planId: plan.planId
-        });
-      }
+      await this.applyPlans(plugin, plans);
     } finally {
       plugin.kill();
     }
@@ -260,6 +141,166 @@ ${JSON.stringify(modifyPlans, null, 2)}`)
     }
   }
 
+  private static async ensurePrerequisites(pluginPath: string, prerequisites: ResourceConfig[]): Promise<void> {
+    prerequisites = prerequisites.filter((c) => !c.os || c.os.includes(getPlatformOs()));
+    if (prerequisites.length === 0) return;
+
+    const ids = prerequisites.map((c) => `${c.type}${c.name ? `.${c.name}` : ''}`).join(', ');
+    console.info(chalk.cyan(`Checking prerequisites [ ${ids} ]...`));
+
+    const plugin = new PluginProcess(pluginPath);
+    try {
+      const initializeResult = await plugin.initialize();
+
+      const unsupportedConfigs = prerequisites.filter((c) =>
+        !initializeResult.resourceDefinitions.some((rd) => rd.type === c.type)
+      )
+      if (unsupportedConfigs.length > 0) {
+        throw new Error(`The plugin does not support the following prerequisite configs:\n ${JSON.stringify(unsupportedConfigs, null, 2)}`)
+      }
+
+      const validate = await plugin.validate({
+        configs: prerequisites.map((c) => {
+          const { coreParameters, parameters } = splitUserConfig(c)
+          return { core: coreParameters, parameters };
+        })
+      });
+
+      const invalidConfigs = validate.resourceValidations.filter((v) => !v.isValid)
+      if (invalidConfigs.length > 0) {
+        console.error(chalk.red(`Prerequisites validation failed:\n ${JSON.stringify(invalidConfigs, null, 2)}`));
+        throw new Error(`The following prerequisite configs did not validate:\n ${JSON.stringify(invalidConfigs, null, 2)}`)
+      }
+
+      for (const config of prerequisites) {
+        const { coreParameters, parameters } = splitUserConfig(config);
+        const plan = await plugin.plan({
+          core: coreParameters,
+          desired: parameters,
+          isStateful: false,
+          state: undefined,
+        });
+
+        const label = `${config.type}${config.name ? `.${config.name}` : ''}`;
+        if (plan.operation === ResourceOperation.NOOP) {
+          console.info(chalk.cyan(`Prerequisite already satisfied: ${label}`));
+        } else {
+          await plugin.apply({ planId: plan.planId });
+          console.info(chalk.cyan(`Prerequisite installed: ${label}`));
+        }
+      }
+    } finally {
+      plugin.kill();
+    }
+  }
+
+  private static async initializeAndValidate(plugin: PluginProcess, configs: ResourceConfig[]): Promise<void> {
+    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)}`)
+    }
+
+    console.info(chalk.cyan('Testing validate...'))
+    const validate = await plugin.validate({
+      configs: configs.map((c) => {
+        const { coreParameters, parameters } = splitUserConfig(c)
+        return { core: coreParameters, parameters };
+      })
+    });
+
+    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)}`)
+    }
+  }
+
+  private static async planConfigs(plugin: PluginProcess, configs: ResourceConfig[]): Promise<PlanResponseData[]> {
+    const plans = [];
+    for (const config of configs) {
+      const { coreParameters, parameters } = splitUserConfig(config);
+      plans.push(await plugin.plan({
+        core: coreParameters,
+        desired: parameters,
+        isStateful: false,
+        state: undefined,
+      }));
+    }
+
+    return plans;
+  }
+
+  private static async applyPlans(plugin: PluginProcess, plans: PlanResponseData[]): Promise<void> {
+    for (const plan of plans) {
+      await plugin.apply({ planId: plan.planId });
+    }
+  }
+
+  private static async runImportPhase(
+    pluginPath: string,
+    configs: ResourceConfig[],
+    validateImport?: (importResults: (ImportResponseData['result'][0])[]) => Promise<void> | void,
+  ): Promise<void> {
+    const importPlugin = new PluginProcess(pluginPath);
+    try {
+      await importPlugin.initialize();
+      console.info(chalk.cyan('Testing import...'))
+
+      const importResults = [];
+      for (const config of configs) {
+        const { coreParameters, parameters } = splitUserConfig(config);
+        importResults.push(await importPlugin.import({ core: coreParameters, parameters }));
+      }
+
+      if (validateImport) {
+        await validateImport(importResults.map((r) => r.result[0]));
+      }
+    } finally {
+      importPlugin.kill();
+    }
+  }
+
+  private static async runModifyPhase(
+    pluginPath: string,
+    testModify: { modifiedConfigs: ResourceConfig[], validateModify?: (plans: PlanResponseData[]) => Promise<void> | void },
+  ): Promise<void> {
+    const modifyPlugin = new PluginProcess(pluginPath);
+
+    try {
+      await modifyPlugin.initialize();
+      console.info(chalk.cyan('Testing modify...'))
+
+      const modifyPlans = [];
+      for (const config of testModify.modifiedConfigs) {
+        const { coreParameters, parameters } = splitUserConfig(config);
+
+        modifyPlans.push(await modifyPlugin.plan({
+          core: coreParameters,
+          desired: parameters,
+          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:
+${JSON.stringify(modifyPlans, null, 2)}`)
+      }
+
+      await this.applyPlans(modifyPlugin, modifyPlans);
+
+      if (testModify.validateModify) {
+        await testModify.validateModify(modifyPlans);
+      }
+    } finally {
+      modifyPlugin.kill();
+    }
+  }
+
   private static addNamesToConfigs(configs: ResourceConfig[]): ResourceConfig[] {
     const configsWithNames = new Array<ResourceConfig>();
 
