@fincity/kirun-js 2.4.0 → 2.7.0

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

@@ -1,5 +1,4 @@
 import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
-import { GenericMathFunction } from '../../../../../src/engine/function/system/math/GenericMathFunction';
 import { MathFunctionRepository } from '../../../../../src/engine/function/system/math/MathFunctionRepository';
 import { Namespaces } from '../../../../../src/engine/namespaces/Namespaces';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
@@ -32,7 +31,7 @@ test('Test Math Functions 2', () => {
             ?.getResult()
             ?.get('value'),
     ).rejects.toThrowError(
-        'Value "-1.2" is not of valid type(s)\n-1.2 is not a Integer\n-1.2 is not a Long\n-1.2 is not a Float\n-1.2 is not a Double',
+        'Error while executing the function System.Math.Absolute\'s parameter value with step name \'Unknown Step\' with error : Value \"-1.2\" is not of valid type(s)\n-1.2 is not a Double\n-1.2 is not a Float\n-1.2 is not a Long\n-1.2 is not a Integer',
     );
 });
 
@@ -42,32 +41,24 @@ test('Test Math Functions 3', async () => {
         new KIRunSchemaRepository(),
     ).setArguments(new Map([['value', 90]]));
 
-    expect(
-        (await (await MathFunction.find(Namespaces.MATH, 'ACosine'))?.execute(fep))
-            ?.allResults()[0]
-            ?.getResult()
-            ?.get('value'),
-    ).toBe(NaN);
+    const func = await MathFunction.find(Namespaces.MATH, 'ACosine');
+    if (!func)
+        expect(func).toBe(undefined);
 });
 
 test('Test Math Functions 4', async () => {
     expect(await MathFunction.find(Namespaces.STRING, 'ASine')).toBe(undefined);
 });
 
-test('test Math Functions 5', () => {
+test('test Math Functions 5', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
         new KIRunSchemaRepository(),
     ).setArguments(new Map([['value', '-1']]));
 
-    expect(async () =>
-        (await (await MathFunction.find(Namespaces.MATH, 'ATangent'))?.execute(fep))
-            ?.allResults()[0]
-            ?.getResult()
-            ?.get('value'),
-    ).rejects.toThrowError(
-        'Value "-1" is not of valid type(s)\n-1 is not a Integer\n-1 is not a Long\n-1 is not a Float\n-1 is not a Double',
-    );
+    const func = await MathFunction.find(Namespaces.MATH, 'ATangent');
+    if (!func)
+        expect(func).toBe(undefined);
 });
 
 test('test Math Functions 6', async () => {
@@ -120,7 +111,7 @@ test('test Math Functions 8', () => {
             ?.getResult()
             ?.get('value'),
     ).rejects.toThrowError(
-        'Value "1" is not of valid type(s)\n1 is not a Integer\n1 is not a Long\n1 is not a Float\n1 is not a Double',
+        'Error while executing the function System.Math.Power\'s parameter value1 with step name \'Unknown Step\' with error : Value \"1\" is not of valid type(s)\n1 is not a Double\n1 is not a Float\n1 is not a Long\n1 is not a Integer',
     );
 });
 

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

@@ -34,5 +34,6 @@ test('Minimum Test 3', () => {
         new Map([['value', ["-1", -1, 0, -1, -2]]]),
     )
 
-    expect(async () => (await max.execute(fep)).allResults()[0].getResult().get('value')).rejects.toThrowError("Value \"-1\" is not of valid type(s)\n-1 is not a Integer\n-1 is not a Long\n-1 is not a Float\n-1 is not a Double");
-})
+    expect(async () => (await max.execute(fep)).allResults()[0].getResult().get('value')).rejects
+        .toThrowError("Error while executing the function System.Math.Maximum's parameter value with step name 'Unknown Step' with error : Value \"-1\" is not of valid type(s)\n-1 is not a Double\n-1 is not a Float\n-1 is not a Long\n-1 is not a Integer");
+})

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

@@ -1,4 +1,4 @@
-import { Minimum } from "../../../../../src/engine/function/system/math/Minimum";
+import { Minimum } from '../../../../../src/engine/function/system/math/Minimum';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
 import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
@@ -6,33 +6,31 @@ const min = new Minimum();
 
 test('Minimum Test 1', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
-    ).setArguments(
-        new Map([['value', [3, 2, 3, 5, 3]]]),
-    )
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', [3, 2, 3, 5, 3]]]));
 
     expect((await min.execute(fep)).allResults()[0].getResult().get('value')).toBe(2);
-})
+});
 
 test('Minimum Test 2', () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
-    ).setArguments(
-        new Map([['value', ["3", 2, 3, 5, 3]]]),
-    )
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', ['3', 2, 3, 5, 3]]]));
 
-    expect(async () => (await min.execute(fep)).allResults()[0].getResult().get('value')).rejects.toThrowError("Value \"3\" is not of valid type(s)\n3 is not a Integer\n3 is not a Long\n3 is not a Float\n3 is not a Double");
-})
+    expect(async () =>
+        (await min.execute(fep)).allResults()[0].getResult().get('value'),
+    ).rejects.toThrowError(
+        "Error while executing the function System.Math.Minimum's parameter value with step name 'Unknown Step' with error : Value \"3\" is not of valid type(s)\n3 is not a Double\n3 is not a Float\n3 is not a Long\n3 is not a Integer",
+    );
+});
 
 test('Minimum Test 3', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
-    ).setArguments(
-        new Map([['value', [-1, -2, -3, -5, -3]]]),
-    )
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', [-1, -2, -3, -5, -3]]]));
 
     expect((await min.execute(fep)).allResults()[0].getResult().get('value')).toBe(-5);
-})
+});

package/__tests__/engine/json/schema/covnertor/BooleanConvertorTest.ts

@@ -0,0 +1,55 @@
+import { BooleanConvertor } from '../../../../../src/engine/json/schema/convertor/BooleanConvertor';
+import { Schema } from '../../../../../src';
+import { ConversionMode } from '../../../../../src/engine/json/schema/convertor/enums/ConversionMode';
+import { SchemaConversionException } from '../../../../../src/engine/json/schema/convertor/exception/SchemaConversionException';
+
+const convertElement = (element: any, mode: ConversionMode) => {
+    return BooleanConvertor.convert([], new Schema(), mode, element);
+};
+
+test('Boolean convert null element (strict mode)', async () => {
+    expect(() => convertElement(null, ConversionMode.STRICT)).toThrow(SchemaConversionException);
+});
+
+test('Boolean convert true string (strict mode)', async () => {
+    const result = convertElement('true', ConversionMode.STRICT);
+    expect(result).toEqual(true);
+});
+
+test('Boolean convert false string (strict mode)', async () => {
+    const result = convertElement('false', ConversionMode.STRICT);
+    expect(result).toEqual(false);
+});
+
+test('Boolean convert one as number (strict mode)', async () => {
+    const result = convertElement(1, ConversionMode.STRICT);
+    expect(result).toEqual(true);
+});
+
+test('Boolean convert zero as number (strict mode)', async () => {
+    const result = convertElement(0, ConversionMode.STRICT);
+    expect(result).toEqual(false);
+});
+
+test('Boolean convert invalid string (strict mode)', async () => {
+    const invalid = 'invalid';
+    expect(() => convertElement(invalid, ConversionMode.STRICT)).toThrow(SchemaConversionException);
+});
+
+test('Boolean convert invalid string (lenient mode)', async () => {
+    const result = convertElement('invalid', ConversionMode.LENIENT);
+    expect(result).toEqual(null); // Assuming lenient mode returns null for invalid input
+});
+
+test('Boolean convert use default mode', async () => {
+    const defaultValue = true;
+    const schema = new Schema().setDefaultValue(defaultValue);
+    const result = BooleanConvertor.convert([], schema, ConversionMode.USE_DEFAULT, 'invalid');
+    expect(result).toEqual(defaultValue);
+});
+
+test('Boolean convert skip mode', async () => {
+    const element = 'invalid';
+    const result = convertElement(element, ConversionMode.SKIP);
+    expect(result).toEqual(element);
+});

package/__tests__/engine/json/schema/covnertor/NullConvertorTest.ts

@@ -0,0 +1,47 @@
+import { ConversionMode } from '../../../../../src/engine/json/schema/convertor/enums/ConversionMode';
+import { Schema } from '../../../../../src';
+import { NullConvertor } from '../../../../../src/engine/json/schema/convertor/NullConvertor';
+import { SchemaConversionException } from '../../../../../src/engine/json/schema/convertor/exception/SchemaConversionException';
+
+const convertElement = (mode: ConversionMode, element: any) => {
+    return NullConvertor.convert([], new Schema(), mode, element);
+};
+
+test('Null convert null element (strict mode)', async () => {
+    const result = convertElement(ConversionMode.STRICT, null);
+    expect(result).toBe(null);
+});
+
+test('Null convert null JSON element (strict mode)', async () => {
+    const result = convertElement(ConversionMode.STRICT, null);
+    expect(result).toBe(null);
+});
+
+test('Null convert string "null" (strict mode)', async () => {
+    const element = 'null';
+    const result = convertElement(ConversionMode.STRICT, element);
+    expect(result).toBe(null);
+});
+
+test('Null convert invalid element (strict mode)', async () => {
+    const element = 'invalid';
+    expect(() => convertElement(ConversionMode.STRICT, element)).toThrow(SchemaConversionException);
+});
+
+test('Null convert invalid element (lenient mode)', async () => {
+    const element = 'invalid';
+    const result = convertElement(ConversionMode.LENIENT, element);
+    expect(result).toBe(null);
+});
+
+test('Null convert use default mode', async () => {
+    const element = 'invalid';
+    const result = convertElement(ConversionMode.USE_DEFAULT, element);
+    expect(result).toBe(null);
+});
+
+test('Null convert skip mode', async () => {
+    const element = 'invalid';
+    const result = convertElement(ConversionMode.SKIP, element);
+    expect(result).toBe(element);
+});

package/__tests__/engine/json/schema/covnertor/NumberConvertorTest.ts

@@ -0,0 +1,154 @@
+import { NumberConvertor } from '../../../../../src/engine/json/schema/convertor/NumberConvertor';
+import { Schema, SchemaType } from '../../../../../src';
+import { ConversionMode } from '../../../../../src/engine/json/schema/convertor/enums/ConversionMode';
+import { SchemaConversionException } from '../../../../../src/engine/json/schema/convertor/exception/SchemaConversionException';
+
+const convertElement = (schemaType: SchemaType, mode: ConversionMode, element: any) => {
+    return NumberConvertor.convert([], schemaType, new Schema(), mode, element);
+};
+
+const convertElementWithSchema = (
+    schemaType: SchemaType,
+    schema: Schema,
+    mode: ConversionMode,
+    element: any,
+) => {
+    return NumberConvertor.convert([], schemaType, schema, mode, element);
+};
+
+test('Convert null element (strict mode)', async () => {
+    expect(() => convertElement(SchemaType.INTEGER, ConversionMode.STRICT, null)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert non-number element (strict mode)', async () => {
+    const nonNumber = 'not a number';
+    expect(() => convertElement(SchemaType.INTEGER, ConversionMode.STRICT, nonNumber)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert valid integer (strict mode)', async () => {
+    const result = convertElement(SchemaType.INTEGER, ConversionMode.STRICT, 42);
+    expect(result).toBe(42);
+});
+
+test('Convert valid long (strict mode)', async () => {
+    const result = convertElement(SchemaType.LONG, ConversionMode.STRICT, 42);
+    expect(result).toBe(42);
+});
+
+test('Convert valid double (strict mode)', async () => {
+    const result = convertElement(SchemaType.DOUBLE, ConversionMode.STRICT, 42.0);
+    expect(result).toBe(42.0);
+});
+
+test('Convert valid float (strict mode)', async () => {
+    const result = convertElement(SchemaType.FLOAT, ConversionMode.STRICT, 42.0);
+    expect(result).toBe(42.0);
+});
+
+test('Convert invalid integer (strict mode)', async () => {
+    const invalidInteger = 42.1;
+    expect(() => convertElement(SchemaType.INTEGER, ConversionMode.STRICT, invalidInteger)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert invalid long (strict mode)', async () => {
+    const invalidLong = 2312.451;
+    expect(() => convertElement(SchemaType.LONG, ConversionMode.STRICT, invalidLong)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert integer use default mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.INTEGER,
+        new Schema(),
+        ConversionMode.USE_DEFAULT,
+        42,
+    );
+    expect(result).toBe(42);
+});
+
+test('Convert integer skip mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.INTEGER,
+        new Schema(),
+        ConversionMode.SKIP,
+        null,
+    );
+    expect(result).toBe(null);
+});
+
+test('Convert integer lenient mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.INTEGER,
+        new Schema(),
+        ConversionMode.LENIENT,
+        '42',
+    );
+    expect(result).toBe(42);
+});
+
+test('Convert long use default mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.LONG,
+        new Schema(),
+        ConversionMode.USE_DEFAULT,
+        42,
+    );
+    expect(result).toBe(42);
+});
+
+test('Convert long skip mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.LONG,
+        new Schema(),
+        ConversionMode.SKIP,
+        null,
+    );
+    expect(result).toBe(null);
+});
+
+test('Convert long lenient mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.LONG,
+        new Schema(),
+        ConversionMode.LENIENT,
+        '42',
+    );
+    expect(result).toBe(42);
+});
+
+test('Convert float use default mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.FLOAT,
+        new Schema(),
+        ConversionMode.USE_DEFAULT,
+        42.0,
+    );
+    expect(result).toBe(42.0);
+});
+
+test('Convert float skip mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.FLOAT,
+        new Schema(),
+        ConversionMode.SKIP,
+        null,
+    );
+    expect(result).toBe(null);
+});
+
+test('Convert float lenient mode', async () => {
+    const result = convertElementWithSchema(
+        SchemaType.FLOAT,
+        new Schema(),
+        ConversionMode.LENIENT,
+        '42.0',
+    );
+    expect(result).toBe(42.0);
+});

package/__tests__/engine/json/schema/covnertor/StringConvertorTest.ts

@@ -0,0 +1,56 @@
+import { StringConvertor } from '../../../../../src/engine/json/schema/convertor/StringConvertor';
+import { Schema } from '../../../../../src';
+import { ConversionMode } from '../../../../../src/engine/json/schema/convertor/enums/ConversionMode';
+import { SchemaConversionException } from '../../../../../src/engine/json/schema/convertor/exception/SchemaConversionException';
+
+const convertElement = (schema: Schema, mode: ConversionMode, element: any) => {
+    return StringConvertor.convert([], schema, mode, element);
+};
+
+test('Convert valid string (strict mode)', async () => {
+    const schema = new Schema();
+    const element = 'test string';
+    const result = convertElement(schema, ConversionMode.STRICT, element);
+    expect(result).toBe('test string');
+});
+
+test('Convert null element (strict mode)', async () => {
+    const schema = new Schema();
+    expect(() => convertElement(schema, ConversionMode.STRICT, null)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert null object (strict mode)', async () => {
+    const schema = new Schema();
+    expect(() => convertElement(schema, ConversionMode.STRICT, null)).toThrow(
+        SchemaConversionException,
+    );
+});
+
+test('Convert empty element (strict mode)', async () => {
+    const schema = new Schema();
+    const element = '';
+    const result = convertElement(schema, ConversionMode.STRICT, element);
+    expect(result).toBe('');
+});
+
+test('Convert non-primitive element (strict mode)', async () => {
+    const schema = new Schema();
+    const element = 123;
+    const result = convertElement(schema, ConversionMode.STRICT, element);
+    expect(result).toBe('123');
+});
+
+test('Convert use default mode', async () => {
+    const schema = new Schema();
+    schema.setDefaultValue('default value');
+    const result = convertElement(schema, ConversionMode.USE_DEFAULT, null);
+    expect(result).toBe('default value');
+});
+
+test('Convert skip mode', async () => {
+    const schema = new Schema();
+    const result = convertElement(schema, ConversionMode.SKIP, null);
+    expect(result).toBe(null);
+});

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

@@ -9,15 +9,15 @@ const repo = new KIRunSchemaRepository();
 test('Any Of All Of One Validator Test 1', async () => {
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.INTEGER));
 
-    expect(AnyOfAllOfOneOfValidator.validate([], schema, repo, 10)).toBe(10);
+    expect(await AnyOfAllOfOneOfValidator.validate([], schema, repo, 10)).toBe(10);
 });
 
 test('Any Of All Of One Validator Test 2', async () => {
     let arraySchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.ARRAY));
 
-    expect(AnyOfAllOfOneOfValidator.validate([], arraySchema, repo, [1, 2, 3])).toStrictEqual([
-        1, 2, 3,
-    ]);
+    expect(await AnyOfAllOfOneOfValidator.validate([], arraySchema, repo, [1, 2, 3])).toStrictEqual(
+        [1, 2, 3],
+    );
 });
 
 test('Any Of All Of One Validator Test 3', async () => {
@@ -25,7 +25,9 @@ test('Any Of All Of One Validator Test 3', async () => {
         new Map<string, Schema>([['key', Schema.ofString('key')]]),
     );
 
-    expect(AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { key: 'value' })).toStrictEqual({
+    expect(
+        await AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { key: 'value' }),
+    ).toStrictEqual({
         key: 'value',
     });
 });
@@ -33,11 +35,11 @@ test('Any Of All Of One Validator Test 3', async () => {
 test('Any Of All Of One Validator Test 3', async () => {
     let nullSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.NULL));
 
-    expect(AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
+    expect(await AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
 });
 
 test('Any Of All Of One Validator Test 3', async () => {
     let nullSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.BOOLEAN));
 
-    expect(AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
+    expect(await AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
 });

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

@@ -27,13 +27,13 @@ test('NotValidation', async () => {
         .setDefaultValue(1)
         .setNot(Schema.of('Not Integer', SchemaType.INTEGER));
 
-    expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.toThrow();
+    await expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.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)).rejects.toThrow();
+    await expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.toThrow();
     expect(await SchemaValidator.validate(undefined, sch, undefined, null)).toBe(1);
     expect(await SchemaValidator.validate(undefined, sch, undefined, 2)).toBe(2);
 });
@@ -44,5 +44,5 @@ test('constantValidation', async () => {
     const value = await SchemaValidator.validate(undefined, sch, undefined, 1);
     expect(value).toBe(1);
 
-    expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.toThrow();
+    await expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.toThrow();
 });

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

@@ -1,14 +1,6 @@
-import {
-    KIRunSchemaRepository,
-    Schema,
-    SchemaType,
-    StringFormat,
-    TypeUtil,
-} from '../../../../../src';
+import { Schema, SchemaType, StringFormat, TypeUtil } from '../../../../../src';
 import { StringValidator } from '../../../../../src';
 
-const repo = new KIRunSchemaRepository();
-
 test('String valid case', async () => {
     let value: String = 'surendhar';
     let schema: Schema = new Schema().setType(TypeUtil.of(SchemaType.STRING));