@fincity/kirun-js 1.9.0 → 2.0.0

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

@@ -9,7 +9,7 @@ import {
 
 const repo = new KIRunSchemaRepository();
 
-test('schema array validator test for single', () => {
+test('schema array validator test for single', async () => {
     let ast = new ArraySchemaType();
     ast.setSingleSchema(Schema.ofInteger('ast'));
 
@@ -17,10 +17,10 @@ test('schema array validator test for single', () => {
 
     let arr = [12, 23, 54, 45];
 
-    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+    expect(await ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
 });
 
-test('schema array validator test for tuple', () => {
+test('schema array validator test for tuple', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -34,10 +34,10 @@ test('schema array validator test for tuple', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }];
 
-    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+    expect(await ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
 });
 
-test('schema array validator test for single', () => {
+test('schema array validator test for single', async () => {
     let ast = new ArraySchemaType();
     ast.setSingleSchema(Schema.ofInteger('ast'));
 
@@ -47,10 +47,10 @@ test('schema array validator test for single', () => {
 
     let arr = [12, 23, 54, 45];
 
-    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+    expect(await ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
 });
 
-test('schema array validator test for tuple', () => {
+test('schema array validator test for tuple', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -66,10 +66,10 @@ test('schema array validator test for tuple', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4];
 
-    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+    expect(await ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
 });
 
-test('schema array validator test for tuple with add schema', () => {
+test('schema array validator test for tuple with add schema', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -85,10 +85,10 @@ test('schema array validator test for tuple with add schema', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2];
 
-    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+    expect(await ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
 });
 
-test('schema array validator test for tuple with add schema fail', () => {
+test('schema array validator test for tuple with add schema fail', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -104,10 +104,10 @@ test('schema array validator test for tuple with add schema fail', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4, 'surendhar'];
 
-    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+    expect(ArrayValidator.validate([], schema, repo, arr)).rejects.toThrow();
 });
 
-test('schema array validator test for tuple with add schema fail', () => {
+test('schema array validator test for tuple with add schema fail', async () => {
     let tupleS: Schema[] = [Schema.ofInteger('item1'), Schema.ofString('item2')];
 
     let ast = new ArraySchemaType();
@@ -119,10 +119,10 @@ test('schema array validator test for tuple with add schema fail', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4, ['ve', 23, 'ctor']];
 
-    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+    expect(ArrayValidator.validate([], schema, repo, arr)).rejects.toThrow();
 });
 
-test('schema array validator test for single with additional', () => {
+test('schema array validator test for single with additional', async () => {
     let ast = new ArraySchemaType();
     ast.setSingleSchema(Schema.ofInteger('ast'));
 
@@ -132,10 +132,10 @@ test('schema array validator test for single with additional', () => {
 
     let arr = [12, 23, 54, 45, 'abcd', 'df'];
 
-    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+    expect(ArrayValidator.validate([], schema, repo, arr)).rejects.toThrow();
 });
 
-test('schema array validator test for tuple without additional', () => {
+test('schema array validator test for tuple without additional', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -149,10 +149,10 @@ test('schema array validator test for tuple without additional', () => {
 
     let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 'add'];
 
-    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+    expect(ArrayValidator.validate([], schema, repo, arr)).rejects.toThrow();
 });
 
-test('schema array validator tuple schema with json object', () => {
+test('schema array validator tuple schema with json object', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -166,10 +166,10 @@ test('schema array validator tuple schema with json object', () => {
 
     let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });
 
-test('schema array validator tuple schema similar to json object', () => {
+test('schema array validator tuple schema similar to json object', async () => {
     let tupleS: Schema[] = [
         Schema.ofInteger('item1'),
         Schema.ofString('item2'),
@@ -187,5 +187,5 @@ test('schema array validator tuple schema similar to json object', () => {
 
     let obj = [1, 'asd', true, { val: 'stringtype' }, false];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });

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

@@ -9,7 +9,7 @@ import {
 
 const repo = new KIRunSchemaRepository();
 
-test('schema array validator tuple schema test for additional items with boolean different datatype', () => {
+test('schema array validator tuple schema test for additional items with boolean different datatype', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: [
@@ -35,10 +35,10 @@ test('schema array validator tuple schema test for additional items with boolean
 
     let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });
 
-test('schema array validator tuple schema test for additional items with boolean true datatype', () => {
+test('schema array validator tuple schema test for additional items with boolean true datatype', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: [
@@ -58,10 +58,10 @@ test('schema array validator tuple schema test for additional items with boolean
 
     let obj = ['asd', true, { a: 'b' }];
 
-    expect(SchemaValidator.validate([], schema, repo, obj)).toStrictEqual(obj);
+    expect(await SchemaValidator.validate([], schema, repo, obj)).toStrictEqual(obj);
 });
 
-test('schema array validator test for additional items with boolean false different datatype', () => {
+test('schema array validator test for additional items with boolean false different datatype', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: { type: 'INTEGER' },
@@ -69,10 +69,10 @@ test('schema array validator test for additional items with boolean false differ
     });
     let obj = [1, 2, 3, 4, 'stringtype', true];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });
 
-test('schema array validator test for additional items with boolean true different datatype', () => {
+test('schema array validator test for additional items with boolean true different datatype', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -87,10 +87,10 @@ test('schema array validator test for additional items with boolean true differe
 
     let obj = [1, 2, 3, 'stringtype', true];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });
 
-test('schema array validator tuple schema test for additional items with boolean different datatype', () => {
+test('schema array validator tuple schema test for additional items with boolean different datatype', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: [
@@ -113,10 +113,10 @@ test('schema array validator tuple schema test for additional items with boolean
 
     let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrowError();
 });
 
-test('multi level validation inner object pollution test', () => {
+test('multi level validation inner object pollution test', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -140,11 +140,11 @@ test('multi level validation inner object pollution test', () => {
         },
     });
 
-    let value = SchemaValidator.validate(
+    let value = await SchemaValidator.validate(
         undefined,
         xschema,
         repo,
-        SchemaValidator.validate(undefined, schema, repo, undefined),
+        await SchemaValidator.validate(undefined, schema, repo, undefined),
     );
 
     expect(schema?.getDefaultValue()[0].y).toBeUndefined();

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

@@ -10,9 +10,10 @@ test('NotValidation', async () => {
         SchemaType.STRING,
     )
         .setDefaultValue(1)
-        .setNot(Schema.of('Not Schema', SchemaType.STRING));
+        .setNot(Schema.of('Not String', SchemaType.STRING));
 
-    const value = SchemaValidator.validate(undefined, sch, undefined, 0);
+    const value = await SchemaValidator.validate(undefined, sch, undefined, 0);
+    console.log(value);
     expect(value).toBe(0);
 
     sch = Schema.of(
@@ -24,24 +25,24 @@ test('NotValidation', async () => {
         SchemaType.STRING,
     )
         .setDefaultValue(1)
-        .setNot(Schema.of('Not Schema', SchemaType.INTEGER));
+        .setNot(Schema.of('Not Integer', SchemaType.INTEGER));
 
-    expect(() => SchemaValidator.validate(undefined, sch, undefined, 0)).toThrow();
+    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)).toThrow();
-    expect(SchemaValidator.validate(undefined, sch, undefined, null)).toBe(1);
-    expect(SchemaValidator.validate(undefined, sch, undefined, 2)).toBe(2);
+    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);
 });
 
 test('constantValidation', async () => {
     let sch = Schema.of('Constant Schema', SchemaType.INTEGER).setConstant(1);
 
-    const value = SchemaValidator.validate(undefined, sch, undefined, 1);
+    const value = await SchemaValidator.validate(undefined, sch, undefined, 1);
     expect(value).toBe(1);
 
-    expect(() => SchemaValidator.validate(undefined, sch, undefined, 0)).toThrow();
+    expect(SchemaValidator.validate(undefined, sch, undefined, 0)).rejects.toThrow();
 });

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

@@ -0,0 +1,13 @@
+import { Schema, SchemaValidator } from '../../../../../src';
+
+test('Check for valid Null value', async () => {
+    let schema = Schema.from({
+        type: 'NULL',
+    });
+
+    expect(async () => SchemaValidator.validate([], schema!, undefined, 23)).rejects.toThrowError();
+    expect(async () => SchemaValidator.validate([], schema!, undefined, 0)).rejects.toThrowError();
+    expect(async () => SchemaValidator.validate([], schema!, undefined, '')).rejects.toThrowError();
+    expect(await SchemaValidator.validate([], schema!, undefined, null)).toBeNull();
+    expect(await SchemaValidator.validate([], schema!, undefined, undefined)).toBeUndefined();
+});

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

@@ -2,7 +2,7 @@ import { KIRunSchemaRepository, Schema, SchemaType, SchemaValidator } from '../.
 
 const repo = new KIRunSchemaRepository();
 
-test('schema Object validator test schema based old ARRAY style', () => {
+test('schema Object validator test schema based old ARRAY style', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
@@ -11,13 +11,13 @@ test('schema Object validator test schema based old ARRAY style', () => {
     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(await SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, {
             name: 'Kiran',
             num: 23,
             lastName: 'grandhi',
         }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });

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

@@ -10,7 +10,7 @@ import {
 
 const repo = new KIRunSchemaRepository();
 
-test('schema Object validator test boolean value', () => {
+test('schema Object validator test boolean value', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
@@ -18,16 +18,16 @@ test('schema Object validator test boolean value', () => {
     });
     expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
 
-    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+    expect(await SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
         name: 'Kiran',
     });
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });
 
-test('schema Object validator test schema based', () => {
+test('schema Object validator test schema based', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
@@ -35,37 +35,39 @@ test('schema Object validator test schema based', () => {
     });
     expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
 
-    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+    expect(
+        await SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 }),
+    ).toStrictEqual({
         name: 'Kiran',
         num: 23,
     });
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, {
             name: 'Kiran',
             num: 23,
             lastName: 'grandhi',
         }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });
 
-test('schema Object validator test boolean value old style', () => {
+test('schema Object validator test boolean value old style', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
         additionalProperties: { booleanValue: false },
     });
 
-    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
+    expect(await SchemaValidator.validate([], schema!, repo, { name: 'Kiran' })).toStrictEqual({
         name: 'Kiran',
     });
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, { name: 'Kiran', lastName: 'Grandhi' }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });
 
-test('schema Object validator test schema based old style', () => {
+test('schema Object validator test schema based old style', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
@@ -73,21 +75,23 @@ test('schema Object validator test schema based old style', () => {
     });
     expect(schema?.getType()?.contains(SchemaType.OBJECT)).toBe(true);
 
-    expect(SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 })).toStrictEqual({
+    expect(
+        await SchemaValidator.validate([], schema!, repo, { name: 'Kiran', num: 23 }),
+    ).toStrictEqual({
         name: 'Kiran',
         num: 23,
     });
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, {
             name: 'Kiran',
             num: 23,
             lastName: 'grandhi',
         }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });
 
-test('schema Object validator test schema based old ARRAY style', () => {
+test('schema Object validator test schema based old ARRAY style', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: { name: { type: 'STRING' } },
@@ -96,18 +100,18 @@ test('schema Object validator test schema based old ARRAY style', () => {
     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(await SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
 
-    expect(() =>
+    expect(
         SchemaValidator.validate([], schema!, repo, {
             name: 'Kiran',
             num: 23,
             lastName: 'grandhi',
         }),
-    ).toThrowError();
+    ).rejects.toThrowError();
 });
 
-test('schema Object validator test schema based old Object style', () => {
+test('schema Object validator test schema based old Object style', async () => {
     let schema = Schema.from({
         type: 'OBJECT',
         properties: {
@@ -119,7 +123,7 @@ test('schema Object validator test schema based old Object style', () => {
     });
 
     var obj = { name: 'Kiran', age: 23 };
-    expect(SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
+    expect(await SchemaValidator.validate([], schema!, repo, obj)).toStrictEqual(obj);
 
     var objwithAdditional = {
         name: 'Kiran',
@@ -130,7 +134,7 @@ test('schema Object validator test schema based old Object style', () => {
         },
     };
 
-    expect(SchemaValidator.validate([], schema!, repo, objwithAdditional)).toStrictEqual(
+    expect(await SchemaValidator.validate([], schema!, repo, objwithAdditional)).toStrictEqual(
         objwithAdditional,
     );
 
@@ -144,10 +148,10 @@ test('schema Object validator test schema based old Object style', () => {
         city: 'kakinada',
     };
 
-    expect(() => SchemaValidator.validate([], schema!, repo, objwithMoreAdditional)).toThrow();
+    expect(SchemaValidator.validate([], schema!, repo, objwithMoreAdditional)).rejects.toThrow();
 });
 
-test('Schema test with object value as null for any', () => {
+test('Schema test with object value as null for any', async () => {
     let filterOperator = Schema.from({
         namespace: 'test',
         name: 'filterOperator',
@@ -260,14 +264,14 @@ test('Schema test with object value as null for any', () => {
     schemaMap.set('FilterCondition', filterCondition!);
 
     class TestRepository implements Repository<Schema> {
-        public find(namespace: string, name: string): Schema | undefined {
+        public async find(namespace: string, name: string): Promise<Schema | undefined> {
             if (!namespace) {
                 return undefined;
             }
             return schemaMap.get(name);
         }
 
-        public filter(name: string): string[] {
+        public async filter(name: string): Promise<string[]> {
             return [];
         }
     }
@@ -275,6 +279,6 @@ test('Schema test with object value as null for any', () => {
 
     var tempOb2 = { field: 'nullcheck', operator: 'LESS_THAN', value: null, isValue: true };
 
-    var res3 = SchemaValidator.validate(undefined, filterCondition, repo, tempOb2);
+    var res3 = await SchemaValidator.validate(undefined, filterCondition, repo, tempOb2);
     expect(res3).toStrictEqual(tempOb2);
 });