Fixed import bugs by making import use refresh() instead of a custom eqs method

Author: kevinwang5658

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-test",
-  "version": "0.0.18",
+  "version": "0.0.22",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -15,20 +15,24 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
-    "codify-schemas": "1.0.52"
+    "codify-schemas": "1.0.52",
+    "lodash.matches": "^4.6.0",
+    "lodash.differencewith": "4.5.0"
   },
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",
     "@types/debug": "^4.1.12",
     "@types/node": "^18",
+    "@types/lodash.matches": "^4.6.9",
+    "@types/lodash.differencewith": "^4.5.9",
     "eslint": "^8.51.0",
     "eslint-config-oclif": "^5",
     "eslint-config-oclif-typescript": "^3",
     "eslint-config-prettier": "^9.0.0",
     "tsx": "^4.7.3",
     "typescript": "^5",
     "vitest": "^1.4.0",
-    "codify-plugin-lib": "1.0.76"
+    "codify-plugin-lib": "1.0.106"
   },
   "engines": {
     "node": ">=18.0.0"

src/plugin-tester.ts

@@ -42,9 +42,6 @@ export class PluginTester {
       throw new Error('A fully qualified path must be supplied to PluginTester');
     }
 
-    console.log('Node Inspector:')
-    console.log(inspector.url());
-
     this.childProcess = fork(
       pluginPath,
       [],
@@ -134,9 +131,8 @@ ${JSON.stringify(unsuccessfulPlans, null, 2)}`
       const importResult = await this.import({ config })
       importResults.push(importResult);
 
-      if (importResult.result.length !== 1 ||
-        Object.entries(config).some(([k, v]) => importResult.result[0][k] !== v)
-      ) {
+      const validationPlan = await this.plan({ desired: importResult.result[0], isStateful: false, state: undefined });
+      if (validationPlan.operation !== ResourceOperation.NOOP) {
         unsuccessfulImports.push(importResult);
       }
     }

test/plugin-tester.test.ts

@@ -2,6 +2,9 @@ import { describe, expect, it } from 'vitest';
 import { PluginTester } from '../src/index.js';
 import path from 'node:path';
 import { ResourceOperation } from 'codify-schemas/src/types/index.js';
+import deepMatches from 'lodash.matches';
+import differenceWith from 'lodash.differencewith';
+
 
 describe('Plugin tester integration tests', () => {
   it('Can instantiate a plugin', async () => {
@@ -122,7 +125,9 @@ describe('Plugin tester integration tests', () => {
       propA: 'a',
       propB: 10,
       propC: 'c',
-    }]);
+    }], {
+      skipUninstall: true,
+    });
   })
 
   it('Full test supports plan assertions to ensure the generated plan is correct', async () => {
@@ -139,19 +144,57 @@ describe('Plugin tester integration tests', () => {
       propA: 'a',
       propB: 10,
       propC: 'c',
-    }], false, (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',
-      });
-    });
+    }], {
+      skipUninstall: true,
+      validatePlan: (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('Full test supports plan assertions to ensure the generated plan is correct (2)', 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,
+    }], {
+      skipUninstall: true,
+      validatePlan: (plans) => {
+        expect(plans[0]).toMatchObject({
+          planId: expect.any(String),
+          operation: ResourceOperation.NOOP,
+          resourceType: 'test',
+        });
+      }
+    })
+  })
+
+  it('Full test supports plan assertions to ensure the generated plan is correct (3)', async () => {
+    const plugin = new PluginTester(path.join(__dirname, './test-plugin.ts'));
+
+    console.log(differenceWith(['b', 'a'], ['a', 'b', 'c'], (a, b) => deepMatches(a)(b)).length === 0);
+
+    // No expect needed here. This passes if it doesn't throw.
+    await plugin.fullTest([{
+      type: 'test2',
+      propB: ['second', 'first'],
+      propA: 'a',
+    }], {
+      skipUninstall: true,
+    })
   })
 
   it('Has helpers that can uninstall a resource', async () => {
@@ -177,4 +220,6 @@ describe('Plugin tester integration tests', () => {
       propC: 'c',
     }])).rejects.toThrowError();
   })
+
+
 })

test/test-plugin.ts

@@ -1,4 +1,4 @@
-import { Plugin, Resource, runPlugin } from 'codify-plugin-lib';
+import { CreatePlan, DestroyPlan, Plugin, Resource, ResourceSettings, runPlugin } from 'codify-plugin-lib';
 import { StringIndexedObject } from 'codify-schemas';
 
 export interface TestConfig extends StringIndexedObject {
@@ -7,16 +7,18 @@ export interface TestConfig extends StringIndexedObject {
   propC: string;
 }
 
-export class TestResource extends Resource<TestConfig> {
-  constructor() {
-    super({
-      type: 'test'
-    });
-  }
+export interface TestConfig2 extends StringIndexedObject {
+  propA: string;
+  propB: string[];
+}
 
-  async applyCreate(): Promise<void> {}
 
-  async applyDestroy(): Promise<void> {}
+export class TestResource extends Resource<TestConfig> {
+  getSettings(): ResourceSettings<TestConfig> {
+    return {
+      id: 'test'
+    };
+  }
 
   async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
     if (parameters.propD) {
@@ -29,34 +31,71 @@ export class TestResource extends Resource<TestConfig> {
       propC: 'c',
     };
   }
+
+  async create(plan: CreatePlan<TestConfig>): Promise<void> {
+  }
+
+  async destroy(plan: DestroyPlan<TestConfig>): Promise<void> {
+  }
 }
 
-export class TestUninstallResource extends Resource<TestConfig> {
-  constructor() {
-    super({
-      type: 'test-uninstall'
-    });
+export class TestResource2 extends Resource<TestConfig2> {
+  getSettings(): ResourceSettings<TestConfig2> {
+    return {
+      id: 'test2',
+      parameterSettings: {
+        propB: { type: 'array' }
+      }
+    };
   }
 
-  async applyCreate(): Promise<void> {}
+  async refresh(parameters: Partial<TestConfig2>): Promise<Partial<TestConfig2> | null> {
+    if (parameters.propD) {
+      throw new Error('Prop D is included');
+    }
 
-  async applyDestroy(): Promise<void> {}
+    return {
+      propA: 'a',
+      propB: ['first', 'second', 'third']
+    };
+  }
 
-  async refresh(): Promise<Partial<TestConfig> | null> {
-    return null;
+  async create(plan: CreatePlan<TestConfig2>): Promise<void> {
+  }
+
+  async destroy(plan: DestroyPlan<TestConfig2>): Promise<void> {
   }
 }
 
-function buildPlugin(): Plugin {
-  const resourceMap = new Map();
+export class TestUninstallResource extends Resource<TestConfig> {
+  first = true;
+  getSettings(): ResourceSettings<TestConfig> {
+    return {
+      id: 'test-uninstall'
+    }
+  }
+
+  async create(plan: CreatePlan<TestConfig>): Promise<void> {
+  }
 
-  const testResource = new TestResource();
-  resourceMap.set(testResource.typeId, testResource);
+  async destroy(plan: DestroyPlan<TestConfig>): Promise<void> {
+  }
 
-  const testUninstallResource = new TestUninstallResource();
-  resourceMap.set(testUninstallResource.typeId, testUninstallResource);
+  async refresh(parameters: Partial<TestConfig>): Promise<Array<Partial<TestConfig>> | Partial<TestConfig> | null> {
+    if (this.first) {
+      this.first = false;
+      return parameters;
+    }
 
-  return new Plugin('test', resourceMap);
+    return null;
+  }
 }
 
-runPlugin(buildPlugin());
+runPlugin(Plugin.create(
+  'default',
+  [
+    new TestResource(),
+    new TestResource2(),
+    new TestUninstallResource()
+  ]
+));