@fincity/kirun-js 2.15.1 → 2.16.0

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -170,7 +170,8 @@ test('KIRuntime Test 1', async () => {
             ).setArguments(new Map([['Count', num]])),
         )
     ).allResults();
-    //console.log('KIRunt Logic : ' + (new Date().getTime() - start));
+    console.log('KIRuntime Logic : ' + (new Date().getTime() - start) + 'ms');
+    
     expect(out[0].getResult().get('result')).toStrictEqual(array);
 });
 

package/__tests__/engine/runtime/KIRuntimeVarArgsTest.ts

@@ -0,0 +1,101 @@
+import { Function, HybridRepository, ObjectValueSetterExtractor } from '../../../src';
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
+import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
+
+test('KIRuntime Print function with variable arguments', async () => {
+    var def = {
+        name: 'varArgWithNothing',
+        namespace: 'Test',
+        steps: {
+            testFunction: {
+                statementName: 'testFunction',
+                namespace: 'LocalFunction',
+                name: 'Other',
+                parameterMap: {
+                    eagerFields: {
+                        one: {
+                            type: 'EXPRESSION',
+                            expression: 'Store.names',
+                            key: 'one',
+                            order: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    var OtherFunction = new KIRuntime(
+        FunctionDefinition.from({
+            namespace: 'LocalFunction',
+            name: 'Other',
+            steps: {
+                print: {
+                    statementName: 'print',
+                    namespace: Namespaces.SYSTEM,
+                    name: 'Print',
+                    parameterMap: {
+                        values: {
+                            one: {
+                                type: 'EXPRESSION',
+                                expression: 'Arguments.eagerFields',
+                                value: 'Test',
+                                key: 'one',
+                                order: 1,
+                            },
+                        },
+                    },
+                },
+            },
+            parameters: {
+                eagerFields: {
+                    schema: {
+                        namespace: '_',
+                        name: 'eagerFields',
+                        version: 1,
+                        type: 'STRING',
+                    },
+                    parameterName: 'eagerFields',
+                    variableArgument: true,
+                    type: 'EXPRESSION',
+                },
+            },
+        }),
+        false,
+    );
+    const fd = FunctionDefinition.from(def);
+
+    const store = new ObjectValueSetterExtractor(
+        { names: ['kiran', 'kumar', 'grandhi'] },
+        'Store.',
+    );
+
+    // console.log(store.getValue('Store.names'));
+
+    const oldConsole = console.log;
+    const test = (console.log = jest.fn().mockImplementation(() => {}));
+
+    let result = await new KIRuntime(fd, false).execute(
+        new FunctionExecutionParameters(
+            new HybridRepository<Function>(new KIRunFunctionRepository(), {
+                find: async (namespace: string, name: string): Promise<Function | undefined> => {
+                    if (namespace === 'LocalFunction' && name === 'Other') return OtherFunction;
+                    return undefined;
+                },
+
+                filter: async (name: string): Promise<string[]> => {
+                    return ['LocalFunction.Other'];
+                },
+            }),
+            new KIRunSchemaRepository(),
+        ).setValuesMap(new Map([[store.getPrefix(), store]])),
+    );
+
+    console.log = oldConsole;
+
+    expect(test.mock.calls[0]).toMatchObject(['kiran', 'kumar', 'grandhi']);
+});

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

@@ -558,3 +558,69 @@ test('backslash escape', () => {
     let ev = new ExpressionEvaluator("'\\maza'");
     expect(ev.evaluate(new Map())).toBe('\\maza');
 });
+
+test('ternary expression with displayValue equality check', () => {
+    // Test when displayValue = "0" -> should return "1"
+    let ttv = new TestTokenValueExtractor({ displayValue: '0' });
+    let ev = new ExpressionEvaluator("(Test.displayValue = '0') ? '1' : (Test.displayValue + '1')");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('1');
+
+    // Test when displayValue = "1" -> should return "11"
+    ttv = new TestTokenValueExtractor({ displayValue: '1' });
+    ev = new ExpressionEvaluator("(Test.displayValue = '0') ? '1' : (Test.displayValue + '1')");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('11');
+
+    // Test when displayValue = "5" -> should return "51"
+    ttv = new TestTokenValueExtractor({ displayValue: '5' });
+    ev = new ExpressionEvaluator("(Test.displayValue = '0') ? '1' : (Test.displayValue + '1')");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('51');
+
+    // Test when displayValue = "10" -> should return "101"
+    ttv = new TestTokenValueExtractor({ displayValue: '10' });
+    ev = new ExpressionEvaluator("(Test.displayValue = '0') ? '1' : (Test.displayValue + '1')");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('101');
+
+    // Test ((Test.displayValue = '0') ? '1' : (Test.displayValue + '1'))
+    ttv = new TestTokenValueExtractor({ displayValue: '1' });
+    ev = new ExpressionEvaluator("((Test.displayValue = '0') ? '1' : (Test.displayValue + '1'))");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('11');
+
+    // Test (((Test.displayValue = '0') ? '1' : (Test.displayValue + '1')))
+    ttv = new TestTokenValueExtractor({ displayValue: '1' });
+    ev = new ExpressionEvaluator("(((Test.displayValue = '0') ? '1' : (Test.displayValue + '1')))");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('11');
+
+    // Test (((Test.displayValue = '0')) ? '1' : (((Test.displayValue) + '1')))
+    ttv = new TestTokenValueExtractor({ displayValue: '1' });
+    ev = new ExpressionEvaluator("(((Test.displayValue = '0')) ? '1' : (((Test.displayValue) + '1')))");
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe('11');
+});
+
+test('unary minus operator', () => {
+    // Simple negative number
+    let ev = new ExpressionEvaluator('-5');
+    expect(ev.evaluate(new Map())).toBe(-5);
+
+    // Negative variable using subtraction from zero
+    let ttv = new TestTokenValueExtractor({ value: 10 });
+    ev = new ExpressionEvaluator('0 - Test.value');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe(-10);
+
+    // Negative in expression: (a + (0 - b)) = 5 + (-3) = 2
+    ttv = new TestTokenValueExtractor({ a: 5, b: 3 });
+    ev = new ExpressionEvaluator('Test.a + (0 - Test.b)');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe(2);
+
+    // Multiplication with negative: a * -1
+    ttv = new TestTokenValueExtractor({ a: 5 });
+    ev = new ExpressionEvaluator('Test.a * -1');
+    expect(ev.evaluate(MapUtil.of(ttv.getPrefix(), ttv))).toBe(-5);
+
+    // Parenthesized negative number
+    ev = new ExpressionEvaluator('(-5)');
+    expect(ev.evaluate(new Map())).toBe(-5);
+
+    // Negative number in complex expression
+    ev = new ExpressionEvaluator('10 + (-5) * 2');
+    expect(ev.evaluate(new Map())).toBe(0);
+});

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

@@ -96,7 +96,7 @@ test('Expression with String Literal - 2 ', () => {
     expect(ev.evaluate(valuesMap)).toBe('');
 
     ev = new ExpressionEvaluator('2.val');
-    expect(ev.evaluate(valuesMap)).toBe('2.val');
+    expect(ev.evaluate(valuesMap)).toBe(undefined);
 });
 
 test('Testing for string length with object', () => {