codify-plugin-lib 1.0.71 → 1.0.72

package/dist/entities/plugin.js

@@ -31,17 +31,15 @@ export class Plugin {
             if (!this.resources.has(config.type)) {
                 throw new Error(`Resource type not found: ${config.type}`);
             }
-            const { parameters } = splitUserConfig(config);
-            const validateResult = await this.resources.get(config.type).validateResource(parameters);
-            validationResults.push({
-                ...validateResult,
-                resourceType: config.type,
-                resourceName: config.name,
-            });
+            const { parameters, resourceMetadata } = splitUserConfig(config);
+            const validation = await this.resources
+                .get(config.type)
+                .validate(parameters, resourceMetadata);
+            validationResults.push(validation);
         }
         await this.crossValidateResources(data.configs);
         return {
-            validationResults
+            resourceValidations: validationResults
         };
     }
     async plan(data) {

package/dist/entities/resource-types.d.ts

@@ -9,7 +9,3 @@ export interface ResourceDefinition {
         type: string;
     };
 }
-export interface ValidationResult {
-    isValid: boolean;
-    errors?: unknown[];
-}

package/dist/entities/resource.d.ts

@@ -1,11 +1,11 @@
 import Ajv from 'ajv';
 import { ValidateFunction } from 'ajv/dist/2020.js';
-import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
 import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
 import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
 import { ResourceOptions } from './resource-options.js';
-import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
+import { ResourceParameterOptions } from './resource-types.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { TransformParameter } from './transform-parameter.js';
 export declare abstract class Resource<T extends StringIndexedObject> {
@@ -23,7 +23,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     protected schemaValidator?: ValidateFunction;
     protected constructor(options: ResourceOptions<T>);
     onInitialize(): Promise<void>;
-    validateResource(parameters: Partial<T>): Promise<ValidationResult>;
+    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
     plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private _applyCreate;
@@ -35,7 +35,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private refreshNonStatefulParameters;
     private refreshStatefulParameters;
     private validatePlanInputs;
-    validate(parameters: Partial<T>): Promise<ValidationResult>;
+    customValidation(parameters: Partial<T>): Promise<void>;
     abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
     applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -37,17 +37,42 @@ export class Resource {
         this.transformParameterOrder = parser.transformParameterOrder;
     }
     async onInitialize() { }
-    async validateResource(parameters) {
+    async validate(parameters, resourceMetaData) {
         if (this.schemaValidator) {
             const isValid = this.schemaValidator(parameters);
             if (!isValid) {
                 return {
-                    errors: this.schemaValidator?.errors ?? [],
+                    resourceType: resourceMetaData.type,
+                    resourceName: resourceMetaData.name,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
                     isValid: false,
                 };
             }
         }
-        return this.validate(parameters);
+        let isValid = true;
+        let customValidationErrorMessage = undefined;
+        try {
+            await this.customValidation(parameters);
+        }
+        catch (err) {
+            isValid = false;
+            customValidationErrorMessage = err.message;
+        }
+        if (!isValid) {
+            return {
+                resourceType: resourceMetaData.type,
+                resourceName: resourceMetaData.name,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                customValidationErrorMessage,
+                isValid: false,
+            };
+        }
+        return {
+            resourceType: resourceMetaData.type,
+            resourceName: resourceMetaData.name,
+            schemaValidationErrors: [],
+            isValid: true,
+        };
     }
     async plan(desiredConfig, currentConfig = null, statefulMode = false) {
         this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
@@ -221,11 +246,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
             throw new Error('Desired config must be provided in non-stateful mode');
         }
     }
-    async validate(parameters) {
-        return {
-            isValid: true,
-        };
-    }
+    async customValidation(parameters) { }
     ;
     async applyModify(pc, plan) { }
     ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.71",
+  "version": "1.0.72",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.39",
+    "codify-schemas": "1.0.42",
     "@npmcli/promise-spawn": "^7.0.1"
   },
   "devDependencies": {

package/src/entities/plugin.test.ts

@@ -3,8 +3,7 @@ import { Plugin } from './plugin.js';
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 import { Resource } from './resource.js';
 import { Plan } from './plan.js';
-import { ValidationResult } from './resource-types.js';
-import { ApplyValidationError } from './errors.js';
+import { spy } from 'sinon';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -27,36 +26,19 @@ class TestResource extends Resource<TestConfig> {
     return Promise.resolve(undefined);
   }
 
-  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+  async refresh(): Promise<Partial<TestConfig> | null> {
     return {
       propA: 'a',
       propB: 10,
       propC: 'c',
     };
   }
-
-  async validateResource(config: unknown): Promise<ValidationResult> {
-    return {
-      isValid: true
-    }
-  }
 }
 
 describe('Plugin tests', () => {
-  it('Validates that applies were successfully applied', async () => {
-    const resource= new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      // Refresh has to line up with desired for the apply to go through
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return {
-          propA: 'abc'
-        }
-      }
-    }
-
-    const plugin = Plugin.create('testPlugin', [resource])
+  it('Can apply resource', async () => {
+    const resource= spy(new TestResource())
+    const plugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.CREATE,
@@ -66,45 +48,13 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await plugin.apply({ plan });
+    expect(resource.applyCreate.calledOnce).to.be.true;
   });
 
-  it('Validates that applies were successfully applied (error)', async () => {
-    const resource = new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      // Return null to indicate that the resource was not created
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return null;
-      }
-    }
-    const plugin = Plugin.create('testPlugin', [resource])
-
-    const plan = {
-      operation: ResourceOperation.CREATE,
-      resourceType: 'testResource',
-      parameters: [
-        { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
-      ]
-    };
-
-    await expect(async () => plugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
-  });
-
-  it('Validates that deletes were successfully applied', async () => {
-    const resource = new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      // Return null to indicate that the resource was deleted
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return null;
-      }
-    }
-
-    const testPlugin = Plugin.create('testPlugin', [resource])
+  it('Can destroy resource', async () => {
+    const resource = spy(new TestResource());
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.DESTROY,
@@ -114,46 +64,13 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await testPlugin.apply({ plan })
+    expect(resource.applyDestroy.calledOnce).to.be.true;
   });
 
-  it('Validates that deletes were successfully applied (error)', async () => {
-    const resource = new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      // Return a value to indicate that the resource still exists
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return { propA: 'abc' };
-      }
-    }
-
-    const testPlugin = Plugin.create('testPlugin', [resource])
-
-    const plan = {
-      operation: ResourceOperation.DESTROY,
-      resourceType: 'testResource',
-      parameters: [
-        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
-      ]
-    };
-
-    // If this doesn't throw then it passes the test
-    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
-  });
-
-  it('Validates that re-create was successfully applied', async () => {
-    const resource = new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return { propA: 'def'};
-      }
-    }
-
-    const testPlugin = Plugin.create('testPlugin', [resource])
+  it('Can re-create resource', async () => {
+    const resource = spy(new TestResource())
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.RECREATE,
@@ -163,31 +80,24 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await testPlugin.apply({ plan })
+    expect(resource.applyDestroy.calledOnce).to.be.true;
+    expect(resource.applyCreate.calledOnce).to.be.true;
   });
 
-  it('Validates that modify was successfully applied (error)', async () => {
-    const resource = new class extends TestResource {
-      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
-      }
-
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        return { propA: 'abc' };
-      }
-    }
-
-    const testPlugin = Plugin.create('testPlugin', [resource])
+  it('Can modify resource', async () => {
+    const resource = spy(new TestResource())
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
-      operation: ResourceOperation.DESTROY,
+      operation: ResourceOperation.MODIFY,
       resourceType: 'testResource',
       parameters: [
-        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: 'def', previousValue: 'abc' },
+        { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
       ]
     };
 
-    // If this doesn't throw then it passes the test
-    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+    await testPlugin.apply({ plan })
+    expect(resource.applyModify.calledOnce).to.be.true;
   });
 });

package/src/entities/plugin.ts

@@ -50,19 +50,17 @@ export class Plugin {
         throw new Error(`Resource type not found: ${config.type}`);
       }
 
-      const { parameters } = splitUserConfig(config);
-      const validateResult = await this.resources.get(config.type)!.validateResource(parameters);
-
-      validationResults.push({
-        ...validateResult,
-        resourceType: config.type,
-        resourceName: config.name,
-      });
+      const { parameters, resourceMetadata } = splitUserConfig(config);
+      const validation = await this.resources
+        .get(config.type)!
+        .validate(parameters, resourceMetadata);
+
+      validationResults.push(validation);
     }
 
     await this.crossValidateResources(data.configs);
     return {
-      validationResults
+      resourceValidations: validationResults
     };
   }
 

package/src/entities/resource-parameters.test.ts

@@ -471,9 +471,9 @@ describe('Resource parameter tests', () => {
     const plan = await resource.plan({ type: 'resourceType', propC: 'abc' } as any);
 
     expect(resource.refresh.called).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propC')).to.be.false;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propC']).to.not.exist;
 
     expect(plan.desiredConfig?.propA).to.eq('propA');
     expect(plan.desiredConfig?.propB).to.eq(10);
@@ -513,8 +513,8 @@ describe('Resource parameter tests', () => {
     const plan = await resource.plan({ type: 'resourceType', propA: 'propA', propB: 10 } as any);
 
     expect(transformParameter.transform.called).to.be.false;
-    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })

package/src/entities/resource-stateful-mode.test.ts

@@ -12,7 +12,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propADifferent',
           propB: undefined,
@@ -61,7 +61,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return null;
       }
     }
@@ -113,7 +113,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propA',
           propC: 'propC',
@@ -184,7 +184,7 @@ describe('Resource tests for stateful plans', () => {
         });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propA',
           propC: 'propC',

package/src/entities/resource-types.ts

@@ -29,8 +29,3 @@ export interface ResourceDefinition {
     type: string;
   }
 }
-
-export interface ValidationResult {
-  isValid: boolean;
-  errors?: unknown[],
-}

package/src/entities/resource.test.ts

@@ -3,7 +3,6 @@ import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
 import { spy } from 'sinon';
 import { Plan } from './plan.js';
 import { describe, expect, it } from 'vitest'
-import { ValidationResult } from './resource-types.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceOptions } from './resource-options.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from './plan-types.js';
@@ -28,19 +27,13 @@ export class TestResource extends Resource<TestConfig> {
     return Promise.resolve(undefined);
   }
 
-  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+  async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
     return {
       propA: 'a',
       propB: 10,
       propC: 'c',
     };
   }
-
-  async validateResource(config: unknown): Promise<ValidationResult> {
-    return {
-      isValid: true
-    }
-  }
 }
 
 describe('Resource tests', () => {
@@ -298,9 +291,8 @@ describe('Resource tests', () => {
       }
 
       // @ts-ignore
-      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
-        expect(desired.has('propA')).to.be.true;
-        expect(desired.get('propA')).to.be.eq('propADefault');
+      async refresh(desired: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(desired['propA']).to.be.eq('propADefault');
 
         return {
           propA: 'propAAfter'
@@ -325,11 +317,11 @@ describe('Resource tests', () => {
         });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        expect(keys.has('propE')).to.be.true;
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        expect(parameters['propE']).to.exist;
 
         return {
-          propE: keys.get('propE'),
+          propE: parameters['propE'],
         };
       }
     }
@@ -374,9 +366,8 @@ describe('Resource tests', () => {
       }
 
       // @ts-ignore
-      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
-        expect(desired.has('propA')).to.be.true;
-        expect(desired.get('propA')).to.be.eq('propA');
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(parameters['propA']).to.be.eq('propA');
 
         return {
           propA: 'propAAfter'
@@ -413,7 +404,7 @@ describe('Resource tests', () => {
         super({ type: 'type' });
       }
 
-      async refresh(values: Map<keyof TestConfig, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return null;
       }
 

package/src/entities/resource.ts

@@ -1,13 +1,19 @@
 import Ajv from 'ajv';
 import Ajv2020, { ValidateFunction } from 'ajv/dist/2020.js';
-import { ParameterOperation, ResourceConfig, ResourceOperation, StringIndexedObject, } from 'codify-schemas';
+import {
+  ParameterOperation,
+  ResourceConfig,
+  ResourceOperation,
+  StringIndexedObject,
+  ValidateResponseData,
+} from 'codify-schemas';
 
 import { setsEqual, splitUserConfig } from '../utils/utils.js';
 import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
 import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions, PlanOptions } from './plan-types.js';
 import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
-import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
+import { ResourceParameterOptions } from './resource-types.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { TransformParameter } from './transform-parameter.js';
 
@@ -60,19 +66,48 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   async onInitialize(): Promise<void> {}
 
-  async validateResource(parameters: Partial<T>): Promise<ValidationResult> {
+  async validate(
+    parameters: Partial<T>,
+    resourceMetaData: ResourceConfig
+  ): Promise<ValidateResponseData['resourceValidations'][0]> {
     if (this.schemaValidator) {
       const isValid = this.schemaValidator(parameters);
 
       if (!isValid) {
         return {
-          errors: this.schemaValidator?.errors ?? [],
+          resourceType: resourceMetaData.type,
+          resourceName: resourceMetaData.name,
+          schemaValidationErrors: this.schemaValidator?.errors ?? [],
           isValid: false,
         }
       }
     }
 
-    return this.validate(parameters);
+    let isValid = true;
+    let customValidationErrorMessage = undefined;
+    try {
+      await this.customValidation(parameters);
+    } catch (err) {
+      isValid = false;
+      customValidationErrorMessage = (err as Error).message;
+    }
+
+    if (!isValid) {
+      return {
+        resourceType: resourceMetaData.type,
+        resourceName: resourceMetaData.name,
+        schemaValidationErrors: this.schemaValidator?.errors ?? [],
+        customValidationErrorMessage,
+        isValid: false,
+      }
+    }
+
+    return {
+      resourceType: resourceMetaData.type,
+      resourceName: resourceMetaData.name,
+      schemaValidationErrors: [],
+      isValid: true,
+    }
   }
 
   // TODO: Currently stateful mode expects that the currentConfig does not need any additional transformations (default and transform parameters)
@@ -342,11 +377,13 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  async validate(parameters: Partial<T>): Promise<ValidationResult> {
-    return {
-      isValid: true,
-    }
-  };
+  /**
+   * Add custom validation logic in-addition to the default schema validation.
+   * In this method throw an error if the object did not validate. The message of the
+   * error will be shown to the user.
+   * @param parameters
+   */
+  async customValidation(parameters: Partial<T>): Promise<void> {};
 
   abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
 

package/src/entities/stateful-parameter.test.ts

@@ -22,7 +22,6 @@ class TestArrayParameter extends ArrayStatefulParameter<TestConfig, string> {
   }
 }
 
-
 describe('Stateful parameter tests', () => {
   it('applyAddItem is called the correct number of times', async () => {
     const plan = Plan.create<TestConfig>(
@@ -36,7 +35,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyAdd(plan.desiredConfig.propA, plan);
+    await testParameter.applyAdd(plan.desiredConfig!.propA, plan);
 
     expect(testParameter.applyAddItem.callCount).to.eq(3);
     expect(testParameter.applyRemoveItem.called).to.be.false;
@@ -54,7 +53,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyRemove(plan.currentConfig.propA, plan);
+    await testParameter.applyRemove(plan.currentConfig!.propA, plan);
 
     expect(testParameter.applyAddItem.called).to.be.false;
     expect(testParameter.applyRemoveItem.callCount).to.eq(3);
@@ -77,7 +76,7 @@ describe('Stateful parameter tests', () => {
     })
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+    await testParameter.applyModify(plan.desiredConfig!.propA, plan.currentConfig!.propA, false, plan);
 
     expect(testParameter.applyAddItem.calledThrice).to.be.true;
     expect(testParameter.applyRemoveItem.called).to.be.false;
@@ -107,7 +106,7 @@ describe('Stateful parameter tests', () => {
       }
     });
 
-    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+    await testParameter.applyModify(plan.desiredConfig!.propA, plan.currentConfig!.propA, false, plan);
 
     expect(testParameter.applyAddItem.calledOnce).to.be.true;
     expect(testParameter.applyRemoveItem.called).to.be.false;