@fincity/kirun-js 1.8.1 → 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

@@ -0,0 +1,118 @@
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+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';
+
+const oldLog = console.log;
+
+test('KIRuntime With ExecuteIfTrue 1', async () => {
+    let def = {
+        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.name': true,
+                },
+            },
+        },
+    };
+
+    let fd = FunctionDefinition.from(def);
+    const mock = jest.spyOn(global.console, 'log').mockImplementation(oldLog);
+
+    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(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);
+});

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

@@ -46,9 +46,11 @@ test('OutputMapTokenValueExtractor Test', () => {
 test('OutputMapTokenValueExtractor Test 2', () => {
     let output: Map<string, Map<string, Map<string, any>>> = new Map([
         ['step1', new Map([['output', new Map([['arr', ['a', 'b', 'c']]])]])],
+        ['step2', new Map([['output', new Map()]])],
     ]);
 
     var omtv = new OutputMapTokenValueExtractor(output);
     expect(omtv.getValue('Steps.step1.output.arr[1]')).toBe('b');
     expect(omtv.getValue('Steps.step1.output.arr1[1]')).toBeUndefined();
+    expect(omtv.getValue('Steps.step2.output')).toBeDefined();
 });