@fincity/kirun-js 1.7.0 → 1.8.0

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

@@ -0,0 +1,180 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+} from '../../../../../src';
+import { ArrayToObject } from '../../../../../src/engine/function/system/array/ArrayToObject';
+
+test('Array To Object Test', async () => {
+    const atoo = new ArrayToObject();
+
+    let source = [
+        { name: 'A', num: 1 },
+        { name: 'B', num: 2 },
+        null,
+        { name: 'C', num: 3 },
+        { name: 'D', num: 4 },
+        { name: 'E', num: 4 },
+        undefined,
+    ];
+
+    const funRepo = new KIRunFunctionRepository();
+    const schemaRepo = new KIRunSchemaRepository();
+
+    let result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'name'],
+                    ['valuePath', 'num'],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({ A: 1, B: 2, C: 3, D: 4, E: 4 });
+
+    result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'num'],
+                    ['valuePath', 'name'],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({ 1: 'A', 2: 'B', 3: 'C', 4: 'E' });
+
+    result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'num'],
+                    ['valuePath', 'name'],
+                    ['ignoreDuplicateKeys', true],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({ 1: 'A', 2: 'B', 3: 'C', 4: 'D' });
+});
+
+test('Array To Object Test - Invalid Key Path', async () => {
+    const atoo = new ArrayToObject();
+
+    let source = [
+        { name: 'A', num: 1 },
+        { name: 'B', num: 2 },
+        { name: 'C', num: 3 },
+        { name: 'D', num: 4 },
+        { name: 'E', num: 4 },
+    ];
+
+    const funRepo = new KIRunFunctionRepository();
+    const schemaRepo = new KIRunSchemaRepository();
+
+    let result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'name1'],
+                    ['valuePath', 'num'],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({});
+
+    result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'name'],
+                    ['valuePath', 'num1'],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({
+        A: undefined,
+        B: undefined,
+        C: undefined,
+        D: undefined,
+        E: undefined,
+    });
+
+    result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'name'],
+                    ['valuePath', 'num1'],
+                    ['ignoreNullValues', true],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({});
+});
+
+test('Array To Object Test - Deep Path', async () => {
+    const atoo = new ArrayToObject();
+
+    let source = [
+        { name: 'A', num: 1, info: { age: 10 } },
+        { name: 'B', num: 2, info: { age: 20 } },
+        { name: 'C', num: 3, info: { age: 30 } },
+        { name: 'D', num: 4, info: { age: 40 } },
+        { name: 'E', num: 4, info: { age: 50 } },
+    ];
+
+    const funRepo = new KIRunFunctionRepository();
+    const schemaRepo = new KIRunSchemaRepository();
+
+    let result = (
+        await atoo.execute(
+            new FunctionExecutionParameters(funRepo, schemaRepo).setArguments(
+                new Map<string, any>([
+                    ['source', source],
+                    ['keyPath', 'info.age'],
+                    ['valuePath', 'name'],
+                ]),
+            ),
+        )
+    )
+        .allResults()[0]
+        .getResult()
+        .get('result');
+
+    expect(result).toMatchObject({ 10: 'A', 20: 'B', 30: 'C', 40: 'D', 50: 'E' });
+});

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

@@ -0,0 +1,74 @@
+import { AbstractArrayFunction } from '../../../../../src/engine/function/system/array/AbstractArrayFunction';
+import { FunctionOutput } from '../../../../../src/engine/model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { RemoveDuplicates } from '../../../../../src/engine/function/system/array/RemoveDuplicates';
+
+test('RemoveDuplicates Test', async () => {
+    let removeDuplicates: RemoveDuplicates = new RemoveDuplicates();
+
+    let source: any[] = [2, 2, 2, 2, 2];
+
+    let fep1: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
+        MapUtil.of(
+            AbstractArrayFunction.PARAMETER_ARRAY_SOURCE.getParameterName(),
+            source as any,
+            AbstractArrayFunction.PARAMETER_INT_SOURCE_FROM.getParameterName(),
+            2,
+            AbstractArrayFunction.PARAMETER_INT_LENGTH.getParameterName(),
+            4,
+        ),
+    );
+
+    await expect(removeDuplicates.execute(fep1)).rejects.toThrow();
+
+    source.push(6);
+
+    let result: any[] = [2, 2, 2, 6];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(
+        MapUtil.of(
+            RemoveDuplicates.PARAMETER_ARRAY_SOURCE.getParameterName(),
+            source as any,
+            RemoveDuplicates.PARAMETER_INT_SOURCE_FROM.getParameterName(),
+            2,
+            RemoveDuplicates.PARAMETER_INT_LENGTH.getParameterName(),
+            4,
+        ),
+    );
+
+    let fo: FunctionOutput = await removeDuplicates.execute(fep);
+    expect(fo.allResults()[0].getResult().get(RemoveDuplicates.EVENT_RESULT_NAME)).toStrictEqual(
+        result,
+    );
+
+    source = new Array();
+    source.push({ name: 'Kiran' });
+    source.push({ name: 'Kiran' });
+    source.push({ name: 'Kiran' });
+    source.push({ name: 'Kumar' });
+
+    result = new Array();
+    result.push({ name: 'Kiran' });
+    result.push({ name: 'Kumar' });
+
+    fep = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(MapUtil.of(RemoveDuplicates.PARAMETER_ARRAY_SOURCE.getParameterName(), source));
+
+    fo = await removeDuplicates.execute(fep);
+
+    expect(fo.allResults()[0].getResult().get(RemoveDuplicates.EVENT_RESULT_NAME)).toMatchObject(
+        result,
+    );
+});

package/__tests__/engine/function/system/loop/CountLoopTest.ts

@@ -43,7 +43,7 @@ test('Count Loop2', async () => {
 
     expect(iterations).toMatchObject([]);
     expect(er?.getName()).toBe('output');
-    expect(er?.getResult().get('value')).toBe(-1);
+    expect(er?.getResult().get('value')).toBe(0);
 });
 
 test('Count Loop3', async () => {

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

@@ -0,0 +1,51 @@
+import { ObjectValueSetterExtractor } from '../../../../../src';
+
+test('ObjectValueSetterExtractor Test', async () => {
+    let store = {
+        name: 'Kiran',
+        addresses: [
+            {
+                city: 'Bangalore',
+                state: 'Karnataka',
+                country: 'India',
+            },
+            {
+                city: 'Kakinada',
+                state: 'Andhra Pradesh',
+                country: 'India',
+            },
+            { city: 'Beaverton', state: 'Oregon' },
+        ],
+        phone: {
+            home: '080-23456789',
+            office: '080-23456789',
+            mobile: '080-23456789',
+            mobile2: '503-23456789',
+        },
+        plain: [1, 2, 3, 4],
+    };
+
+    let extractor: ObjectValueSetterExtractor = new ObjectValueSetterExtractor(store, 'Store');
+
+    expect(extractor.getValue('Store.name')).toStrictEqual('Kiran');
+
+    extractor.setValue('Store.name', 'Kiran Kumar');
+    store = extractor.getStore();
+
+    expect(store.name).toStrictEqual('Kiran Kumar');
+
+    extractor.setValue('Store.addresses[0].city', 'Bengaluru');
+    expect(extractor.getValue('Store.addresses[0].city')).toStrictEqual('Bengaluru');
+
+    extractor.setValue('Store.plain[0]', '123');
+    expect(extractor.getValue('Store.plain')).toMatchObject(['123', 2, 3, 4]);
+
+    extractor.setValue('Store.plain[0]', 1, false);
+    expect(extractor.getValue('Store.plain')).toMatchObject(['123', 2, 3, 4]);
+
+    extractor.setValue('Store.plain', undefined, true, true);
+    expect(Object.keys(extractor.getValue('Store'))).toMatchObject(['name', 'addresses', 'phone']);
+
+    extractor.setValue('Store.plain', 'plainString', false, false);
+    expect(extractor.getValue('Store.plain')).toStrictEqual('plainString');
+});