@fincity/kirun-js 1.6.5 → 1.6.7

package/__tests__/engine/runtime/KIRuntimeNoParamMapTest.ts

@@ -0,0 +1,50 @@
+import {
+    Namespaces,
+    FunctionDefinition,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    Repository,
+    Function,
+    HybridRepository,
+} from '../../../src';
+import { Print } from '../../../src/engine/function/system/Print';
+
+test('KIRuntime Without any parameter map passed in definition', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+    } catch (e: any) {
+        console.error(e);
+    }
+});

package/__tests__/engine/runtime/KIRuntimeNoValuesTest.ts

@@ -0,0 +1,53 @@
+import {
+    Namespaces,
+    FunctionDefinition,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    Repository,
+    Function,
+    HybridRepository,
+    FunctionOutput,
+} from '../../../src';
+import { Print } from '../../../src/engine/function/system/Print';
+
+test('KIRuntime With Definition without values object inside parameter Map', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {},
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        const fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        console.log(fo);
+    } catch (e: any) {
+        console.error(e);
+    }
+});

package/__tests__/engine/runtime/KIRuntimeUndefinedParamTest.ts

@@ -0,0 +1,137 @@
+import {
+    Namespaces,
+    FunctionDefinition,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    Repository,
+    Function,
+    HybridRepository,
+    FunctionOutput,
+    Parameter,
+    Schema,
+    FunctionSignature,
+    EventResult,
+    AbstractFunction,
+} from '../../../src';
+
+class Print extends AbstractFunction {
+    private static readonly VALUES: string = 'values';
+    private static readonly VALUE: string = 'value';
+
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Print')
+        .setNamespace(Namespaces.SYSTEM)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(Print.VALUES, Schema.ofAny(Print.VALUES), true),
+                Parameter.ofEntry(Print.VALUE, Schema.ofAny(Print.VALUE)),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return Print.SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let values = context.getArguments()?.get(Print.VALUES);
+        let value = context.getArguments()?.get(Print.VALUE);
+
+        console?.log('Values', ...values);
+        console?.log('Value', value);
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}
+
+test('KIRuntime Undefined and null param type with varargs', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {
+                    values: {
+                        one: { key: 'one', type: 'VALUE', value: null },
+                        two: { key: 'two', type: 'VALUE', value: undefined },
+                        three: { key: 'three', type: 'EXPRESSION', expression: 'null' },
+                        four: { key: 'four', type: 'VALUE', value: 12 },
+                    },
+                    value: {},
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        var fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        expect(fo.allResults()).toStrictEqual([]);
+    } catch (e: any) {
+        console.error(e);
+    }
+});
+
+test('KIRuntime Undefined and null param type without varargs', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {
+                    value: {
+                        two: { key: 'two', type: 'VALUE', value: undefined },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        var fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        expect(fo.allResults()).toStrictEqual([]);
+    } catch (e: any) {
+        console.error(e);
+    }
+});

package/__tests__/engine/runtime/KIRuntimeValuesEmptyTest.ts

@@ -0,0 +1,172 @@
+import {
+    Namespaces,
+    FunctionDefinition,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    Repository,
+    Function,
+    HybridRepository,
+    FunctionOutput,
+    Parameter,
+    AbstractFunction,
+    EventResult,
+    FunctionSignature,
+    Schema,
+} from '../../../src';
+
+class Print extends AbstractFunction {
+    private static readonly VALUES: string = 'values';
+    private static readonly VALUE: string = 'value';
+
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Print')
+        .setNamespace(Namespaces.SYSTEM)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(Print.VALUES, Schema.ofAny(Print.VALUES), true),
+                Parameter.ofEntry(Print.VALUE, Schema.ofAny(Print.VALUE)),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return Print.SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let values = context.getArguments()?.get(Print.VALUES);
+        let value = context.getArguments()?.get(Print.VALUE);
+
+        console?.log('Values', ...values);
+        console?.log('Value', value);
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}
+
+test('KIRuntime With Definition no values passed ', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {
+                    values: {},
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        const fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        console.log(fo);
+    } catch (e: any) {
+        console.error(e);
+    }
+});
+
+test('KIRuntime With Definition with no value passed', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {
+                    value: {},
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        const fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        console.log(fo);
+    } catch (e: any) {
+        console.error(e);
+    }
+});
+
+test('KIRuntime With Definition with no value and values passed', async () => {
+    var def = {
+        name: 'Make an error',
+        namespace: 'UIApp',
+        steps: {
+            print: {
+                statementName: 'print',
+                namespace: 'function',
+                name: 'test',
+                parameterMap: {
+                    value: {},
+                    values: {},
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    const tstPrint = new Print();
+
+    class TestRepository implements Repository<Function> {
+        public find(namespace: string, name: string): Function | undefined {
+            return tstPrint;
+        }
+        filter(name: string): string[] {
+            throw new Error('Method not implemented.');
+        }
+    }
+
+    try {
+        const fo: FunctionOutput = await new KIRuntime(fd).execute(
+            new FunctionExecutionParameters(
+                new HybridRepository(new KIRunFunctionRepository(), new TestRepository()),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map()),
+        );
+        console.log(fo);
+    } catch (e: any) {
+        console.error(e);
+    }
+});

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -84,7 +84,6 @@ test('KIRuntime With Definition 1', async () => {
             ]),
         ),
     );
-
     expect(result.allResults()[0].getResult().get('additionResult')).toBe(31);
 });