@fincity/kirun-js 1.1.1 → 1.1.2

package/__tests__/engine/function/system/array/DeleteTest.ts

@@ -47,7 +47,6 @@ test('Delete Test 2', async () => {
     expect(source).toStrictEqual(temp);
 });
 
-
 test('Delete Test 3', async () => {
     let delet: Delete = new Delete();
     let source = undefined;
@@ -105,7 +104,9 @@ test('Delete Test 4', async () => {
     await expect(delet.execute(fep)).rejects.toThrow();
 });
 
-test('Delete Test 5', () => {
+test('Delete Test 5', async () => {
+    let delet: Delete = new Delete();
+
     var arr1: any[] = ['nocode', 'platform', 14];
     var arr2: any[] = ['nocode', 'platiform', 14];
     var obj: object = {
@@ -138,7 +139,7 @@ test('Delete Test 5', () => {
         .setSteps(new Map([]))
         .setContext(new Map([]));
 
-    delet.execute(fep);
+    await delet.execute(fep);
 
     expect(arr).toStrictEqual(res);
 });

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

@@ -3,7 +3,7 @@ import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/F
 
 const rand = new RandomInt();
 
-test(' rand int 1', () => {
+test(' rand int 1', async () => {
     let min = 100,
         max = 1000123;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
@@ -12,24 +12,24 @@ test(' rand int 1', () => {
             ['maxValue', max],
         ]),
     );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
 });
 
-test(' rand int 2', () => {
+test(' rand int 2', async () => {
     let min = 100;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
         new Map([['minValue', min]]),
     );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     expect(num).toBeLessThanOrEqual(2147483647);
     expect(num).toBeGreaterThanOrEqual(min);
 });
 
-test(' rand int 3', () => {
+test(' rand int 3', async () => {
     let min = 100,
         max = 101;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters().setArguments(
@@ -38,7 +38,7 @@ test(' rand int 3', () => {
             ['maxValue', max],
         ]),
     );
-    let num: number = rand.execute(fep).allResults()[0].getResult().get('value');
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
 
     console.log(num);
     expect(num).toBeLessThanOrEqual(max);

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -0,0 +1,89 @@
+import { KIRuntime } from '../../../src/engine/runtime/KIRuntime';
+import { EventResult } from '../../../src/engine/model/EventResult';
+import { Event } from '../../../src/engine/model/Event';
+import { FunctionDefinition } from '../../../src/engine/model/FunctionDefinition';
+import { Parameter } from '../../../src/engine/model/Parameter';
+import { FunctionExecutionParameters } from '../../../src/engine/runtime/FunctionExecutionParameters';
+import { Create } from '../../../src/engine/function/system/context/Create';
+import { SetFunction } from '../../../src/engine/function/system/context/SetFunction';
+import { GenerateEvent } from '../../../src/engine/function/system/GenerateEvent';
+import { If } from '../../../src/engine/function/system/If';
+import { RangeLoop } from '../../../src/engine/function/system/loop/RangeLoop';
+import { Statement } from '../../../src/engine/model/Statement';
+import { ParameterReference } from '../../../src/engine/model/ParameterReference';
+import { Schema } from '../../../src/engine/json/schema/Schema';
+import { KIRunFunctionRepository } from '../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../src/engine/repository/KIRunSchemaRepository';
+import { Namespaces } from '../../../src/engine/namespaces/Namespaces';
+import { FunctionSignature } from '../../../src/engine/model/FunctionSignature';
+import { AbstractFunction } from '../../../src/engine/function/AbstractFunction';
+import { FunctionOutput } from '../../../src/engine/model/FunctionOutput';
+import { HybridRepository } from '../../../src/engine/HybridRepository';
+import { Function } from '../../../src/engine/function/Function';
+
+test('KIRuntime With Definition 1', async () => {
+    var def = {
+        name: 'getAppData',
+        namespace: 'UIApp',
+        parameters: {
+            a: { parameterName: 'a', schema: { name: 'integer', type: 'INTEGER' } },
+            b: { parameterName: 'b', schema: { name: 'integer', type: 'INTEGER' } },
+            c: { parameterName: 'c', schema: { name: 'integer', type: 'INTEGER' } },
+        },
+        events: {
+            output: {
+                name: 'output',
+                parameters: { additionResult: { name: 'additionResult', type: 'INTEGER' } },
+            },
+        },
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: [
+                        { type: 'EXPRESSION', expression: 'Arguments.a' },
+                        { type: 'EXPRESSION', expression: '10 + 1' },
+                        { type: 'EXPRESSION', expression: 'Arguments.c' },
+                    ],
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                parameterMap: {
+                    eventName: [{ type: 'VALUE', value: 'output' }],
+                    results: [
+                        {
+                            type: 'VALUE',
+                            value: {
+                                name: 'additionResult',
+                                value: { isExpression: true, value: 'Steps.add.output.value' },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(
+        fd,
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).execute(
+        new FunctionExecutionParameters().setArguments(
+            new Map([
+                ['a', 7],
+                ['b', 11],
+                ['c', 13],
+            ]),
+        ),
+    );
+
+    expect(result.allResults()[0].getResult().get('additionResult')).toBe(31);
+});