Added planAssertion to full test so that plans can be asserted during tests. Added tests.

Author: kevinwang5658

src/plugin-tester.ts

@@ -15,10 +15,10 @@ import {
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';
-import { ChildProcess, fork, spawn, SpawnOptions } from 'node:child_process';
+import { ChildProcess, SpawnOptions, fork, spawn } from 'node:child_process';
+import path from 'node:path';
 
 import { CodifyTestUtils } from './test-utils.js';
-import path from 'node:path';
 
 const ajv = new Ajv2020.default({
   strict: true
@@ -53,7 +53,7 @@ export class PluginTester {
     this.handleSudoRequests(this.childProcess);
   }
 
-  async fullTest(configs: ResourceConfig[]): Promise<void> {
+  async fullTest(configs: ResourceConfig[], assertPlans?: (plans: PlanResponseData[]) => void): Promise<void> {
     const initializeResult = await this.initialize();
 
     const unsupportedConfigs = configs.filter((c)  =>
@@ -75,6 +75,10 @@ export class PluginTester {
       plans.push(await this.plan(config));
     }
 
+    if (assertPlans) {
+      assertPlans(plans);
+    }
+
     for (const plan of plans) {
       await this.apply({
         planId: plan.planId
@@ -97,25 +101,25 @@ ${JSON.stringify(unsuccessfulPlans, null, 2)}`
 
   async uninstall(configs: ResourceConfig[]) {
     for (const config of configs) {
-      const { type, dependsOn, name, ...parameters } = config
+      const { dependsOn, name, type, ...parameters } = config
 
       await this.apply({
         plan: {
           operation: ResourceOperation.DESTROY,
-          resourceType: config.type,
           parameters: Object.entries(parameters).map(([key, value]) => ({
             name: key,
-            previousValue: value,
             newValue: null,
             operation: ParameterOperation.REMOVE,
+            previousValue: value,
           })),
+          resourceType: type,
         }
       });
 
       // Validate that the destroy was successful
       const validationPlan = await this.plan(config);
       if (validationPlan.operation !== ResourceOperation.CREATE) {
-        throw new Error(`Resource ${config.type} was not successfully destroyed.
+        throw new Error(`Resource ${type} was not successfully destroyed.
 Validation plan shows:
 ${JSON.stringify(validationPlan, null, 2)}
 Previous config:
@@ -190,8 +194,6 @@ type CodifySpawnOptions = {
  *
  * @param cmd Command to run. Ex: `rm -rf`
  * @param opts Options for spawn
- * @param secureMode Secure mode for sudo
- * @param pluginName Optional plugin name so that stdout and stderr can be piped
  *
  * @see promiseSpawn
  * @see spawn

test/plugin-tester.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { PluginTester } from '../src/plugin-tester.js';
+import { PluginTester } from '../src/index.js';
 import path from 'node:path';
 import { ResourceOperation } from 'codify-schemas/src/types/index.js';
-import { ParameterOperation } from 'codify-schemas';
 
 describe('Plugin tester integration tests', () => {
   it('Can instantiate a plugin', async () => {
@@ -13,7 +12,7 @@ describe('Plugin tester integration tests', () => {
     expect(plugin.childProcess.stderr).to.not.be.undefined;
     expect(plugin.childProcess.channel).to.not.be.undefined;
 
-    await plugin.initialize({});
+    await plugin.initialize();
   })
 
   it('Can validate a config', async () => {
@@ -110,6 +109,35 @@ describe('Plugin tester integration tests', () => {
     }]);
   })
 
+  it('Full test supports plan assertions to ensure the generated plan is correct', async () => {
+    const plugin = new PluginTester(path.join(__dirname, './test-plugin.ts'));
+
+    // No expect needed here. This passes if it doesn't throw.
+    await plugin.fullTest([{
+      type: 'test',
+      propA: 'a',
+      propB: 10,
+      propC: 'c',
+    }, {
+      type: 'test',
+      propA: 'a',
+      propB: 10,
+      propC: 'c',
+    }], (plans) => {
+      expect(plans[0]).toMatchObject({
+        planId: expect.any(String),
+        operation: ResourceOperation.NOOP,
+        resourceType: 'test',
+      });
+
+      expect(plans[1]).toMatchObject({
+        planId: expect.any(String),
+        operation: ResourceOperation.NOOP,
+        resourceType: 'test',
+      });
+    });
+  })
+
   it('Has helpers that can uninstall a resource', async () => {
     const plugin = new PluginTester(path.join(__dirname, './test-plugin.ts'));