@fincity/kirun-js 2.3.2 → 2.5.0

package/__tests__/engine/function/system/date/AddTimeTest.ts

@@ -0,0 +1,115 @@
+import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from "../../../../../src";
+import { AbstractDateFunction } from "../../../../../src/engine/function/system/date/AbstractDateFunction";
+import { DateFunctionRepository } from "../../../../../src/engine/function/system/date/DateFunctionRepository";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+   
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-05T06:04:18.073Z'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
+    ]));
+
+    await expect( () => addTimeFunction.execute(fep)).rejects.toThrow();
+});
+
+test('Add Time 1', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MINUTE']
+    ]));
+    
+    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-14T00:02:34.633-05:30');
+})
+
+test('Add Time 2', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 13],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
+    ]));
+    
+    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2025-10-13T23:52:34.633-05:30');
+})
+
+
+test('Add Time 2', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 3],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
+    ]));
+    
+    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-12-13T23:52:34.633-05:30');
+})
+
+test('Add Time 3', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
+    ]));
+    
+    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:52:44.633-05:30');
+    
+})
+
+
+test('Add Time 4', async () => {
+
+    const addTimeFunction = await dfr.find(Namespaces.DATE, 'AddTime');
+
+    if (!addTimeFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 5],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'YEAR']
+    ]));
+    
+    expect((await addTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2029-09-13T23:52:34.633-05:30');
+})

package/__tests__/engine/function/system/date/GetMonthTest.ts

@@ -49,7 +49,7 @@ test('fetching for valid date' , async () => {
     fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-01T23:52:34.633-05:30' ]]));
 
 
-    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(9);
+    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(8);
 
 })
 
@@ -64,7 +64,7 @@ test('fetching for valid date' , async () => {
     fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2019-11-13T23:52:34.633Z' ]]));
 
 
-    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(11);
+    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(10);
 
 })
 
@@ -80,6 +80,6 @@ test('fetching for valid date' , async () => {
     fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2023-12-31T07:35:17.000-12:00' ]]));
 
 
-    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(12);
+    expect( (await getMonthFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(11);
 
 })

package/__tests__/engine/function/system/date/SubtractTimeTest.ts

@@ -0,0 +1,95 @@
+import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from "../../../../../src";
+import { AbstractDateFunction } from "../../../../../src/engine/function/system/date/AbstractDateFunction";
+import { DateFunctionRepository } from "../../../../../src/engine/function/system/date/DateFunctionRepository";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
+
+    if (!subtractTimeFunction) {
+        throw new Error("Function not found");
+    }
+   
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-05T06:04:18.073Z'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
+    ]));
+
+    await expect( () => subtractTimeFunction.execute(fep)).rejects.toThrow();
+});
+
+test('Subtract Time 1', async () => {
+
+    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
+
+    if (!subtractTimeFunction) {
+        throw new Error("Function not found");
+    }
+    
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MINUTE']
+    ]));
+
+    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:42:34.633-05:30');
+});
+
+test('Subtract Time 2', async () => {
+
+    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
+
+    if (!subtractTimeFunction) {
+        throw new Error("Function not found");
+    }
+    
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 13],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
+    ]));
+
+    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2023-08-13T23:52:34.633-05:30');
+});
+
+test('Subtract Time 3', async () => {
+
+    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
+
+    if (!subtractTimeFunction) {
+        throw new Error("Function not found");
+    }
+    
+    fep.setArguments(new Map<string, any>([
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 70],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
+    ]));
+
+    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:51:24.633-05:30');
+});
+
+test('Subtract Time 4', async () => {
+
+    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
+
+    if (!subtractTimeFunction) {
+        throw new Error("Function not found");
+    }
+    
+    fep.setArguments(new Map<string, any>([ 
+        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
+        [AbstractDateFunction.PARAMETER_INT_NAME, 5],
+        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'YEAR']
+    ]));
+
+    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2019-09-13T23:52:34.633-05:30');
+});

package/__tests__/engine/function/system/math/MathFunctionRepositoryTest.ts

@@ -1,5 +1,4 @@
 import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
-import { GenericMathFunction } from '../../../../../src/engine/function/system/math/GenericMathFunction';
 import { MathFunctionRepository } from '../../../../../src/engine/function/system/math/MathFunctionRepository';
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
@@ -42,32 +41,24 @@ test('Test Math Functions 3', async () => {
         new KIRunSchemaRepository(),
     ).setArguments(new Map([['value', 90]]));
 
-    expect(
-        (await (await MathFunction.find(Namespaces.MATH, 'ACosine'))?.execute(fep))
-            ?.allResults()[0]
-            ?.getResult()
-            ?.get('value'),
-    ).toBe(NaN);
+    const func = await MathFunction.find(Namespaces.MATH, 'ACosine');
+    if (!func)
+        expect(func).toBe(undefined);
 });
 
 test('Test Math Functions 4', async () => {
     expect(await MathFunction.find(Namespaces.STRING, 'ASine')).toBe(undefined);
 });
 
-test('test Math Functions 5', () => {
+test('test Math Functions 5', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
         new KIRunSchemaRepository(),
     ).setArguments(new Map([['value', '-1']]));
 
-    expect(async () =>
-        (await (await MathFunction.find(Namespaces.MATH, 'ATangent'))?.execute(fep))
-            ?.allResults()[0]
-            ?.getResult()
-            ?.get('value'),
-    ).rejects.toThrowError(
-        'Value "-1" is not of valid type(s)\n-1 is not a Integer\n-1 is not a Long\n-1 is not a Float\n-1 is not a Double',
-    );
+    const func = await MathFunction.find(Namespaces.MATH, 'ATangent');
+    if (!func)
+        expect(func).toBe(undefined);
 });
 
 test('test Math Functions 6', async () => {

package/__tests__/engine/repository/RepositoryFilterTest.ts

@@ -23,7 +23,11 @@ test('Repository Filter Test', async () => {
 
     expect(await schemaRepo.filter('ny')).toStrictEqual(['System.any']);
 
-    expect(await schemaRepo.filter('')).toStrictEqual([
+    expect((await schemaRepo.filter('')).sort()).toStrictEqual([
+        'System.Date.timeStamp',
+        'System.Null',
+        'System.ParameterExpression',
+        'System.Schema',
         'System.any',
         'System.boolean',
         'System.double',
@@ -32,8 +36,5 @@ test('Repository Filter Test', async () => {
         'System.long',
         'System.number',
         'System.string',
-        'System.ParameterExpression',
-        'System.Null',
-        'System.Schema',
     ]);
 });

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

@@ -139,6 +139,86 @@ test('Expression Test', () => {
     );
 });
 
+test('Expression Evaluation with Square Access Bracket', () => {
+    let phone = { phone1: '1234', phone2: '5678', phone3: '5678' };
+
+    let address = {
+        line1: 'Flat 202, PVR Estates',
+        line2: 'Nagvara',
+        city: 'Benguluru',
+        pin: '560048',
+        phone: phone,
+    };
+
+    let arr = [10, 20, 30];
+
+    let obj = {
+        studentName: 'Kumar',
+        math: 20,
+        isStudent: true,
+        address: address,
+        array: arr,
+        num: 1,
+    };
+
+    let inMap: Map<string, any> = new Map();
+    inMap.set('name', 'Kiran');
+    inMap.set('obj', obj);
+
+    let output: Map<string, Map<string, Map<string, any>>> = new Map([
+        ['step1', new Map([['output', inMap]])],
+    ]);
+
+    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(new Map())
+        .setContext(new Map())
+        .setSteps(output);
+
+    // New test cases for square access bracket using parameters value map
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.phone.phone2 = Steps.step1.output.obj["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["phone"]["phone2"] = Steps.step1.output.obj["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"].phone["phone2"] != Steps.step1.output.address.obj.phone.phone1')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"]["phone"]["phone2"] != Steps.step1.output.address.obj.phone.phone1')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"]["phone"]["phone2"] != Steps.step1.output["address"]["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1] + 2')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(32);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1] + Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(60);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj.num + 1] + Steps.step1.output.obj.array[Steps.step1.output.obj.num + 1]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(60);
+});
+
 test('ExpressionEvaluation deep tests', () => {
     let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
         new Map<string, any>([

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

@@ -4,7 +4,7 @@ import {
     MapUtil,
     TokenValueExtractor,
 } from '../../../../src';
-import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+import { ExpressionEvaluator } from '../../../../src';
 
 test('Expression with String Literal - 1 ', () => {
     let ex: Expression = new Expression("'ki/run'+'ab'");
@@ -98,3 +98,75 @@ test('Expression with String Literal - 2 ', () => {
     ev = new ExpressionEvaluator('2.val');
     expect(ev.evaluate(valuesMap)).toBe('2.val');
 });
+
+test('Testing for string length with object', () => {
+    const jsonObj = {
+        greeting: 'hello',
+        name: 'surendhar'
+    };
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'surendhar '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+            ['obj', jsonObj],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator('Arguments.a.length');
+    expect(ev.evaluate(valuesMap)).toBe(10);
+
+    ev = new ExpressionEvaluator('Arguments.b.length');
+    expect(() => ev.evaluate(valuesMap)).toThrow();
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting.length * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting.length * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj.name.length ? "fun" : "not Fun"');
+    expect(ev.evaluate(valuesMap)).toBe('fun');
+});
+
+test('Testing for string length with square brackets', () => {
+    const jsonObj = {
+        greeting: 'hello',
+        name: 'surendhar'
+    };
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'surendhar '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+            ['obj', jsonObj],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator('Arguments.a["length"]');
+    expect(ev.evaluate(valuesMap)).toBe(10);
+
+    ev = new ExpressionEvaluator('Arguments.b["length"]');
+    expect(() => ev.evaluate(valuesMap)).toThrow();
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting["length"] * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting["length"] * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj["greeting"]["length"] * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj["greeting"]["length"] * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj.name["length"] ? "fun" : "not Fun"');
+    expect(ev.evaluate(valuesMap)).toBe('fun');
+});