@fincity/kirun-js 1.4.4 → 1.4.6

package/__tests__/engine/json/schema/type/TypeUtilTest.ts

@@ -1,9 +1,9 @@
 import { SchemaType, TypeUtil } from '../../../../../src';
 
 test('TypeUtilTest', () => {
-    expect(TypeUtil.from('Object')?.contains(SchemaType.OBJECT)).toBeTruthy();
+    expect(TypeUtil.from('OBJECT')?.contains(SchemaType.OBJECT)).toBeTruthy();
 
-    let type = TypeUtil.from(['Object', 'String']);
+    let type = TypeUtil.from(['OBJECT', 'STRING']);
 
     expect(type?.contains(SchemaType.STRING)).toBeTruthy();
     expect(type?.contains(SchemaType.OBJECT)).toBeTruthy();

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

@@ -30,9 +30,9 @@ test('Schema validation when ref of ref', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
-            url: { name: 'url', type: 'String' },
+            url: { name: 'url', type: 'STRING' },
         },
         required: ['url'],
     });
@@ -66,7 +66,7 @@ test('Schema validation when ref of ref', () => {
         },
         new KIRunSchemaRepository(),
     );
-    const obj = { url: 'http://xxxxxx.com' };
+    const obj = { obj: { url: 'http://xxxxxx.com' } };
     const queryParams = {
         obj: { obj: { url: 'http://xxxxxx.com' } },
     };
@@ -80,9 +80,9 @@ test('Schema Validator Test 2', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
-            url: { name: 'url', type: 'String' },
+            url: { name: 'url', type: 'STRING' },
         },
         required: ['url'],
     });
@@ -116,7 +116,7 @@ test('Schema Validator Test 3', () => {
     const locationSchema = Schema.from({
         name: 'Location',
         namespace: 'Test',
-        type: 'Object',
+        type: 'OBJECT',
         properties: {
             url: { name: 'url', type: 'String' },
         },

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

@@ -0,0 +1,135 @@
+import {
+    KIRunSchemaRepository,
+    Schema,
+    SchemaType,
+    StringFormat,
+    TypeUtil,
+} from '../../../../../src';
+import { StringValidator } from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('String valid case', () => {
+    let value: String = 'surendhar';
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING));
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String invalid case', () => {
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING));
+
+    expect(() => StringValidator.validate([], schema, 123).toThrow(123 + ' is not String'));
+});
+
+test('String min length invalid', () => {
+    let value: String = 'abcd';
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMinLength(5);
+
+    expect(() =>
+        StringValidator.validate([], schema, value).toThrow(
+            'Expected a minimum of ' + value.length + ' characters',
+        ),
+    );
+});
+
+test('String max length invalid', () => {
+    let value: String = 'surendhar';
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMaxLength(8);
+
+    expect(() =>
+        StringValidator.validate([], schema, value).toThrow(
+            'Expected a maximum of ' + value.length + ' characters',
+        ),
+    );
+});
+
+test('String min length', () => {
+    let value: String = 'abcdefg';
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMinLength(5);
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String max length', () => {
+    let value: String = 'surendhar';
+    let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING)).setMaxLength(12323);
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String date invalid case', () => {
+    let value: String = '1234-12-1245';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.DATE);
+
+    expect(() =>
+        StringValidator.validate([], schema, value).toThrow(
+            value + ' is not matched with the ' + 'date pattern',
+        ),
+    );
+});
+
+test('String date valid case', () => {
+    let value: String = '2023-01-26';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.DATE);
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String time invalid case', () => {
+    let value: String = '231:45:56';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.TIME);
+
+    expect(() => StringValidator.validate([], schema, value)).toThrow(
+        value + ' is not matched with the ' + 'time pattern',
+    );
+});
+
+test('String time valid case', () => {
+    let value: String = '22:32:45';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.TIME);
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String date time invalid case', () => {
+    let value: String = '26-jan-2023 231:45:56';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.DATETIME);
+
+    expect(() => StringValidator.validate([], schema, value)).toThrow(
+        value + ' is not matched with the ' + 'date time pattern',
+    );
+});
+
+test('String date time valid case', () => {
+    let value: String = '2032-02-12T02:54:23';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.DATETIME);
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});
+
+test('String email invalid case', () => {
+    let value: String = 'testemail fai%6&8ls@gmail.com';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);
+
+    expect(() => StringValidator.validate([], schema, value)).toThrow(
+        value + ' is not matched with the ' + 'email pattern',
+    );
+});
+
+test('String email valid case', () => {
+    let value: String = 'testemaifai%6&8lworkings@magil.com';
+
+    let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);
+
+    console.log(StringValidator.validate([], schema, value));
+
+    expect(StringValidator.validate([], schema, value)).toBe(value);
+});

package/__tests__/engine/runtime/KIRuntimeExtended.ts

@@ -0,0 +1,142 @@
+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 Extended Definition', async () => {
+    var def = {
+        name: 'checkExtendedFunction',
+        namespace: 'Test',
+        parameters: {
+            a: { parameterName: 'a', schema: { name: 'INTEGER', type: 'INTEGER' } },
+        },
+        events: {
+            output: {
+                name: 'output',
+                parameters: { additionResult: { name: 'additionResult', type: 'INTEGER' } },
+            },
+        },
+        steps: {
+            add1: {
+                statementName: 'add1',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'EXPRESSION', expression: 'Arguments.a' },
+                        two: { key: 'two', type: 'VALUE', value: 1 },
+                    },
+                },
+            },
+            if1: {
+                statementName: 'if1',
+                namespace: Namespaces.SYSTEM,
+                name: 'If',
+                parameterMap: {
+                    condition: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value % 2 = 0',
+                        },
+                    },
+                },
+            },
+            add2: {
+                statementName: 'add2',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 2 },
+                    },
+                },
+                dependentStatements: {
+                    'Steps.if1.true': true,
+                },
+            },
+            add3: {
+                statementName: 'add3',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add2.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 2 },
+                    },
+                },
+            },
+            add4: {
+                statementName: 'add4',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: {
+                            key: 'one',
+                            type: 'EXPRESSION',
+                            expression: 'Steps.add1.output.value',
+                        },
+                        two: { key: 'two', type: 'VALUE', value: 1 },
+                    },
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                parameterMap: {
+                    eventName: { one: { key: 'one', type: 'VALUE', value: 'output' } },
+                    results: {
+                        one: {
+                            key: 'one',
+                            type: 'VALUE',
+                            value: {
+                                name: 'additionResult',
+                                value: { isExpression: true, value: 'Steps.add4.output.value' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(fd, true).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['a', 7]])),
+    );
+
+    expect(result.allResults()[0].getResult().get('additionResult')).toBe(9);
+});

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -72,7 +72,7 @@ test('KIRuntime With Definition 1', async () => {
 
     const fd = FunctionDefinition.from(def);
 
-    let result = await new KIRuntime(fd).execute(
+    let result = await new KIRuntime(fd, true).execute(
         new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),

package/__tests__/engine/runtime/expression/operators/unary/LogicalNotOperatorTest.ts

@@ -0,0 +1,17 @@
+import { LogicalNotOperator } from '../../../../../../src';
+
+test('Logical Not Test', () => {
+    expect(new LogicalNotOperator().apply(null)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(undefined)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(false)).toBeTruthy();
+    expect(new LogicalNotOperator().apply(0)).toBeTruthy();
+
+    expect(new LogicalNotOperator().apply(true)).toBeFalsy();
+    expect(new LogicalNotOperator().apply(1)).toBeFalsy();
+
+    expect(new LogicalNotOperator().apply({ name: 'Kiran' })).toBeFalsy();
+
+    expect(new LogicalNotOperator().apply([])).toBeFalsy();
+    expect(new LogicalNotOperator().apply('')).toBeFalsy();
+    expect(new LogicalNotOperator().apply('TRUE')).toBeFalsy();
+});