@fincity/kirun-js 1.9.0 → 1.9.1

package/__tests__/engine/json/schema/validator/NullValidatorTest.ts

@@ -0,0 +1,13 @@
+import { Schema, SchemaValidator } from '../../../../../src';
+
+test('Check for valid Null value', () => {
+    let schema = Schema.from({
+        type: 'NULL',
+    });
+
+    expect(() => SchemaValidator.validate([], schema!, undefined, 23)).toThrowError();
+    expect(() => SchemaValidator.validate([], schema!, undefined, 0)).toThrowError();
+    expect(() => SchemaValidator.validate([], schema!, undefined, '')).toThrowError();
+    expect(SchemaValidator.validate([], schema!, undefined, null)).toBeNull();
+    expect(SchemaValidator.validate([], schema!, undefined, undefined)).toBeUndefined();
+});

package/__tests__/engine/runtime/KIRuntimeDependencyTest.ts

@@ -1,12 +1,13 @@
 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 With Definition 1', async () => {
-    var def = {
+const oldLog = console.log;
+
+test('KIRuntime With ExecuteIfTrue 1', async () => {
+    let def = {
         name: 'getAppData',
         namespace: 'UIApp',
         parameters: {
@@ -47,12 +48,10 @@ test('KIRuntime With Definition 1', async () => {
         },
     };
 
-    const fd = FunctionDefinition.from(def);
-    const oldLog = console.log;
-
+    let fd = FunctionDefinition.from(def);
     const mock = jest.spyOn(global.console, 'log').mockImplementation(oldLog);
 
-    let result = await new KIRuntime(fd, false).execute(
+    await new KIRuntime(fd, false).execute(
         new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
@@ -62,4 +61,58 @@ test('KIRuntime With Definition 1', async () => {
     );
 
     expect(mock).toBeCalledTimes(2);
+
+    let newDef = {
+        name: 'getAppData',
+        namespace: 'UIApp',
+        parameters: {
+            a: {
+                parameterName: 'a',
+                schema: { name: 'INTEGER', type: ['ARRAY'], items: { type: ['OBJECT', 'NULL'] } },
+            },
+        },
+
+        steps: {
+            forEach: {
+                statementName: 'forEach',
+                namespace: 'System.Loop',
+                name: 'ForEachLoop',
+                parameterMap: {
+                    source: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                    },
+                },
+            },
+            print: {
+                statementName: 'print',
+                namespace: 'System',
+                name: 'Print',
+                parameterMap: {
+                    values: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.forEach.iteration.each.name',
+                        },
+                    },
+                },
+                executeIftrue: {
+                    '(Steps.forEach.iteration.each.age ?? 1) % 2 = 0': true,
+                },
+            },
+        },
+    };
+
+    fd = FunctionDefinition.from(newDef);
+
+    let result = await new KIRuntime(fd, false).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([['a', [{ name: 'Kiran', age: 40 }, null, { name: 'Kumar', age: 39 }]]]),
+        ),
+    );
+
+    expect(mock).toBeCalledTimes(3);
 });

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

@@ -243,3 +243,38 @@ test('Partial path evaluation', () => {
     console.log(ev.getExpression().toString());
     expect(ev.evaluate(valuesMap)).toBe(2);
 });
+
+test('Expression with consecutive negative operators', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 1],
+            ['b1', 4],
+            ['b2', 4],
+        ]),
+    );
+
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev = new ExpressionEvaluator('Arguments.b - Arguments.b1 - Arguments.b2');
+    expect(ev.evaluate(valuesMap)).toBe(-7);
+});
+
+test('Expression with multiple coalesce operator', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 1],
+            ['b1', 4],
+            ['b2', 4],
+        ]),
+    );
+
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev = new ExpressionEvaluator('Arguments.b3 ?? (Arguments.b - 3) ?? Arguments.b5 ?? 4');
+    expect(ev.evaluate(valuesMap)).toBe(-2);
+
+    ev = new ExpressionEvaluator('Arguments.b3 ?? Arguments.b - 3 ?? Arguments.b5 ?? 4');
+    expect(ev.evaluate(valuesMap)).toBe(-2);
+});