@fincity/kirun-js 1.6.13 → 1.6.15

package/__tests__/engine/function/system/array/ArrayToArrayOfObjectsTest.ts

@@ -20,7 +20,7 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([{ value: 1 }, { value: 2 }, { value: 3 }]);
+    expect(result).toStrictEqual([{ value: 1 }, { value: 2 }, { value: 3 }]);
 
     result = (
         await fun.execute(
@@ -39,7 +39,7 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([{ number: 1 }, { number: 2 }, { number: 3 }]);
+    expect(result).toStrictEqual([{ number: 1 }, { number: 2 }, { number: 3 }]);
 
     result = (
         await fun.execute(
@@ -53,7 +53,7 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([
+    expect(result).toStrictEqual([
         { value: { number: 1 } },
         { value: { number: 2 } },
         { value: { number: 3 } },
@@ -82,7 +82,7 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([
+    expect(result).toStrictEqual([
         { value1: 'a', value2: 1 },
         { value1: 'b', value2: 2 },
         { value1: 'c', value2: '3' },
@@ -112,10 +112,10 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([
-        { key: 'a', value: 1 },
-        { key: 'b', value: 2 },
-        { key: 'c', value: '3' },
+    expect(result).toStrictEqual([
+        { key: 'a', value: 1, other: undefined },
+        { key: 'b', value: 2, other: undefined },
+        { key: 'c', value: '3', other: undefined },
     ]);
 
     result = (
@@ -142,5 +142,118 @@ test('Array to Array of objects', async () => {
         .getResult()
         .get('result');
 
-    expect(result).toMatchObject([{ maKey: 'a' }, { maKey: 'b' }, { maKey: 'c' }]);
+    expect(result).toStrictEqual([{ maKey: 'a' }, { maKey: 'b' }, { maKey: 'c' }]);
+});
+
+test('Array with nested object and mixed', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([
+                    ['source', [true, 1, 2, ['a', 'b', 'c']]],
+                    ['keyName', ['akey', 'bkey', 'ckey']],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject([
+        { akey: true },
+        { akey: 1 },
+        { akey: 2 },
+        { akey: 'a', bkey: 'b', ckey: 'c' },
+    ]);
+});
+
+test('Array with nested array object and mixed without key', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['source', [true, 1, 2, ['a', 'b', 'c']]]])),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toStrictEqual([
+        { value: true },
+        { value: 1 },
+        { value: 2 },
+        { value1: 'a', value2: 'b', value3: 'c' },
+    ]);
+});
+
+test('Array with nested array object and mixed without key', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([['source', [true, 1, 2, ['a', 'b', 'c', ['d', 'e'], { obj1: 'val1' }]]]]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toStrictEqual([
+        { value: true },
+        { value: 1 },
+        { value: 2 },
+        {
+            value1: 'a',
+            value2: 'b',
+            value3: 'c',
+            value4: ['d', 'e'],
+            value5: {
+                obj1: 'val1',
+            },
+        },
+    ]);
+});
+
+test('Array with nested array object and mixed with key arrays', async () => {
+    let fun = new ArrayToArrayOfObjects();
+
+    let result = (
+        await fun.execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(
+                new Map([
+                    ['source', [[true, false], [1, 'surendhar'], ['satya']]],
+                    ['keyName', ['valueA', 'valueB', 'valueC', 'valueD']],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    console.log(result);
+
+    expect(result).toStrictEqual([
+        { valueA: true, valueB: false, valueC: undefined, valueD: undefined },
+        { valueA: 1, valueB: 'surendhar', valueC: undefined, valueD: undefined },
+        { valueA: 'satya', valueB: undefined, valueC: undefined, valueD: undefined },
+    ]);
 });

package/__tests__/engine/runtime/KIRuntimeValuesEmptyTest.ts

@@ -26,6 +26,14 @@ class Print extends AbstractFunction {
             new Map([
                 Parameter.ofEntry(Print.VALUES, Schema.ofAny(Print.VALUES), true),
                 Parameter.ofEntry(Print.VALUE, Schema.ofAny(Print.VALUE)),
+                Parameter.ofEntry(
+                    Print.VALUE + 'Pick1',
+                    Schema.ofBoolean(Print.VALUE + 'Pick1').setDefaultValue(false),
+                ),
+                Parameter.ofEntry(
+                    Print.VALUE + 'Pick2',
+                    Schema.ofString(Print.VALUE + 'Pick2').setDefaultValue(''),
+                ),
             ]),
         );
 
@@ -36,14 +44,20 @@ class Print extends AbstractFunction {
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let values = context.getArguments()?.get(Print.VALUES);
         let value = context.getArguments()?.get(Print.VALUE);
+        let valuePick1 = context.getArguments()?.get(Print.VALUE + 'Pick1');
+        let valuePick2 = context.getArguments()?.get(Print.VALUE + 'Pick2');
 
         console?.log('Values', ...values);
         console?.log('Value', value);
+        console?.log('ValuePick1', valuePick1);
+        console?.log('ValuePick2', valuePick2);
 
         return new FunctionOutput([EventResult.outputOf(new Map())]);
     }
 }
 
+const mock = jest.spyOn(global.console, 'log').mockImplementation();
+
 test('KIRuntime With Definition no values passed ', async () => {
     var def = {
         name: 'Make an error',
@@ -80,7 +94,7 @@ test('KIRuntime With Definition no values passed ', async () => {
                 new KIRunSchemaRepository(),
             ).setArguments(new Map()),
         );
-        console.log(fo);
+        expect(mock).toBeCalledTimes(4);
     } catch (e: any) {
         console.error(e);
     }
@@ -122,7 +136,7 @@ test('KIRuntime With Definition with no value passed', async () => {
                 new KIRunSchemaRepository(),
             ).setArguments(new Map()),
         );
-        console.log(fo);
+        expect(mock).toBeCalledTimes(8);
     } catch (e: any) {
         console.error(e);
     }
@@ -165,7 +179,7 @@ test('KIRuntime With Definition with no value and values passed', async () => {
                 new KIRunSchemaRepository(),
             ).setArguments(new Map()),
         );
-        console.log(fo);
+        expect(mock).toBeCalledTimes(12);
     } catch (e: any) {
         console.error(e);
     }

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -1,25 +1,9 @@
-import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
-import { EventResult } from '../../../src/engine/model/EventResult';
-import { Event } from '../../../src/engine/model/Event';
 import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
-import { Parameter } from '../../../src/engine/model/Parameter';
-import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
-import { Create } from '../../../src/engine/function/system/context/Create';
-import { SetFunction } from '../../../src/engine/function/system/context/SetFunction';
-import { GenerateEvent } from '../../../src/engine/function/system/GenerateEvent';
-import { If } from '../../../src/engine/function/system/If';
-import { RangeLoop } from '../../../src/engine/function/system/loop/RangeLoop';
-import { Statement } from '../../../src/engine/model/Statement';
-import { ParameterReference } from '../../../src/engine/model/ParameterReference';
-import { Schema } from '../../../src/engine/json/schema/Schema';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
 import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
 import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
-import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
-import { FunctionSignature } from '../../../src/engine/model/FunctionSignature';
-import { AbstractFunction } from '../../../src/engine/function/AbstractFunction';
-import { FunctionOutput } from '../../../src/engine/model/FunctionOutput';
-import { HybridRepository } from '../../../src/engine/HybridRepository';
-import { Function } from '../../../src/engine/function/Function';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
 
 test('KIRuntime With Definition 1', async () => {
     var def = {

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

@@ -42,3 +42,13 @@ test('OutputMapTokenValueExtractor Test', () => {
     expect(omtv.getValue('Steps.step1.output.zero')).toBe(0);
     expect(omtv.getValue('Steps.step1.output.obj.address.phone.phone2')).toBe('5678');
 });
+
+test('OutputMapTokenValueExtractor Test 2', () => {
+    let output: Map<string, Map<string, Map<string, any>>> = new Map([
+        ['step1', new Map([['output', new Map([['arr', ['a', 'b', 'c']]])]])],
+    ]);
+
+    var omtv = new OutputMapTokenValueExtractor(output);
+    expect(omtv.getValue('Steps.step1.output.arr[1]')).toBe('b');
+    expect(omtv.getValue('Steps.step1.output.arr1[1]')).toBeUndefined();
+});