@fincity/kirun-js 2.4.0 → 2.7.0

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

@@ -0,0 +1,290 @@
+import {
+    ArrayValidator,
+    BooleanValidator,
+    KIRunSchemaRepository,
+    MapUtil,
+    NumberValidator,
+    Schema,
+    SchemaType,
+    StringValidator,
+    TypeValidator,
+} from '../../../../../src';
+import { StringConvertor } from '../../../../../src/engine/json/schema/convertor/StringConvertor';
+import { ConversionMode } from '../../../../../src/engine/json/schema/convertor/enums/ConversionMode';
+import { NumberConvertor } from '../../../../../src/engine/json/schema/convertor/NumberConvertor';
+import { BooleanConvertor } from '../../../../../src/engine/json/schema/convertor/BooleanConvertor';
+import { NullConvertor } from '../../../../../src/engine/json/schema/convertor/NullConvertor';
+
+const repo = new KIRunSchemaRepository();
+
+test('Type Validator for Number', async () => {
+    const element = { value: 123 };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.INTEGER,
+        schema,
+        repo,
+        element.value,
+    );
+    expect(result).toEqual(NumberValidator.validate(SchemaType.INTEGER, [], schema, element.value));
+});
+
+test('Type Validator for String', async () => {
+    const element = { value: 'string' };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate([], SchemaType.STRING, schema, repo, element.value);
+    expect(result).toEqual(StringValidator.validate([], schema, element.value));
+});
+
+test('Type Validator for Boolean', async () => {
+    const element = { value: true };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.BOOLEAN,
+        schema,
+        repo,
+        element.value,
+    );
+    expect(result).toEqual(BooleanValidator.validate([], schema, element.value));
+});
+
+test('Type Validator for Array', async () => {
+    const schema = new Schema();
+    const array = ['abc'];
+
+    const result = await TypeValidator.validate([], SchemaType.ARRAY, schema, repo, array);
+    const expected = await ArrayValidator.validate([], schema, repo, array);
+    expect(result).toEqual(expected);
+});
+
+test('Type Validator for Null', async () => {
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate([], SchemaType.NULL, schema, repo, null);
+    expect(result).toBeNull();
+});
+
+test('Type Validator with String Conversion', async () => {
+    const element = { value: 'string' };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.STRING,
+        schema,
+        repo,
+        element.value,
+        true,
+        ConversionMode.STRICT,
+    );
+    expect(result).toEqual(
+        StringConvertor.convert([], schema, ConversionMode.STRICT, element.value),
+    );
+});
+
+test('Type Validator with Number Conversion', async () => {
+    const element = { value: '12345' };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.INTEGER,
+        schema,
+        repo,
+        element.value,
+        true,
+        ConversionMode.STRICT,
+    );
+    expect(result).toEqual(
+        NumberConvertor.convert(
+            [],
+            SchemaType.INTEGER,
+            schema,
+            ConversionMode.STRICT,
+            element.value,
+        ),
+    );
+});
+
+test('Type Validator with Boolean Conversion', async () => {
+    const element = { value: 'true' };
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.BOOLEAN,
+        schema,
+        repo,
+        element.value,
+        true,
+        ConversionMode.STRICT,
+    );
+    expect(result).toEqual(
+        BooleanConvertor.convert([], schema, ConversionMode.STRICT, element.value),
+    );
+});
+
+test('Type Validator with Null Conversion', async () => {
+    const element = null;
+    const schema = new Schema();
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.NULL,
+        schema,
+        repo,
+        element,
+        true,
+        ConversionMode.STRICT,
+    );
+    expect(result).toEqual(NullConvertor.convert([], schema, ConversionMode.STRICT, element));
+});
+
+test('Boolean Convertor Array', async () => {
+    const schema = Schema.ofArray('boolean', Schema.ofBoolean('boolean'));
+
+    const booleanArray: (string | number | boolean)[] = [true, false, 'yes', 'no', 'y', 'n', 1, 0];
+
+    const expectedArray: boolean[] = [true, false, true, false, true, false, true, false];
+
+    const result: any = await TypeValidator.validate(
+        [],
+        SchemaType.ARRAY,
+        schema,
+        repo,
+        booleanArray,
+        true,
+        ConversionMode.STRICT,
+    );
+
+    expect(result).toEqual(expectedArray);
+});
+
+test('Number Convertor Array', async () => {
+    const schema = Schema.ofArray('number', Schema.ofNumber('number'));
+
+    const numberArray = ['11', '11.12', '11192371231', '1123.123', '0'];
+
+    const expectedArray = [11, 11.12, 11192371231, 1123.123, 0];
+
+    const result = await TypeValidator.validate(
+        [],
+        SchemaType.ARRAY,
+        schema,
+        repo,
+        numberArray,
+        true,
+        ConversionMode.LENIENT,
+    );
+
+    expect(result).toEqual(expectedArray);
+});
+
+test('Object Conversion', async () => {
+    const numberArray: string[] = ['11', '11.12', '11192371231', '1123.123', '0'];
+
+    const object = {
+        int: '1997',
+        long: '123123123',
+        float: '123.12',
+        double: '123.1232',
+        booleanTrue: 'true',
+        booleanFalse: 'false',
+        string: 12314,
+        numberArray: numberArray,
+    };
+
+    const schema: Schema = Schema.ofObject('jsonObject').setProperties(
+        MapUtil.of(
+            'int',
+            Schema.ofNumber('int'),
+            'long',
+            Schema.ofLong('long'),
+            'float',
+            Schema.ofFloat('float'),
+            'double',
+            Schema.ofNumber('double'),
+            'booleanTrue',
+            Schema.ofBoolean('booleanTrue'),
+            'booleanFalse',
+            Schema.ofBoolean('booleanFalse'),
+            'string',
+            Schema.ofString('string'),
+            'numberArray',
+            Schema.ofArray('number', Schema.ofNumber('number')),
+        ),
+    );
+
+    const expectedObject = {
+        int: 1997,
+        long: 123123123,
+        float: 123.12,
+        double: 123.1232,
+        booleanTrue: true,
+        booleanFalse: false,
+        string: '12314',
+        numberArray: [11, 11.12, 11192371231, 1123.123, 0],
+    };
+
+    const result: any = await TypeValidator.validate(
+        [],
+        SchemaType.OBJECT,
+        schema,
+        repo,
+        object,
+        true,
+        ConversionMode.STRICT,
+    );
+
+    expect(result).toEqual(expectedObject);
+});
+
+test('Object of Object Conversion', async () => {
+    const innerObject = {
+        innerInt: '42',
+        innerString: 'innerValue',
+    };
+
+    const outerObject = {
+        innerObject: innerObject,
+        outerInt: '100',
+    };
+
+    const innerSchema: Schema = Schema.ofObject('innerObject').setProperties(
+        MapUtil.of(
+            'innerInt',
+            Schema.ofNumber('innerInt'),
+            'innerString',
+            Schema.ofString('innerString'),
+        ),
+    );
+
+    const outerSchema: Schema = Schema.ofObject('outerObject').setProperties(
+        MapUtil.of('innerObject', innerSchema, 'outerInt', Schema.ofNumber('outerInt')),
+    );
+
+    const expectedOuterObject = {
+        innerObject: {
+            innerInt: 42,
+            innerString: 'innerValue',
+        },
+        outerInt: 100,
+    };
+
+    const result: any = await TypeValidator.validate(
+        [],
+        SchemaType.OBJECT,
+        outerSchema,
+        repo,
+        outerObject,
+        true,
+        ConversionMode.STRICT,
+    );
+
+    expect(result).toEqual(expectedOuterObject);
+});

package/__tests__/engine/runtime/expression/ExpressionEvaluationTest.ts

@@ -139,6 +139,86 @@ test('Expression Test', () => {
     );
 });
 
+test('Expression Evaluation with Square Access Bracket', () => {
+    let phone = { phone1: '1234', phone2: '5678', phone3: '5678' };
+
+    let address = {
+        line1: 'Flat 202, PVR Estates',
+        line2: 'Nagvara',
+        city: 'Benguluru',
+        pin: '560048',
+        phone: phone,
+    };
+
+    let arr = [10, 20, 30];
+
+    let obj = {
+        studentName: 'Kumar',
+        math: 20,
+        isStudent: true,
+        address: address,
+        array: arr,
+        num: 1,
+    };
+
+    let inMap: Map<string, any> = new Map();
+    inMap.set('name', 'Kiran');
+    inMap.set('obj', obj);
+
+    let output: Map<string, Map<string, Map<string, any>>> = new Map([
+        ['step1', new Map([['output', inMap]])],
+    ]);
+
+    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(new Map())
+        .setContext(new Map())
+        .setSteps(output);
+
+    // New test cases for square access bracket using parameters value map
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.phone.phone2 = Steps.step1.output.obj["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["phone"]["phone2"] = Steps.step1.output.obj["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"].phone["phone2"] != Steps.step1.output.address.obj.phone.phone1')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"]["phone"]["phone2"] != Steps.step1.output.address.obj.phone.phone1')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj["address"]["phone"]["phone2"] != Steps.step1.output["address"]["phone"]["phone2"]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(true);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1] + 2')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(32);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1] + Steps.step1.output.obj.array[Steps.step1.output.obj["num"] + 1]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(60);
+
+    expect(
+        new ExpressionEvaluator('Steps.step1.output.obj.array[Steps.step1.output.obj.num + 1] + Steps.step1.output.obj.array[Steps.step1.output.obj.num + 1]')
+            .evaluate(parameters.getValuesMap())
+    ).toBe(60);
+});
+
 test('ExpressionEvaluation deep tests', () => {
     let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
         new Map<string, any>([

package/__tests__/engine/runtime/expression/ExpressionEvaluatorStringLiteralTest.ts

@@ -4,7 +4,7 @@ import {
     MapUtil,
     TokenValueExtractor,
 } from '../../../../src';
-import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+import { ExpressionEvaluator } from '../../../../src';
 
 test('Expression with String Literal - 1 ', () => {
     let ex: Expression = new Expression("'ki/run'+'ab'");
@@ -98,3 +98,75 @@ test('Expression with String Literal - 2 ', () => {
     ev = new ExpressionEvaluator('2.val');
     expect(ev.evaluate(valuesMap)).toBe('2.val');
 });
+
+test('Testing for string length with object', () => {
+    const jsonObj = {
+        greeting: 'hello',
+        name: 'surendhar'
+    };
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'surendhar '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+            ['obj', jsonObj],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator('Arguments.a.length');
+    expect(ev.evaluate(valuesMap)).toBe(10);
+
+    ev = new ExpressionEvaluator('Arguments.b.length');
+    expect(() => ev.evaluate(valuesMap)).toThrow();
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting.length * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting.length * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj.name.length ? "fun" : "not Fun"');
+    expect(ev.evaluate(valuesMap)).toBe('fun');
+});
+
+test('Testing for string length with square brackets', () => {
+    const jsonObj = {
+        greeting: 'hello',
+        name: 'surendhar'
+    };
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'surendhar '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+            ['obj', jsonObj],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator('Arguments.a["length"]');
+    expect(ev.evaluate(valuesMap)).toBe(10);
+
+    ev = new ExpressionEvaluator('Arguments.b["length"]');
+    expect(() => ev.evaluate(valuesMap)).toThrow();
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting["length"] * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj.greeting["length"] * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj["greeting"]["length"] * "S"');
+    expect(ev.evaluate(valuesMap)).toBe('SSSSS');
+
+    ev = new ExpressionEvaluator('Arguments.obj["greeting"]["length"] * "SP"');
+    expect(ev.evaluate(valuesMap)).toBe('SPSPSPSPSP');
+
+    ev = new ExpressionEvaluator('Arguments.obj.name["length"] ? "fun" : "not Fun"');
+    expect(ev.evaluate(valuesMap)).toBe('fun');
+});