codify-plugin-lib 1.0.36 → 1.0.38

package/src/entities/resource.test.ts

@@ -1,63 +1,54 @@
 import { Resource } from './resource.js';
-import { ParameterOperation, ResourceConfig, ResourceOperation } from 'codify-schemas';
-import { ChangeSet, ParameterChange } from './change-set.js';
+import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { ParameterChange } from './change-set.js';
 import { spy } from 'sinon';
 import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { describe, expect, it } from 'vitest'
+import { ResourceConfiguration } from './resource-types.js';
 
-class TestResource extends Resource<TestConfig> {
-  applyCreate(plan: Plan<TestConfig>): Promise<void> {
-    return Promise.resolve(undefined);
-  }
+interface TestConfig extends StringIndexedObject {
+  propA: string;
+  propB: number;
+  propC?: string;
+}
 
-  applyDestroy(plan: Plan<TestConfig>): Promise<void> {
-    return Promise.resolve(undefined);
+class TestResource extends Resource<TestConfig> {
+  constructor(options: ResourceConfiguration<TestConfig>) {
+    super(options);
   }
 
-  applyModify(plan: Plan<TestConfig>): Promise<void> {
+  applyCreate(plan: Plan<TestConfig>): Promise<void> {
     return Promise.resolve(undefined);
   }
 
-  applyRecreate(plan: Plan<TestConfig>): Promise<void> {
+  applyDestroy(plan: Plan<TestConfig>): Promise<void> {
     return Promise.resolve(undefined);
   }
 
-  calculateOperation(change: ParameterChange): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
-    return ResourceOperation.MODIFY;
-  }
-
-  async getCurrentConfig(): Promise<TestConfig | null> {
-    return null;
+  async refresh(): Promise<Partial<TestConfig> | null> {
+    return {
+      propA: 'a',
+      propB: 10,
+      propC: 'c',
+    };
   }
 
-  async validate(config: ResourceConfig): Promise<string | undefined> {
+  async validate(config: unknown): Promise<string[] | undefined> {
     return undefined;
   }
-
-  getTypeId(): string {
-    return '';
-  }
-}
-
-interface TestConfig extends ResourceConfig {
-  propA: string;
-  propB: number;
-  propC?: string;
 }
 
 describe('Resource tests', () => {
   it('plans correctly', async () => {
     const resource = new class extends TestResource {
-      calculateOperation(change: ParameterChange): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
-        return ResourceOperation.MODIFY;
+      constructor() {
+        super({ type: 'type' });
       }
 
-      async getCurrentConfig(): Promise<TestConfig> {
+      async refresh(): Promise<TestConfig> {
         return {
-          type: 'type',
-          name: 'name',
-          propA: "propABefore",
+          propA: 'propABefore',
           propB: 10,
         };
       }
@@ -71,20 +62,20 @@ describe('Resource tests', () => {
       propB: 10,
     })
 
-    expect(result.resourceConfig).to.deep.eq({
+    expect(result.desiredConfig).to.deep.eq({
       type: 'type',
       name: 'name',
       propA: 'propA',
       propB: 10,
     });
-    expect(result.changeSet.operation).to.eq(ResourceOperation.MODIFY);
+    expect(result.changeSet.operation).to.eq(ResourceOperation.RECREATE);
     expect(result.changeSet.parameterChanges[0]).to.deep.eq({
       name: 'propA',
       previousValue: 'propABefore',
       newValue: 'propA',
       operation: 'modify'
     })
-    expect(result.changeSet.parameterChanges[1]).to.deep.eq(  {
+    expect(result.changeSet.parameterChanges[1]).to.deep.eq({
       name: 'propB',
       previousValue: 10,
       newValue: 10,
@@ -92,42 +83,17 @@ describe('Resource tests', () => {
     })
   })
 
-  it('calls calculateOperation for only modifications and recreates', async () => {
+  it('creates the resource if it doesnt exist', async () => {
     const resource = new class extends TestResource {
-      calculateOperation(change: ParameterChange): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
-        return ResourceOperation.MODIFY;
-      }
-
-      async getCurrentConfig(): Promise<TestConfig> {
-        return {
-          type: 'type',
-          name: 'name',
-          propA: "propABefore",
-          propB: 10,
-          propC: 'somethingBefore'
-        };
+      constructor() {
+        super({ type: 'type' });
       }
-    }
 
-    const resourceSpy = spy(resource);
-    await resourceSpy.plan({
-      type: 'type',
-      name: 'name',
-      propA: 'propA',
-      propB: 10,
-      propC: 'somethingAfter'
-    })
-
-    expect(resourceSpy.calculateOperation.calledTwice).to.be.true;
-  })
-
-  it('creates the resource if it doesnt exist', async () => {
-    const resource = new class extends TestResource {
-      calculateOperation(change: ParameterChange): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
+      calculateOperation(change: ParameterChange<TestConfig>): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
         return ResourceOperation.MODIFY;
       }
 
-      async getCurrentConfig(): Promise<TestConfig | null> {
+      async refresh(): Promise<TestConfig | null> {
         return null;
       }
     }
@@ -147,16 +113,17 @@ describe('Resource tests', () => {
 
   it('chooses the create apply properly', async () => {
     const resource = new class extends TestResource {
-      getTypeId(): string {
-        return 'resource'
+      constructor() {
+        super({ type: 'resource' });
       }
     }
 
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
-      Plan.create(
-        new ChangeSet(ResourceOperation.CREATE, []),
-        { type: 'resource', propA: 'a', propB: 0 }
+      Plan.create<TestConfig>(
+        { type: 'resource', propA: 'a', propB: 0 },
+        { type: 'resource' },
+        { statefulMode: false },
       )
     )
 
@@ -165,72 +132,88 @@ describe('Resource tests', () => {
 
   it('chooses the destroy apply properly', async () => {
     const resource = new class extends TestResource {
-      getTypeId(): string {
-        return 'resource'
+      constructor() {
+        super({ type: 'resource' });
       }
     }
 
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
-      Plan.create(
-        new ChangeSet(ResourceOperation.DESTROY, []),
-        { type: 'resource', propA: 'a', propB: 0 }
+      Plan.create<TestConfig>(
+        { type: 'resource' },
+        { type: 'resource', propA: 'a', propB: 0 },
+        { statefulMode: true },
       )
     )
 
     expect(resourceSpy.applyDestroy.calledOnce).to.be.true;
   })
 
-  it('calls apply modify', async () => {
+  it('Defaults parameter changes to recreate', async () => {
     const resource = new class extends TestResource {
-      getTypeId(): string {
-        return 'resource'
+      constructor() {
+        super({ type: 'resource' });
       }
     }
 
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
-      Plan.create(
-        new ChangeSet(ResourceOperation.MODIFY, [
-          {
-            name: 'propA',
-            newValue: 'a',
-            previousValue: 'b',
-            operation: ParameterOperation.ADD,
-          },
-          {
-            name: 'propB',
-            newValue: 0,
-            previousValue: -1,
-            operation: ParameterOperation.ADD,
-          },
-        ]),
-        { type: 'resource', propA: 'a', propB: 0 }
+      Plan.create<TestConfig>(
+        { type: 'resource', propA: 'a', propB: 0 },
+        { type: 'resource', propA: 'b', propB: -1 },
+        { statefulMode: true },
       )
     );
 
-    expect(resourceSpy.applyModify.calledOnce).to.be.true;
+    expect(resourceSpy.applyDestroy.calledOnce).to.be.true;
+    expect(resourceSpy.applyCreate.calledOnce).to.be.true;
   })
 
-  it('supports the creation of stateful parameters', async () => {
-    const statefulParameter = new class implements StatefulParameter<TestConfig, 'propA'> {
-      get name(): "propA" {
-        return 'propA';
+  it('Allows modification of parameter behavior to allow modify for parameters', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          parameterConfigurations: {
+            propA: { planOperation: ResourceOperation.MODIFY },
+            propB: { planOperation: ResourceOperation.MODIFY },
+          }
+        });
       }
 
-      applyAdd(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
+      async refresh(): Promise<TestConfig | null> {
+        return { propA: 'b', propB: -1 };
       }
+    }
 
-      applyModify(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
-      }
+    const plan = await resource.plan({ type: 'resource', propA: 'a', propB: 0 })
 
-      applyRemove(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.apply(
+      plan
+    );
+
+    expect(resourceSpy.applyModify.calledTwice).to.be.true;
+  })
+
+  it('supports the creation of stateful parameters', async () => {
+    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
+      constructor() {
+        super({
+          name: 'propA',
+        })
       }
 
-      async getCurrent(): Promise<TestConfig["propA"]> {
+      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
+      }
+      applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
+      }
+      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
+      }
+      async refresh(): Promise<string | null> {
         return '';
       }
     }
@@ -240,39 +223,19 @@ describe('Resource tests', () => {
     const resource = new class extends TestResource {
 
       constructor() {
-        super();
-        this.registerStatefulParameter(statefulParameterSpy)
-      }
-
-      getTypeId(): string {
-        return 'resource'
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+        });
       }
     }
 
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
-      Plan.create(
-        new ChangeSet(ResourceOperation.CREATE, [
-          {
-            name: 'propA',
-            newValue: 'a',
-            previousValue: null,
-            operation: ParameterOperation.ADD,
-          },
-          {
-            name: 'propB',
-            newValue: 0,
-            previousValue: null,
-            operation: ParameterOperation.ADD,
-          },
-          {
-            name: 'propC',
-            newValue: 'b',
-            previousValue: null,
-            operation: ParameterOperation.ADD,
-          },
-        ]),
-        { type: 'resource', propA: 'a', propB: 0, propC: 'b' }
+      Plan.create<TestConfig>(
+        { type: 'resource', propA: 'a', propB: 0, propC: 'b' },
+        null,
+        { statefulMode: false },
       )
     );
 
@@ -281,25 +244,24 @@ describe('Resource tests', () => {
   })
 
   it('supports the modification of stateful parameters', async () => {
-    const statefulParameter = new class implements StatefulParameter<TestConfig, 'propA'> {
-      get name(): "propA" {
-        return 'propA';
+    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
+      constructor() {
+        super({
+          name: 'propA',
+        })
       }
 
-      applyAdd(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
+      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
       }
-
-      applyModify(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
+      applyModify(newValue: string, previousValue: string, allowDeletes: false, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
       }
-
-      applyRemove(parameterChange: ParameterChange, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve(undefined);
+      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+        return Promise.resolve();
       }
-
-      async getCurrent(): Promise<TestConfig["propA"]> {
-        return '';
+      async refresh(): Promise<string | null> {
+        return 'b';
       }
     }
 
@@ -308,41 +270,24 @@ describe('Resource tests', () => {
     const resource = new class extends TestResource {
 
       constructor() {
-        super();
-        this.registerStatefulParameter(statefulParameterSpy)
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+          parameterConfigurations: {
+            propB: { planOperation: ResourceOperation.MODIFY },
+          }
+        });
       }
 
-      getTypeId(): string {
-        return 'resource'
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return { propB: -1, propC: 'b' }
       }
     }
 
+    const plan = await resource.plan({ type: 'resource', propA: 'a', propB: 0, propC: 'b' })
+
     const resourceSpy = spy(resource);
-    const result = await resourceSpy.apply(
-      Plan.create(
-        new ChangeSet(ResourceOperation.MODIFY, [
-          {
-            name: 'propA',
-            newValue: 'a',
-            previousValue: 'b',
-            operation: ParameterOperation.MODIFY,
-          },
-          {
-            name: 'propB',
-            newValue: 0,
-            previousValue: null,
-            operation: ParameterOperation.ADD,
-          },
-          {
-            name: 'propC',
-            newValue: 'b',
-            previousValue: 'b',
-            operation: ParameterOperation.NOOP,
-          },
-        ]),
-        { type: 'resource', propA: 'a', propB: 0, propC: 'b' }
-      )
-    );
+    const result = await resourceSpy.apply(plan);
 
     expect(statefulParameterSpy.applyModify.calledOnce).to.be.true;
     expect(resourceSpy.applyModify.calledOnce).to.be.true;