@fincity/kirun-js 2.1.7 → 2.2.0

package/__tests__/engine/runtime/expression/ExpressionEvaluationTest.ts

@@ -4,6 +4,7 @@ import {
     KIRunFunctionRepository,
     KIRunSchemaRepository,
     MapUtil,
+    OutputMapTokenValueExtractor,
     TokenValueExtractor,
 } from '../../../../src';
 import { Schema } from '../../../../src/engine/json/schema/Schema';
@@ -240,7 +241,6 @@ test('Partial path evaluation', () => {
     let ev = new ExpressionEvaluator('Arguments.c.keys[2].val + 3');
     expect(ev.evaluate(valuesMap)).toBe(8);
     ev = new ExpressionEvaluator('(Arguments.f ?? Arguments.e)[1+1-1].num');
-    console.log(ev.getExpression().toString());
     expect(ev.evaluate(valuesMap)).toBe(2);
 });
 
@@ -374,3 +374,70 @@ test('Expression with logical operators and all value types including object', (
     ev = new ExpressionEvaluator('Arguments.number0 ? 3 : 4');
     expect(ev.evaluate(valuesMap)).toBe(4);
 });
+
+test('Full Store Test', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['c', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+            ['d', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+        ]),
+    );
+
+    expect(atv.getStore()).toMatchObject({
+        a: 'kirun ',
+        b: 2,
+        c: { a: 2, b: [true, false], c: { x: 'kiran' } },
+        d: { a: 2, b: [true, false], c: { x: 'kiran' } },
+    });
+
+    let obv: OutputMapTokenValueExtractor = new OutputMapTokenValueExtractor(
+        new Map<string, Map<string, Map<string, any>>>([
+            ['step1', new Map([['output', new Map([['name', 'Kiran']])]])],
+            ['loop', new Map([['iteration', new Map([['index', 2]])]])],
+        ]),
+    );
+
+    expect(obv.getStore()).toMatchObject({
+        step1: { output: { name: 'Kiran' } },
+        loop: { iteration: { index: 2 } },
+    });
+
+    class TestTokenValueExtractor extends TokenValueExtractor {
+        private store: any;
+
+        constructor(store: any) {
+            super();
+            this.store = store;
+        }
+
+        protected getValueInternal(token: string): any {
+            return this.retrieveElementFrom(token, token.split('.'), 1, this.store);
+        }
+        public getPrefix(): string {
+            return 'Test.';
+        }
+        public getStore(): any {
+            return this.store;
+        }
+    }
+
+    let ttv: TestTokenValueExtractor = new TestTokenValueExtractor({
+        a: 'kirun',
+        b: 2,
+        c: { a: 2, b: [true, false], c: { x: 'kiran' } },
+        d: { a: 2, b: [true, false], c: { x: 'kiran' } },
+    });
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator('Test.a');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('kirun');
+
+    ttv = new TestTokenValueExtractor(20);
+
+    ev = new ExpressionEvaluator('Test');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe(20);
+
+    ev = new ExpressionEvaluator('Test > 10');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toStrictEqual(true);
+});

package/__tests__/engine/runtime/expression/tokenextractor/TokenValueExtractorTest.ts

@@ -17,6 +17,10 @@ class TestExtractor extends TokenValueExtractor {
     ): any {
         return super.retrieveElementFrom(token, parts, partNumber, jsonElement);
     }
+
+    public getStore(): any {
+        return undefined;
+    }
 }
 
 let extractor: TestExtractor;

package/__tests__/engine/util/deepEqualTest.ts

@@ -1,6 +1,97 @@
 import { deepEqual } from '../../../src/engine/util/deepEqual';
 
+const data = [
+    {
+        name: 'Single Array',
+        data: [0, 10, 20, 30, 40, 50],
+    },
+    {
+        name: 'Single Array With Labels',
+        data: [0, 10, 20, 30, 40, 50],
+        labels: ['First', 'Second', 'Third', 'Fourth', 'Fifth', 'Sixth'],
+    },
+    {
+        name: 'Multiple Arrays',
+        data: [
+            [-10, 10, 20, 30, 40, 50],
+            [-20, -10, 0, null, 20, 30],
+            [-60, -30, 10, 100, 20, 30],
+        ],
+    },
+    {
+        name: 'Simple Objects With Labels',
+        data: [
+            {
+                x: 'First',
+                y: 0,
+            },
+            {
+                x: 'Second',
+                y: 10,
+            },
+            {
+                x: 'Third',
+                y: 20,
+            },
+            {
+                x: 'Fourth',
+                y: 30,
+            },
+            {
+                x: 'Fifth',
+                y: 40,
+            },
+            {
+                x: 'Sixth',
+                y: 50,
+            },
+        ],
+    },
+    {
+        name: 'Multiple Objects With Labels',
+        data: [
+            {
+                x: 'First',
+                y: 0,
+                z: -100,
+            },
+            {
+                x: 'Second',
+                y: 10,
+                z: -20,
+            },
+            {
+                x: 'Third',
+                y: 20,
+                z: 30,
+            },
+            {
+                x: 'Fourth',
+                y: 30,
+                z: 40,
+            },
+            {
+                x: 'Fifth',
+                y: 40,
+                z: 10,
+            },
+            {
+                x: 'Sixth',
+                y: 50,
+                z: 80,
+            },
+        ],
+    },
+];
+
 test('deepEqual', () => {
+    expect(deepEqual(null, null)).toBeTruthy();
+    expect(deepEqual(null, data)).toBeFalsy();
+    expect(deepEqual(data[0], data[0])).toBeTruthy();
+    expect(deepEqual(data[0], data[1])).toBeFalsy();
+    expect(deepEqual(data[0], data[2])).toBeFalsy();
+    expect(deepEqual(data[0], data[3])).toBeFalsy();
+    expect(deepEqual(data[0], data[4])).toBeFalsy();
     expect(deepEqual(true, false)).toBeFalsy();
     expect(deepEqual(2, 2)).toBeTruthy();
     expect(deepEqual(null, undefined)).toBeTruthy();