@fincity/kirun-js 1.6.17 → 1.8.0

package/__tests__/engine/function/system/loop/BreakLoopTest.ts

@@ -0,0 +1,173 @@
+import {
+    FunctionDefinition,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    KIRuntime,
+} from '../../../../../src';
+
+test('Range Loop Break Test', async () => {
+    const breakDefinition = {
+        name: 'Break Me 1',
+        events: {
+            output: {
+                name: 'output',
+                parameters: {
+                    returnValue: {
+                        schema: { type: 'ARRAY', items: { type: 'INTEGER' } },
+                    },
+                },
+            },
+        },
+        steps: {
+            create: {
+                name: 'Create',
+                namespace: 'System.Context',
+                statementName: 'create',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'array' } },
+                    schema: {
+                        one: {
+                            key: 'one',
+                            type: 'VALUE',
+                            value: { type: 'ARRAY', items: { type: 'INTEGER' } },
+                        },
+                    },
+                },
+            },
+            createSet: {
+                name: 'Set',
+                namespace: 'System.Context',
+                statementName: 'createSet',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'Context.array' } },
+                    value: { one: { key: 'one', type: 'VALUE', value: [] } },
+                },
+                dependentStatements: {
+                    'Steps.create.output': true,
+                },
+            },
+            loop: {
+                name: 'RangeLoop',
+                namespace: 'System.Loop',
+                statementName: 'loop',
+                parameterMap: {
+                    from: {
+                        one: { key: 'one', type: 'VALUE', value: 5 },
+                    },
+                    to: { one: { key: 'one', type: 'VALUE', value: 10 } },
+                    step: { one: { key: 'one', type: 'VALUE', value: 1 } },
+                },
+                dependentStatements: {
+                    'Steps.createSet.output': true,
+                },
+            },
+            insert: {
+                name: 'InsertLast',
+                namespace: 'System.Array',
+                statementName: 'insert',
+                parameterMap: {
+                    source: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Context.array' },
+                    },
+                    element: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.loop.iteration.index',
+                        },
+                    },
+                },
+                dependentStatements: {
+                    'Steps.if.false': true,
+                },
+            },
+            set: {
+                name: 'Set',
+                namespace: 'System.Context',
+                statementName: 'set',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'Context.array' } },
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.insert.output.result',
+                        },
+                    },
+                },
+            },
+            if: {
+                name: 'If',
+                namespace: 'System',
+                statementName: 'if',
+                parameterMap: {
+                    condition: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.loop.iteration.index = 7',
+                        },
+                    },
+                },
+            },
+            break: {
+                name: 'Break',
+                namespace: 'System.Loop',
+                statementName: 'break',
+                parameterMap: {
+                    stepName: { one: { key: 'one', type: 'VALUE', value: 'loop' } },
+                },
+                dependentStatements: {
+                    'Steps.if.true': true,
+                },
+            },
+            generateEvent: {
+                statementName: 'generateEvent',
+                name: 'GenerateEvent',
+                namespace: 'System',
+                parameterMap: {
+                    eventName: {
+                        '5OdGxruBiEyysESbAubdX2': {
+                            key: '5OdGxruBiEyysESbAubdX2',
+                            type: 'VALUE',
+                            expression: '',
+                            value: 'output',
+                        },
+                    },
+                    results: {
+                        '4o0c0kvVtWiGjgb37hMTBX': {
+                            key: '4o0c0kvVtWiGjgb37hMTBX',
+                            type: 'VALUE',
+                            order: 1,
+                            value: {
+                                name: 'returnValue',
+                                value: {
+                                    isExpression: true,
+                                    value: 'Context.array',
+                                },
+                            },
+                        },
+                    },
+                },
+                dependentStatements: {
+                    'Steps.loop.output': true,
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(breakDefinition);
+    const result = (
+        await new KIRuntime(fd, true).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ),
+        )
+    )
+        .next()
+        ?.getResult()
+        .get('returnValue');
+    expect(result).toMatchObject([5, 6]);
+});

package/__tests__/engine/function/system/loop/CountLoopTest.ts

@@ -43,7 +43,7 @@ test('Count Loop2', async () => {
 
     expect(iterations).toMatchObject([]);
     expect(er?.getName()).toBe('output');
-    expect(er?.getResult().get('value')).toBe(-1);
+    expect(er?.getResult().get('value')).toBe(0);
 });
 
 test('Count Loop3', async () => {

package/__tests__/engine/function/system/loop/RangeLoopTest.ts

@@ -0,0 +1,145 @@
+import {
+    FunctionDefinition,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    KIRuntime,
+} from '../../../../../src';
+
+test('Range Loop Test', async () => {
+    const breakDefinition = {
+        name: 'Break Me 1',
+        events: {
+            output: {
+                name: 'output',
+                parameters: {
+                    returnValue: {
+                        schema: { type: 'ARRAY', items: { type: 'INTEGER' } },
+                    },
+                },
+            },
+        },
+        steps: {
+            create: {
+                name: 'Create',
+                namespace: 'System.Context',
+                statementName: 'create',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'array' } },
+                    schema: {
+                        one: {
+                            key: 'one',
+                            type: 'VALUE',
+                            value: { type: 'ARRAY', items: { type: 'INTEGER' } },
+                        },
+                    },
+                },
+            },
+            createSet: {
+                name: 'Set',
+                namespace: 'System.Context',
+                statementName: 'createSet',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'Context.array' } },
+                    value: { one: { key: 'one', type: 'VALUE', value: [] } },
+                },
+                dependentStatements: {
+                    'Steps.create.output': true,
+                },
+            },
+            loop: {
+                name: 'RangeLoop',
+                namespace: 'System.Loop',
+                statementName: 'loop',
+                parameterMap: {
+                    from: {
+                        one: { key: 'one', type: 'VALUE', value: 5 },
+                    },
+                    to: { one: { key: 'one', type: 'VALUE', value: 10 } },
+                    step: { one: { key: 'one', type: 'VALUE', value: 1 } },
+                },
+                dependentStatements: {
+                    'Steps.createSet.output': true,
+                },
+            },
+            insert: {
+                name: 'InsertLast',
+                namespace: 'System.Array',
+                statementName: 'insert',
+                parameterMap: {
+                    source: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Context.array' },
+                    },
+                    element: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.loop.iteration.index',
+                        },
+                    },
+                },
+            },
+            set: {
+                name: 'Set',
+                namespace: 'System.Context',
+                statementName: 'set',
+                parameterMap: {
+                    name: { one: { key: 'one', type: 'VALUE', value: 'Context.array' } },
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.insert.output.result',
+                        },
+                    },
+                },
+            },
+            generateEvent: {
+                statementName: 'generateEvent',
+                name: 'GenerateEvent',
+                namespace: 'System',
+                parameterMap: {
+                    eventName: {
+                        '5OdGxruBiEyysESbAubdX2': {
+                            key: '5OdGxruBiEyysESbAubdX2',
+                            type: 'VALUE',
+                            expression: '',
+                            value: 'output',
+                        },
+                    },
+                    results: {
+                        '4o0c0kvVtWiGjgb37hMTBX': {
+                            key: '4o0c0kvVtWiGjgb37hMTBX',
+                            type: 'VALUE',
+                            order: 1,
+                            value: {
+                                name: 'returnValue',
+                                value: {
+                                    isExpression: true,
+                                    value: 'Context.array',
+                                },
+                            },
+                        },
+                    },
+                },
+                dependentStatements: {
+                    'Steps.loop.output': true,
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(breakDefinition);
+    const result = (
+        await new KIRuntime(fd, true).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ),
+        )
+    )
+        .next()
+        ?.getResult()
+        .get('returnValue');
+    expect(result).toMatchObject([5, 6, 7, 8, 9]);
+});

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

@@ -33,7 +33,7 @@ test('split test1', async () => {
     array.push('Driven');
     array.push('developement');
 
-    expect((await Spli.execute(fep)).allResults()[0].getResult().get('output')).toStrictEqual(
+    expect((await Spli.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(
         array,
     );
 });
@@ -66,7 +66,7 @@ test('split test2', async () => {
     array.push('m');
     array.push('nt');
 
-    expect((await Spli.execute(fep)).allResults()[0].getResult().get('output')).toStrictEqual(
+    expect((await Spli.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(
         array,
     );
 });

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

@@ -107,7 +107,6 @@ test('schemaArray With Tuple Test ', () => {
         12.34,
         'mla',
     ];
-    console.log(JSON.stringify(schema, undefined, 2));
 
     expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
 });

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

@@ -0,0 +1,47 @@
+import { Schema, SchemaType, SchemaValidator } from '../../../../../src';
+
+test('NotValidation', async () => {
+    let sch = Schema.of(
+        'Not Schema',
+        SchemaType.INTEGER,
+        SchemaType.LONG,
+        SchemaType.FLOAT,
+        SchemaType.DOUBLE,
+        SchemaType.STRING,
+    )
+        .setDefaultValue(1)
+        .setNot(Schema.of('Not Schema', SchemaType.STRING));
+
+    const value = SchemaValidator.validate(undefined, sch, undefined, 0);
+    expect(value).toBe(0);
+
+    sch = Schema.of(
+        'Not Schema',
+        SchemaType.INTEGER,
+        SchemaType.LONG,
+        SchemaType.FLOAT,
+        SchemaType.DOUBLE,
+        SchemaType.STRING,
+    )
+        .setDefaultValue(1)
+        .setNot(Schema.of('Not Schema', SchemaType.INTEGER));
+
+    expect(() => SchemaValidator.validate(undefined, sch, undefined, 0)).toThrow();
+
+    sch = Schema.of('Not Schema', SchemaType.INTEGER, SchemaType.LONG, SchemaType.FLOAT)
+        .setDefaultValue(1)
+        .setNot(new Schema().setConstant(0));
+
+    expect(() => SchemaValidator.validate(undefined, sch, undefined, 0)).toThrow();
+    expect(SchemaValidator.validate(undefined, sch, undefined, null)).toBe(1);
+    expect(SchemaValidator.validate(undefined, sch, undefined, 2)).toBe(2);
+});
+
+test('constantValidation', async () => {
+    let sch = Schema.of('Constant Schema', SchemaType.INTEGER).setConstant(1);
+
+    const value = SchemaValidator.validate(undefined, sch, undefined, 1);
+    expect(value).toBe(1);
+
+    expect(() => SchemaValidator.validate(undefined, sch, undefined, 0)).toThrow();
+});

package/__tests__/engine/runtime/KIRuntimeNoValuesTest.ts

@@ -46,7 +46,6 @@ test('KIRuntime With Definition without values object inside parameter Map', asy
                 new KIRunSchemaRepository(),
             ).setArguments(new Map()),
         );
-        console.log(fo);
     } catch (e: any) {
         console.error(e);
     }

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

@@ -0,0 +1,51 @@
+import { ObjectValueSetterExtractor } from '../../../../../src';
+
+test('ObjectValueSetterExtractor Test', async () => {
+    let store = {
+        name: 'Kiran',
+        addresses: [
+            {
+                city: 'Bangalore',
+                state: 'Karnataka',
+                country: 'India',
+            },
+            {
+                city: 'Kakinada',
+                state: 'Andhra Pradesh',
+                country: 'India',
+            },
+            { city: 'Beaverton', state: 'Oregon' },
+        ],
+        phone: {
+            home: '080-23456789',
+            office: '080-23456789',
+            mobile: '080-23456789',
+            mobile2: '503-23456789',
+        },
+        plain: [1, 2, 3, 4],
+    };
+
+    let extractor: ObjectValueSetterExtractor = new ObjectValueSetterExtractor(store, 'Store');
+
+    expect(extractor.getValue('Store.name')).toStrictEqual('Kiran');
+
+    extractor.setValue('Store.name', 'Kiran Kumar');
+    store = extractor.getStore();
+
+    expect(store.name).toStrictEqual('Kiran Kumar');
+
+    extractor.setValue('Store.addresses[0].city', 'Bengaluru');
+    expect(extractor.getValue('Store.addresses[0].city')).toStrictEqual('Bengaluru');
+
+    extractor.setValue('Store.plain[0]', '123');
+    expect(extractor.getValue('Store.plain')).toMatchObject(['123', 2, 3, 4]);
+
+    extractor.setValue('Store.plain[0]', 1, false);
+    expect(extractor.getValue('Store.plain')).toMatchObject(['123', 2, 3, 4]);
+
+    extractor.setValue('Store.plain', undefined, true, true);
+    expect(Object.keys(extractor.getValue('Store'))).toMatchObject(['name', 'addresses', 'phone']);
+
+    extractor.setValue('Store.plain', 'plainString', false, false);
+    expect(extractor.getValue('Store.plain')).toStrictEqual('plainString');
+});