@fincity/kirun-js 1.5.2 → 1.6.3

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

@@ -0,0 +1,152 @@
+import {
+    AdditionalType,
+    ArraySchemaType,
+    ArrayValidator,
+    KIRunSchemaRepository,
+    Schema,
+    SchemaValidator,
+} from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema array validator tuple schema test for additional items with boolean different datatype', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: [
+            {
+                type: 'INTEGER',
+            },
+            {
+                type: 'STRING',
+            },
+            {
+                type: 'BOOLEAN',
+            },
+            {
+                type: 'OBJECT',
+            },
+        ],
+        additionalItems: {
+            schemaValue: {
+                type: 'OBJECT',
+            },
+        },
+    });
+
+    let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});
+
+test('schema array validator tuple schema test for additional items with boolean true datatype', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: [
+            {
+                type: 'STRING',
+            },
+            {
+                type: 'BOOLEAN',
+            },
+        ],
+        additionalItems: {
+            schemaValue: {
+                type: 'OBJECT',
+            },
+        },
+    });
+
+    let obj = ['asd', true, { a: 'b' }];
+
+    expect(SchemaValidator.validate([], schema, repo, obj)).toStrictEqual(obj);
+});
+
+test('schema array validator test for additional items with boolean false different datatype', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: { type: 'INTEGER' },
+        additionalItems: { booleanValue: false },
+    });
+    let obj = [1, 2, 3, 4, 'stringtype', true];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});
+
+test('schema array validator test for additional items with boolean true different datatype', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            type: 'INTEGER',
+        },
+        additionalItems: {
+            schemaValue: {
+                type: 'STRING',
+            },
+        },
+    });
+
+    let obj = [1, 2, 3, 'stringtype', true];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});
+
+test('schema array validator tuple schema test for additional items with boolean different datatype', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: [
+            {
+                type: 'INTEGER',
+            },
+            {
+                type: 'STRING',
+            },
+            {
+                type: 'BOOLEAN',
+            },
+        ],
+        additionalItems: {
+            schemaValue: {
+                type: 'OBJECT',
+            },
+        },
+    });
+
+    let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});
+
+test('multi level validation inner object pollution test', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            type: 'OBJECT',
+            properties: {
+                x: { type: 'INTEGER' },
+            },
+        },
+        defaultValue: [{ x: 20 }, { x: 30 }],
+    });
+
+    let xschema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            type: 'OBJECT',
+            properties: {
+                x: { type: 'INTEGER' },
+                y: { type: 'STRING', defaultValue: 'Kiran' },
+            },
+            required: ['x'],
+        },
+    });
+
+    let value = SchemaValidator.validate(
+        undefined,
+        xschema,
+        repo,
+        SchemaValidator.validate(undefined, schema, repo, undefined),
+    );
+
+    expect(schema?.getDefaultValue()[0].y).toBeUndefined();
+    expect(value[0].y).toBe('Kiran');
+});

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

@@ -0,0 +1,23 @@
+import { KIRunSchemaRepository, Schema, SchemaType, SchemaValidator } from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema Object validator test schema based old ARRAY style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { schemaValue: { type: 'ARRAY' } },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    var obj = { name: 'Kiran', num: [1, 2, 3] };
+    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});

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

@@ -0,0 +1,280 @@
+import {
+    HybridRepository,
+    KIRunSchemaRepository,
+    ObjectValidator,
+    Repository,
+    Schema,
+    SchemaType,
+    SchemaValidator,
+} from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema Object validator test boolean value', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: false,
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+        name: 'Kiran',
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { type: 'INTEGER' },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+        name: 'Kiran',
+        num: 23,
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test boolean value old style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { booleanValue: false },
+    });
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+        name: 'Kiran',
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { schemaValue: { type: 'INTEGER' } },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+        name: 'Kiran',
+        num: 23,
+    });
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old ARRAY style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: { name: { type: 'STRING' } },
+        additionalProperties: { schemaValue: { type: 'ARRAY' } },
+    });
+    expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
+
+    var obj = { name: 'Kiran', num: [1, 2, 3] };
+    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+
+    expect(() =>
+        SchemaValidator.validate([], schema!, repo, {
+            name: 'Kiran',
+            num: 23,
+            lastName: 'grandhi',
+        }),
+    ).toThrowError();
+});
+
+test('schema Object validator test schema based old Object style', () => {
+    let schema = Schema.from({
+        type: 'OBJECT',
+        properties: {
+            name: { type: 'STRING' },
+            lastname: { type: 'STRING' },
+            age: { type: 'INTEGER' },
+        },
+        additionalProperties: { schemaValue: { type: 'OBJECT' } },
+    });
+
+    var obj = { name: 'Kiran', age: 23 };
+    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+
+    var objwithAdditional = {
+        name: 'Kiran',
+        lastname: 'grandhi',
+        addresses: {
+            area: 'j.p.nagar',
+            city: 'banga',
+        },
+    };
+
+    expect(SchemaValidator.validate([], schema!, repo, objwithAdditional)).toStrictEqual(
+        objwithAdditional,
+    );
+
+    var objwithMoreAdditional = {
+        name: 'Kiran',
+        lastname: 'grandhi',
+        addresses: {
+            area: 'j.p.nagar',
+            city: 'banga',
+        },
+        city: 'kakinada',
+    };
+
+    expect(() => SchemaValidator.validate([], schema!, repo, objwithMoreAdditional)).toThrow();
+});
+
+test('Schema test with object value as null for any', () => {
+    let filterOperator = Schema.from({
+        namespace: 'test',
+        name: 'filterOperator',
+        version: 1,
+        type: 'STRING',
+        defaultValue: 'EQUALS',
+        enums: ['EQUALS', 'LESS_THAN', 'GREATER_THAN', 'LESS_THAN_EQUAL', 'BETWEEN', 'IN'],
+    });
+
+    let filterCondition = Schema.from({
+        namespace: 'test',
+        name: 'FilterCondition',
+        version: 1,
+        type: 'OBJECT',
+        properties: {
+            field: {
+                namespace: '_',
+                name: 'field',
+                version: 1,
+                type: 'STRING',
+            },
+            multiValue: {
+                namespace: '_',
+                name: 'multiValue',
+                version: 1,
+                type: 'ARRAY',
+                items: {
+                    namespace: '_',
+                    name: 'singleType',
+                    version: 1,
+                    type: [
+                        'FLOAT',
+                        'BOOLEAN',
+                        'STRING',
+                        'DOUBLE',
+                        'INTEGER',
+                        'LONG',
+                        'NULL',
+                        'ARRAY',
+                        'OBJECT',
+                    ],
+                },
+            },
+            isValue: {
+                namespace: '_',
+                name: 'isValue',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+            toValue: {
+                namespace: '_',
+                name: 'toValue',
+                version: 1,
+                type: [
+                    'FLOAT',
+                    'BOOLEAN',
+                    'STRING',
+                    'DOUBLE',
+                    'INTEGER',
+                    'LONG',
+                    'NULL',
+                    'ARRAY',
+                    'OBJECT',
+                ],
+            },
+            operator: {
+                namespace: '_',
+                version: 1,
+                ref: 'test.filterOperator',
+            },
+            negate: {
+                namespace: '_',
+                name: 'negate',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+            value: {
+                namespace: '_',
+                name: 'value',
+                version: 1,
+                type: [
+                    'FLOAT',
+                    'BOOLEAN',
+                    'STRING',
+                    'DOUBLE',
+                    'INTEGER',
+                    'LONG',
+                    'NULL',
+                    'ARRAY',
+                    'OBJECT',
+                ],
+            },
+            isToValue: {
+                namespace: '_',
+                name: 'isToValue',
+                version: 1,
+                type: 'BOOLEAN',
+                defaultValue: false,
+            },
+        },
+        additionalProperties: false,
+        required: ['operator', 'field'],
+    });
+
+    var schemaMap = new Map<string, Schema>();
+
+    schemaMap.set('filterOperator', filterOperator!);
+    schemaMap.set('FilterCondition', filterCondition!);
+
+    class TestRepository implements Repository<Schema> {
+        public find(namespace: string, name: string): Schema | undefined {
+            if (!namespace) {
+                return undefined;
+            }
+            return schemaMap.get(name);
+        }
+
+        public filter(name: string): string[] {
+            return [];
+        }
+    }
+    var repo = new HybridRepository(new TestRepository(), new KIRunSchemaRepository());
+
+    var tempOb2 = { field: 'nullcheck', operator: 'LESS_THAN', value: null, isValue: true };
+
+    var res3 = SchemaValidator.validate(undefined, filterCondition, repo, tempOb2);
+    expect(res3).toStrictEqual(tempOb2);
+});

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

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, ArraySchemaType, HybridRepository } from '../../../../../src';
+import { AdditionalType, ArraySchemaType, HybridRepository } from '../../../../../src';
 import { Schema } from '../../../../../src/engine/json/schema/Schema';
 import { SchemaType } from '../../../../../src/engine/json/schema/type/SchemaType';
 import { TypeUtil } from '../../../../../src/engine/json/schema/type/TypeUtil';
@@ -42,6 +42,12 @@ test('filter condition with ref schema', () => {
                 if (namespace !== 'Test') return undefined;
                 return schemaMap.get(name);
             },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -86,6 +92,11 @@ test('complex condition with ref schema', () => {
                 if (namespace !== 'Test') return undefined;
                 return schemaMap.get(name);
             },
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -142,7 +153,7 @@ test('filter complex condition with ref schema', () => {
             ]),
         )
         .setRequired(['operator', 'field'])
-        .setAdditionalProperties(new AdditionalPropertiesType().setBooleanValue(false));
+        .setAdditionalProperties(new AdditionalType().setBooleanValue(false));
 
     let complexOperator: Schema = Schema.ofString('complexOperator')
         .setNamespace('Test')
@@ -163,7 +174,7 @@ test('filter complex condition with ref schema', () => {
             ]),
         )
         .setRequired(['conditions', 'operator'])
-        .setAdditionalProperties(new AdditionalPropertiesType().setBooleanValue(false));
+        .setAdditionalProperties(new AdditionalType().setBooleanValue(false));
 
     var schemaMap = new Map<string, Schema>([
         ['filterOperator', filterOperator],
@@ -178,6 +189,12 @@ test('filter complex condition with ref schema', () => {
                 if (namespace !== 'Test') return undefined;
                 return schemaMap.get(name);
             },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .filter((e) => e.getFullName().toLowerCase().indexOf(name.toLowerCase()) !== -1)
+                    .map((e) => e.getFullName());
+            },
         },
         new KIRunSchemaRepository(),
     );

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

@@ -1,4 +1,4 @@
-import { AdditionalPropertiesType, HybridRepository } from '../../../../../src';
+import { AdditionalType, HybridRepository } from '../../../../../src';
 import { Schema } from '../../../../../src/engine/json/schema/Schema';
 import { SchemaType } from '../../../../../src/engine/json/schema/type/SchemaType';
 import { TypeUtil } from '../../../../../src/engine/json/schema/type/TypeUtil';
@@ -39,15 +39,13 @@ test('Schema validation when ref of ref', () => {
 
     const urlParamsSchema = Schema.ofObject('UrlParameters')
         .setNamespace('Test')
-        .setAdditionalProperties(
-            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.Location`)),
-        )
+        .setAdditionalProperties(new AdditionalType().setSchemaValue(Schema.ofRef(`Test.Location`)))
         .setDefaultValue({});
 
     const testSchema = Schema.ofObject('TestSchema')
         .setNamespace('Test')
         .setAdditionalProperties(
-            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
+            new AdditionalType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
         )
         .setDefaultValue({});
 
@@ -63,6 +61,12 @@ test('Schema validation when ref of ref', () => {
                 if (namespace !== 'Test') return undefined;
                 return schemaMap.get(name);
             },
+
+            filter(name: string): string[] {
+                return Array.from(schemaMap.values())
+                    .map((e) => e!.getFullName())
+                    .filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1);
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -95,6 +99,11 @@ test('Schema Validator Test 2', () => {
                 }
                 return undefined;
             },
+            filter(name): string[] {
+                return [locationSchema!.getFullName()].filter((n) =>
+                    n.toLowerCase().includes(name.toLowerCase()),
+                );
+            },
         },
         new KIRunSchemaRepository(),
     );
@@ -132,7 +141,14 @@ test('Schema Validator Test 3', () => {
                 }
                 return undefined;
             },
+
+            filter(name): string[] {
+                return [locationSchema!.getFullName()].filter((n) =>
+                    n.toLowerCase().includes(name.toLowerCase()),
+                );
+            },
         },
+
         new KIRunSchemaRepository(),
     );
 

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

@@ -129,7 +129,5 @@ test('String email valid case', () => {
 
     let schema: Schema = new Schema().setFormat(StringFormat.EMAIL);
 
-    console.log(StringValidator.validate([], schema, value));
-
     expect(StringValidator.validate([], schema, value)).toBe(value);
 });

package/__tests__/engine/repository/RepositoryFilterTest.ts

@@ -0,0 +1,39 @@
+import { KIRunSchemaRepository, KIRunFunctionRepository } from '../../../src';
+
+const funcRepo = new KIRunFunctionRepository();
+const schemaRepo = new KIRunSchemaRepository();
+
+test('Repository Filter Test', () => {
+    expect(funcRepo.filter('Rep')).toStrictEqual([
+        'System.String.Repeat',
+        'System.String.Replace',
+        'System.String.ReplaceFirst',
+        'System.String.PrePad',
+        'System.String.ReplaceAtGivenPosition',
+    ]);
+
+    expect(funcRepo.filter('root')).toStrictEqual([
+        'System.Math.CubeRoot',
+        'System.Math.SquareRoot',
+    ]);
+
+    expect(schemaRepo.filter('root')).toStrictEqual([]);
+
+    expect(schemaRepo.filter('rin')).toStrictEqual(['System.string']);
+
+    expect(schemaRepo.filter('ny')).toStrictEqual(['System.any']);
+
+    expect(schemaRepo.filter('')).toStrictEqual([
+        'System.any',
+        'System.boolean',
+        'System.double',
+        'System.float',
+        'System.integer',
+        'System.long',
+        'System.number',
+        'System.string',
+        'System.ParameterExpression',
+        'System.Null',
+        'System.Schema',
+    ]);
+});

package/__tests__/engine/runtime/KIRuntimeFunctionInFunction.ts

@@ -149,6 +149,12 @@ test('KIRuntime Function in Function', async () => {
             if (name === 'Third') return third;
             if (name === 'Second') return second;
         }
+
+        filter(name: string): string[] {
+            return [third.getSignature().getFullName(), second.getSignature().getFullName()].filter(
+                (e) => e.toLowerCase().includes(name.toLowerCase()),
+            );
+        }
     }
 
     const repo = new HybridRepository(new KIRunFunctionRepository(), new InternalRepository());