@fincity/kirun-js 1.4.9 → 1.4.11

package/__tests__/engine/function/system/string/ToStringTest.ts

@@ -38,7 +38,20 @@ test('toString test2', async () => {
     fep.setArguments(MapUtil.of('anytype', array));
 
     expect((await toString.execute(fep)).allResults()[0].getResult().get('result')).toBe(
-        '["I","am","using","eclipse","to","test","the","changes","with","test","Driven","developement"]',
+        `[
+  "I",
+  "am",
+  "using",
+  "eclipse",
+  "to",
+  "test",
+  "the",
+  "changes",
+  "with",
+  "test",
+  "Driven",
+  "developement"
+]`,
     );
 });
 

package/__tests__/engine/repository/KIRunFunctionRepositoryTest.ts

@@ -0,0 +1,29 @@
+import { KIRunFunctionRepository, Namespaces } from '../../../src';
+
+test('KIRunFunctionRepository Test', () => {
+    const repo = new KIRunFunctionRepository();
+
+    let fun = repo.find(Namespaces.STRING, 'ToString');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('ToString');
+
+    fun = repo.find(Namespaces.STRING, 'IndexOfWithStartPoint');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('IndexOfWithStartPoint');
+
+    fun = repo.find(Namespaces.SYSTEM_ARRAY, 'Compare');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('Compare');
+
+    fun = repo.find(Namespaces.MATH, 'RandomInt');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('RandomInt');
+
+    fun = repo.find(Namespaces.MATH, 'Exponential');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('Exponential');
+
+    fun = repo.find(Namespaces.SYSTEM, 'If');
+    expect(fun).toBeTruthy();
+    expect(fun?.getSignature().getName()).toBe('If');
+});

package/__tests__/engine/runtime/KIRuntimeFunctionInFunction.ts

@@ -0,0 +1,163 @@
+import {
+    Function,
+    FunctionDefinition,
+    HybridRepository,
+    KIRunFunctionRepository,
+    Repository,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunSchemaRepository,
+} from '../../../src';
+
+test('KIRuntime Function in Function', async () => {
+    const first = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+        "name": "First",
+        "namespace": "Internal",
+        "events": {
+            "output": {
+                "name": "output",
+                "parameters": { "aresult": { "name": "aresult", "type": "INTEGER" } }
+            }
+        },
+        "steps": {
+            "exSecond": {
+                "statementName": "exSecond",
+                "name": "Second",
+                "namespace": "Internal",
+                "parameterMap": {
+                    "value" : { "one" : { "key": "one", "type": "VALUE", "value": 2 } }
+                }
+            },
+            "exThird": {
+                "statementName": "exThird",
+                "name": "Third",
+                "namespace": "Internal",
+                "parameterMap": {
+                    "value" : { "one" : { "key": "one", "type": "VALUE", "value": 3 } }
+                }
+            },
+            "genOutput": {
+                "statementName": "genOutput",
+                "namespace": "System",
+                "name": "GenerateEvent",
+                "dependentStatements": {
+                    "Steps.exSecond.output": true,
+                    "Steps.exThird.output": true
+                },
+                "parameterMap": {
+                    "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } },
+                    "results": {
+                        "one": {
+                            "key": "one",
+                            "type": "VALUE",
+                            "value": {
+                                "name": "aresult",
+                                "value": { "isExpression": true, "value": "Steps.exThird.output.result" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }`),
+        ),
+        true,
+    );
+
+    const second = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+            "name": "Second",
+            "namespace": "Internal",
+            "parameters": {
+                "value": { "parameterName": "value", "schema": { "name": "INTEGER", "type": "INTEGER" } } },
+            "events": {
+                "output": {
+                    "name": "output",
+                    "parameters": { "result": { "name": "result", "type": "INTEGER" } }
+                }
+            },
+            "steps": {
+                "genOutput": {
+                    "statementName": "genOutput",
+                    "namespace": "System",
+                    "name": "GenerateEvent",
+                    "parameterMap": {
+                        "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } },
+                        "results": {
+                            "one": {
+                                "key": "one",
+                                "type": "VALUE",
+                                "value": {
+                                    "name": "result",
+                                    "value": { "isExpression": true, "value": "Arguments.value * 2" }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }`),
+        ),
+        true,
+    );
+
+    const third = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+            "name": "Third",
+            "namespace": "Internal",
+            "parameters": {
+                "value": { "parameterName": "value", "schema": { "name": "INTEGER", "type": "INTEGER" } } },
+            "events": {
+                "output": {
+                    "name": "output",
+                    "parameters": { "result": { "name": "result", "type": "INTEGER" } }
+                }
+            },
+            "steps": {
+                "genOutput": {
+                    "statementName": "genOutput",
+                    "namespace": "System",
+                    "name": "GenerateEvent",
+                    "parameterMap": {
+                        "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } },
+                        "results": {
+                            "one": {
+                                "key": "one",
+                                "type": "VALUE",
+                                "value": {
+                                    "name": "result",
+                                    "value": { "isExpression": true, "value": "Arguments.value * 3" }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }`),
+        ),
+        true,
+    );
+
+    class InternalRepository implements Repository<Function> {
+        find(namespace: string, name: string): Function | undefined {
+            if (namespace !== 'Internal') return;
+
+            if (name === 'Third') return third;
+            if (name === 'Second') return second;
+        }
+    }
+
+    const repo = new HybridRepository(new KIRunFunctionRepository(), new InternalRepository());
+
+    const results = (
+        await first.execute(
+            new FunctionExecutionParameters(repo, new KIRunSchemaRepository(), 'Testing'),
+        )
+    ).next();
+
+    expect(results?.getResult().get('aresult')).toBe(9);
+});