Fix/jsonpath invalid evaluation

__tests__/InputOutputProcessing.test.ts

@@ -30,8 +30,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processInputPath(undefined, input);
+      const result = processInputPath(undefined, input, context);
 
       expect(result).toEqual(input);
     });
@@ -54,8 +55,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processInputPath('$.movies', input);
+      const result = processInputPath('$.movies', input, context);
 
       expect(result).toEqual([
         {
@@ -89,8 +91,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processInputPath(null, input);
+      const result = processInputPath(null, input, context);
 
       expect(result).toEqual({});
     });
@@ -108,8 +111,9 @@ describe('Input processing', () => {
         },
       };
       const input = {};
+      const context = {};
 
-      const result = processPayloadTemplate(parameters, input);
+      const result = processPayloadTemplate(parameters, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -149,8 +153,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(parameters, input);
+      const result = processPayloadTemplate(parameters, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -192,8 +197,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(parameters, input);
+      const result = processPayloadTemplate(parameters, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -247,8 +253,9 @@ describe('Input processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(parameters, input);
+      const result = processPayloadTemplate(parameters, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -279,8 +286,9 @@ describe('Output processing', () => {
         },
       };
       const input = {};
+      const context = {};
 
-      const result = processPayloadTemplate(resultSelector, input);
+      const result = processPayloadTemplate(resultSelector, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -320,8 +328,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(resultSelector, input);
+      const result = processPayloadTemplate(resultSelector, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -363,8 +372,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(resultSelector, input);
+      const result = processPayloadTemplate(resultSelector, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -418,8 +428,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processPayloadTemplate(resultSelector, input);
+      const result = processPayloadTemplate(resultSelector, input, context);
 
       expect(result).toEqual({
         field1: 50,
@@ -621,8 +632,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processOutputPath(undefined, input);
+      const result = processOutputPath(undefined, input, context);
 
       expect(result).toEqual(input);
     });
@@ -645,8 +657,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processOutputPath('$.movies', input);
+      const result = processOutputPath('$.movies', input, context);
 
       expect(result).toEqual([
         {
@@ -680,8 +693,9 @@ describe('Output processing', () => {
           lastUpdated: '2020-05-27T08:00:00Z',
         },
       };
+      const context = {};
 
-      const result = processOutputPath(null, input);
+      const result = processOutputPath(null, input, context);
 
       expect(result).toEqual({});
     });

__tests__/jsonPath/JsonPath.test.ts

@@ -0,0 +1,62 @@
+import { jsonPathQuery } from '../../src/stateMachine/jsonPath/JsonPath';
+import { IntegerConstraint } from '../../src/stateMachine/jsonPath/constraints/IntegerConstraint';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('jsonPathQuery', () => {
+  const testObject = {
+    a: 1,
+    b: 2,
+    c: [3, 4, 5],
+    d: { e: 6 },
+  };
+  const context = {
+    executionId: 'id-12345',
+  };
+
+  test('should query `json` parameter if path expression starts with `$`', () => {
+    const pathExpression = '$.a';
+
+    const result = jsonPathQuery(pathExpression, testObject, context);
+    expect(result).toBe(1);
+  });
+
+  test('should query Context Object if path expression starts with `$$`', () => {
+    const pathExpression = '$$.executionId';
+
+    const result = jsonPathQuery(pathExpression, testObject, context);
+    expect(result).toBe('id-12345');
+  });
+
+  describe('constraints', () => {
+    test('should return value if path is valid', () => {
+      const pathExpression = '$.d.e';
+
+      const result = jsonPathQuery(pathExpression, testObject, context);
+      expect(result).toBe(6);
+    });
+
+    test('should check default `DefinedValueConstraint` constraint', () => {
+      const pathExpression = '$.nonexistent';
+
+      const testFn = () => jsonPathQuery(pathExpression, testObject, context);
+      expect(testFn).toThrow("Path expression '$.nonexistent' does not point to a value");
+    });
+
+    test('should not check default `DefinedValueConstraint` constraint if `ignoreDefinedValueConstraint` option is true', () => {
+      const pathExpression = '$.nonexistent';
+
+      const testFn = () => jsonPathQuery(pathExpression, testObject, context, { ignoreDefinedValueConstraint: true });
+      expect(testFn).not.toThrow();
+    });
+
+    test('should check for any constraints provided by the caller', () => {
+      const pathExpression = '$.c';
+
+      const testFn = () => jsonPathQuery(pathExpression, testObject, context, { constraints: [IntegerConstraint] });
+      expect(testFn).toThrow("Path expression '$.c' evaluated to [3,4,5], but expected an integer");
+    });
+  });
+});

__tests__/jsonPath/constraints/ArrayConstraint.test.ts

@@ -0,0 +1,27 @@
+import { StatesRuntimeError } from '../../../src/error/predefined/StatesRuntimeError';
+import { ArrayConstraint } from '../../../src/stateMachine/jsonPath/constraints/ArrayConstraint';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('ArrayConstraint', () => {
+  test('should not throw if passed value is an array', () => {
+    const value = ['item', 1, { a: 1, b: 2 }, [], true];
+
+    const constraint = new ArrayConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).not.toThrow();
+  });
+
+  test('should throw if passed value is not an array', () => {
+    const value = 55;
+
+    const constraint = new ArrayConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).toThrow("Path expression '' evaluated to 55, but expected an array");
+    expect(testFunc).toThrow(StatesRuntimeError);
+  });
+});

__tests__/jsonPath/constraints/BooleanConstraint.test.ts

@@ -0,0 +1,27 @@
+import { StatesRuntimeError } from '../../../src/error/predefined/StatesRuntimeError';
+import { BooleanConstraint } from '../../../src/stateMachine/jsonPath/constraints/BooleanConstraint';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('BooleanConstraint', () => {
+  test('should not throw if passed value is a boolean', () => {
+    const value = true;
+
+    const constraint = new BooleanConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).not.toThrow();
+  });
+
+  test('should throw if passed value is not a boolean', () => {
+    const value = 'hello';
+
+    const constraint = new BooleanConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).toThrow('Path expression \'\' evaluated to "hello", but expected a boolean');
+    expect(testFunc).toThrow(StatesRuntimeError);
+  });
+});

__tests__/jsonPath/constraints/DefinedValueConstraint.test.ts

@@ -0,0 +1,27 @@
+import { DefinedValueConstraint } from '../../../src/stateMachine/jsonPath/constraints/DefinedValueConstraint';
+import { StatesRuntimeError } from '../../../src/error/predefined/StatesRuntimeError';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('DefinedValueConstraint', () => {
+  test('should not throw if passed value is not undefined', () => {
+    const value = {};
+
+    const constraint = new DefinedValueConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).not.toThrow();
+  });
+
+  test('should throw if passed value is undefined', () => {
+    const value = undefined;
+
+    const constraint = new DefinedValueConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).toThrow("Path expression '' does not point to a value");
+    expect(testFunc).toThrow(StatesRuntimeError);
+  });
+});

__tests__/jsonPath/constraints/IntegerConstraint.test.ts

@@ -0,0 +1,81 @@
+import { IntegerConstraint } from '../../../src/stateMachine/jsonPath/constraints/IntegerConstraint';
+import { StatesRuntimeError } from '../../../src/error/predefined/StatesRuntimeError';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('IntegerConstraint', () => {
+  test('should not throw if passed value is an integer', () => {
+    const value = 12345;
+
+    const constraint = new IntegerConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).not.toThrow();
+  });
+
+  test('should throw if passed value is not a number', () => {
+    const value = 'hello, world!';
+
+    const constraint = new IntegerConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).toThrow('Path expression \'\' evaluated to "hello, world!", but expected an integer');
+    expect(testFunc).toThrow(StatesRuntimeError);
+  });
+
+  test('should throw if passed value is a number but not an integer', () => {
+    const value = 123.45;
+
+    const constraint = new IntegerConstraint('');
+
+    const testFunc = () => constraint.test(value);
+    expect(testFunc).toThrow("Path expression '' evaluated to 123.45, but expected an integer");
+    expect(testFunc).toThrow(StatesRuntimeError);
+  });
+
+  describe('IntegerConstraint.greaterThanOrEqual', () => {
+    test('should not throw if passed value is greater than the constraint value', () => {
+      const value = 12345;
+
+      const GreaterThanOrEqualConstraint = IntegerConstraint.greaterThanOrEqual(12000);
+      const constraint = new GreaterThanOrEqualConstraint('');
+
+      const testFunc = () => constraint.test(value);
+      expect(testFunc).not.toThrow();
+    });
+
+    test('should not throw if passed value is equal to the constraint value', () => {
+      const value = 12345;
+
+      const GreaterThanOrEqualConstraint = IntegerConstraint.greaterThanOrEqual(12345);
+      const constraint = new GreaterThanOrEqualConstraint('');
+
+      const testFunc = () => constraint.test(value);
+      expect(testFunc).not.toThrow();
+    });
+
+    test('should throw if passed value is less than the constraint value', () => {
+      const value = 8000;
+
+      const GreaterThanOrEqualConstraint = IntegerConstraint.greaterThanOrEqual(12345);
+      const constraint = new GreaterThanOrEqualConstraint('');
+
+      const testFunc = () => constraint.test(value);
+      expect(testFunc).toThrow("Path expression '' evaluated to 8000, but expected an integer >= 12345");
+      expect(testFunc).toThrow(StatesRuntimeError);
+    });
+
+    test('should throw if passed value is not an integer', () => {
+      const value = 123.45;
+
+      const GreaterThanOrEqualConstraint = IntegerConstraint.greaterThanOrEqual(12345);
+      const constraint = new GreaterThanOrEqualConstraint('');
+
+      const testFunc = () => constraint.test(value);
+      expect(testFunc).toThrow("Path expression '' evaluated to 123.45, but expected an integer");
+      expect(testFunc).toThrow(StatesRuntimeError);
+    });
+  });
+});