@fincity/kirun-js 1.4.1 → 1.4.3

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -35,7 +35,7 @@ test('KIRuntime Test 1', async () => {
         array.push(array[i - 2] + array[i - 1]);
     }
 
-    console.log('Normal Logic : ' + (new Date().getTime() - start));
+    //console.log('Normal Logic : ' + (new Date().getTime() - start));
 
     var create = new Create().getSignature();
     var integerSchema = { name: 'EachElement', type: 'INTEGER' };
@@ -170,7 +170,7 @@ test('KIRuntime Test 1', async () => {
             ).setArguments(new Map([['Count', num]])),
         )
     ).allResults();
-    console.log('KIRunt Logic : ' + (new Date().getTime() - start));
+    //console.log('KIRunt Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);
 });
 
@@ -306,7 +306,7 @@ test('KIRuntime Test 4', async () => {
         array[i] = array[i - 2] + array[i - 1];
     }
 
-    console.log('Normal Logic : ' + (new Date().getTime() - start));
+    //console.log('Normal Logic : ' + (new Date().getTime() - start));
 
     var fibFunctionSignature = new FunctionSignature('FibFunction')
         .setNamespace('FibSpace')
@@ -399,6 +399,6 @@ test('KIRuntime Test 4', async () => {
             ),
         )
     ).allResults();
-    console.log('KIRun Logic : ' + (new Date().getTime() - start));
+    //console.log('KIRun Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);
 });

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -124,3 +124,42 @@ test('KIRuntime With Definition 2', async () => {
 
     expect(result.allResults()[0].getResult()).toMatchObject({});
 });
+
+test('KIRuntime With Definition 3', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'VALUE', value: 'X' },
+                        two: { key: 'two', type: 'VALUE', value: 5 },
+                    },
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                dependentStatements: { 'Steps.add.output': true },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    try {
+        await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+    } catch (e: any) {
+        expect(e.message).toMatch('error');
+    }
+});

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

@@ -1,5 +1,6 @@
 import {
     ArgumentsTokenValueExtractor,
+    Expression,
     KIRunFunctionRepository,
     KIRunSchemaRepository,
     MapUtil,
@@ -211,3 +212,34 @@ test('Expression Evaluation nesting expression', () => {
         'There are 4 boys in the class room...There are 4 boys in the class room...',
     );
 });
+
+test('Partial path evaluation', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 1],
+            ['b1', 4],
+            ['b2', 4],
+            [
+                'c',
+                { a: 0, b: [true, false], c: { x: 'Arguments.b2' }, keys: ['a', 'e', { val: 5 }] },
+            ],
+            ['d', 'c'],
+            [
+                'e',
+                [
+                    { name: 'Kiran', num: 1 },
+                    { name: 'Good', num: 2 },
+                ],
+            ],
+        ]),
+    );
+
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    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);
+});

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

@@ -74,4 +74,7 @@ test('Expression with String Literal - 2 ', () => {
 
     ev = new ExpressionEvaluator("'asdf' * 0");
     expect(ev.evaluate(valuesMap)).toBe('');
+
+    ev = new ExpressionEvaluator('2.val');
+    expect(ev.evaluate(valuesMap)).toBe('2.val');
 });