@fincity/kirun-js 1.9.1 → 2.0.1

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

@@ -1,108 +1,151 @@
-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";
+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';
 
 const MathFunction: MathFunctionRepository = new MathFunctionRepository();
 
-test("Test Math Functions 1", async () => {
+test('Test Math Functions 1', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', 1.2]]),
-    );
-
-    expect((await MathFunction.find(Namespaces.MATH, "Ceiling")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(2);
-})
-
-test("Test Math Functions 2", () => {
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', 1.2]]));
+
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'Ceiling'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(2);
+});
+
+test('Test Math Functions 2', () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', "-1.2"]]),
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', '-1.2']]));
+
+    expect(async () =>
+        (await (await MathFunction.find(Namespaces.MATH, 'Absolute'))?.execute(fep))
+            ?.allResults()[0]
+            ?.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',
     );
+});
 
-    expect(async () => (await (MathFunction.find(Namespaces.MATH, "Absolute")?.execute(fep)))?.allResults()[0]?.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");
-})
-
-test("Test Math Functions 3", async () => {
+test('Test Math Functions 3', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', 90]]),
-    );
-
-    expect((await MathFunction.find(Namespaces.MATH, "ACosine")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(NaN);
-})
-
-test("Test Math Functions 4", () => {
-    expect(MathFunction.find(Namespaces.STRING, "ASine")).toBe(undefined);
-})
-
-test("test Math Functions 5", () => {
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', 90]]));
+
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'ACosine'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(NaN);
+});
+
+test('Test Math Functions 4', async () => {
+    expect(await MathFunction.find(Namespaces.STRING, 'ASine')).toBe(undefined);
+});
+
+test('test Math Functions 5', () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', "-1"]]),
+        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',
     );
+});
 
-    expect(async () => (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");
-})
-
-test("test Math Functions 6", async () => {
+test('test Math Functions 6', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', 1]]),
-    );
-
-    expect((await MathFunction.find(Namespaces.MATH, "Cosine")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(0.5403023058681398);
-})
-
-test("test Math Functions 7", async () => {
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', 1]]));
+
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'Cosine'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(0.5403023058681398);
+});
+
+test('test Math Functions 7', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
+        new KIRunSchemaRepository(),
     ).setArguments(
-        new Map([['value1', 2], ['value2', 3]]),
+        new Map([
+            ['value1', 2],
+            ['value2', 3],
+        ]),
     );
 
-    expect((await MathFunction.find(Namespaces.MATH, "Power")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(8);
-})
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'Power'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(8);
+});
 
-test("test Math Functions 8", () => {
+test('test Math Functions 8', () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
+        new KIRunSchemaRepository(),
     ).setArguments(
-        new Map([['value1', '1'], ['value2', '1']]),
+        new Map([
+            ['value1', '1'],
+            ['value2', '1'],
+        ]),
     );
 
-    expect(async () => (await MathFunction.find(Namespaces.MATH, "Power")?.execute(fep))?.allResults()[0]?.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");
-})
+    expect(async () =>
+        (await (await MathFunction.find(Namespaces.MATH, 'Power'))?.execute(fep))
+            ?.allResults()[0]
+            ?.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',
+    );
+});
 
-test("test Math Functions 9", async () => {
+test('test Math Functions 9', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', [3, 2, 3, 5, 3]]]),
-    );
-    expect((await MathFunction.find(Namespaces.MATH, "Add")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(16);
-})
-
-test("test Math Functions 10", async () => {
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', [3, 2, 3, 5, 3]]]));
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'Add'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(16);
+});
+
+test('test Math Functions 10', async () => {
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
-        new KIRunSchemaRepository()
-    ).setArguments(
-        new Map([['value', [3, 2]]]),
-    );
-    expect((await MathFunction.find(Namespaces.MATH, "Hypotenuse")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(3.605551275463989);
-})
+        new KIRunSchemaRepository(),
+    ).setArguments(new Map([['value', [3, 2]]]));
+    expect(
+        (await (await MathFunction.find(Namespaces.MATH, 'Hypotenuse'))?.execute(fep))
+            ?.allResults()[0]
+            ?.getResult()
+            ?.get('value'),
+    ).toBe(3.605551275463989);
+});

package/__tests__/engine/function/system/string/StringFunctionRepoTest2.ts

@@ -8,7 +8,7 @@ import { MapUtil } from '../../../../../src/engine/util/MapUtil';
 const stringRepo = new StringFunctionRepository();
 
 test('StringRepo - contains', async () => {
-    let fun = stringRepo.find(Namespaces.STRING, 'Contains');
+    let fun = await stringRepo.find(Namespaces.STRING, 'Contains');
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
         new KIRunSchemaRepository(),
@@ -82,7 +82,7 @@ test('StringRepo - contains', async () => {
 });
 
 test('string function repo 2', async () => {
-    let fun = stringRepo.find(Namespaces.STRING, 'EndsWith');
+    let fun = await stringRepo.find(Namespaces.STRING, 'EndsWith');
 
     if (!fun) {
         throw new Error('Function not available');
@@ -141,7 +141,7 @@ test('string function repo 2', async () => {
 });
 
 test('string function repo 3', async () => {
-    let fun = stringRepo.find(Namespaces.STRING, 'EndsWith');
+    let fun = await stringRepo.find(Namespaces.STRING, 'EndsWith');
 
     if (!fun) {
         throw new Error('Function not available');

package/__tests__/engine/function/system/string/StringFunctionRepoTest3.ts

@@ -8,7 +8,7 @@ import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../s
 const stringRepo = new StringFunctionRepository();
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
-    let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
+    let fun = await stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
         new KIRunSchemaRepository(),
@@ -51,7 +51,7 @@ test('StringRepo3 - EqualsIgnoreCase', async () => {
 });
 
 test('StringRepo3 - EqualsIgnoreCase', async () => {
-    let fun = stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
+    let fun = await stringRepo.find(Namespaces.STRING, 'EqualsIgnoreCase');
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
         new KIRunSchemaRepository(),

package/__tests__/engine/function/system/string/StringFunctionRepositoryTest.ts

@@ -8,7 +8,7 @@ import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../s
 const repo = new StringFunctionRepository();
 
 test('StringFunctionRepository - Trim', async () => {
-    let fun = repo.find(Namespaces.STRING, 'Trim');
+    let fun = await repo.find(Namespaces.STRING, 'Trim');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -26,7 +26,7 @@ test('StringFunctionRepository - Trim', async () => {
 });
 
 test('StringFunctionRepo -Repeat', async () => {
-    let fun = repo.find(Namespaces.STRING, 'Repeat');
+    let fun = await repo.find(Namespaces.STRING, 'Repeat');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -53,7 +53,7 @@ test('StringFunctionRepo -Repeat', async () => {
 });
 
 test('StringFunctionRepo -Lowercase', async () => {
-    let fun = repo.find(Namespaces.STRING, 'LowerCase');
+    let fun = await repo.find(Namespaces.STRING, 'LowerCase');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -79,7 +79,7 @@ test('StringFunctionRepo -Lowercase', async () => {
 });
 
 test('StringFunctionRepo -UpperCase', async () => {
-    let fun = repo.find(Namespaces.STRING, 'UpperCase');
+    let fun = await repo.find(Namespaces.STRING, 'UpperCase');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -104,7 +104,7 @@ test('StringFunctionRepo -UpperCase', async () => {
 });
 
 test('StringFunctionRepo -Blank1', async () => {
-    let fun = repo.find(Namespaces.STRING, 'IsBlank');
+    let fun = await repo.find(Namespaces.STRING, 'IsBlank');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -124,7 +124,7 @@ test('StringFunctionRepo -Blank1', async () => {
 });
 
 test('StringFunctionRepo -Blank2', async () => {
-    let fun = repo.find(Namespaces.STRING, 'IsBlank');
+    let fun = await repo.find(Namespaces.STRING, 'IsBlank');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -149,7 +149,7 @@ test('StringFunctionRepo -Blank2', async () => {
 });
 
 test('StringFunctionRepo -Empty1', async () => {
-    let fun = repo.find(Namespaces.STRING, 'IsEmpty');
+    let fun = await repo.find(Namespaces.STRING, 'IsEmpty');
     if (!fun) {
         throw new Error('Function not available');
     }
@@ -171,7 +171,7 @@ test('StringFunctionRepo -Empty1', async () => {
 });
 
 test('StringFunctionRepo -Empty2', async () => {
-    let fun = repo.find(Namespaces.STRING, 'IsEmpty');
+    let fun = await repo.find(Namespaces.STRING, 'IsEmpty');
     if (!fun) {
         throw new Error('Function not available');
     }

package/__tests__/engine/json/schema/SchemaUtil.ts

@@ -1,3 +1,3 @@
 import { SchemaUtil } from '../../../../src';
 
-test('Schema Util Test', () => {});
+test('Schema Util Test', async () => {});

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

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

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

@@ -1,38 +1,43 @@
-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";
-import { AnyOfAllOfOneOfValidator } from "../../../../../src/engine/json/schema/validator/AnyOfAllOfOneOfValidator";
-import { KIRunSchemaRepository } from "../../../../../src/engine/repository/KIRunSchemaRepository";
+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';
+import { AnyOfAllOfOneOfValidator } from '../../../../../src/engine/json/schema/validator/AnyOfAllOfOneOfValidator';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
 
 const repo = new KIRunSchemaRepository();
 
-test("Any Of All Of One Validator Test 1", () => {
+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);
-})
+});
 
-test("Any Of All Of One Validator Test 2", () => {
+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(AnyOfAllOfOneOfValidator.validate([], arraySchema, repo, [1, 2, 3])).toStrictEqual([
+        1, 2, 3,
+    ]);
+});
 
-test("Any Of All Of One Validator Test 3", () => {
-    let objSchema: Schema = Schema.ofObject("testObj").setProperties(new Map<string, Schema>([['key', Schema.ofString('key')]]));
+test('Any Of All Of One Validator Test 3', async () => {
+    let objSchema: Schema = Schema.ofObject('testObj').setProperties(
+        new Map<string, Schema>([['key', Schema.ofString('key')]]),
+    );
 
-    expect(AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { "key": "value" })).toStrictEqual({ "key": "value" });
-})
+    expect(AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { key: 'value' })).toStrictEqual({
+        key: 'value',
+    });
+});
 
-test("Any Of All Of One Validator Test 3", () => {
+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);
-})
+});
 
-test("Any Of All Of One Validator Test 3", () => {
+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);
-})
-
+});

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

@@ -11,7 +11,7 @@ import {
 
 const repo = new KIRunSchemaRepository();
 
-test('schema array contains test  ', () => {
+test('schema array contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -31,10 +31,10 @@ test('schema array contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
 });
 
-test('schema array error contains test  ', () => {
+test('schema array error contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -54,12 +54,12 @@ test('schema array error contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj];
 
-    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+    expect(ArrayValidator.validate([], schema, repo, array)).rejects.toThrow(
         'None of the items are of type contains schema',
     );
 });
 
-test('schema array min contains test  ', () => {
+test('schema array min contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -85,10 +85,10 @@ test('schema array min contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
 });
 
-test('schema array max contains test  ', () => {
+test('schema array max contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -114,10 +114,10 @@ test('schema array max contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
 });
 
-test('schema array min contains test  ', () => {
+test('schema array min contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -143,14 +143,14 @@ test('schema array min contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+    expect(ArrayValidator.validate([], schema, repo, array)).rejects.toThrow(
         'The minimum number of the items of type contains schema should be ' +
             schema.getMinContains() +
             ' but found 2',
     );
 });
 
-test('schema array max contains test  ', () => {
+test('schema array max contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -176,14 +176,14 @@ test('schema array max contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+    expect(ArrayValidator.validate([], schema, repo, array)).rejects.toThrow(
         'The maximum number of the items of type contains schema should be ' +
             schema.getMaxContains() +
             ' but found 2',
     );
 });
 
-test('schema array min error contains test  ', () => {
+test('schema array min error contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -209,14 +209,14 @@ test('schema array min error contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+    expect(ArrayValidator.validate([], schema, repo, array)).rejects.toThrow(
         'The minimum number of the items of type contains schema should be ' +
             schema.getMinContains() +
             ' but found 2',
     );
 });
 
-test('schema array min max contains test  ', () => {
+test('schema array min max contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -243,10 +243,10 @@ test('schema array min max contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toBe(array);
 });
 
-test('schema array min max contains test  ', () => {
+test('schema array min max contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -273,14 +273,14 @@ test('schema array min max contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+    expect(ArrayValidator.validate([], schema, repo, array)).rejects.toThrow(
         'The maximum number of the items of type contains schema should be ' +
             schema.getMaxContains() +
             ' but found 2',
     );
 });
 
-test('schema array min max contains without contains test  ', () => {
+test('schema array min max contains without contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -306,10 +306,10 @@ test('schema array min max contains without contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toBe(array);
 });
 
-test('schema array min max contains without contains test  ', () => {
+test('schema array min max contains without contains test  ', async () => {
     let tupleS: Schema[] = [
         Schema.ofString('item1'),
         Schema.ofInteger('item2'),
@@ -335,5 +335,5 @@ test('schema array min max contains without contains test  ', () => {
 
     let array: any[] = ['jimmy', 31, obj, true, obj1];
 
-    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+    expect(await ArrayValidator.validate([], schema, repo, array)).toBe(array);
 });

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

@@ -2,7 +2,7 @@ import { KIRunSchemaRepository, SchemaValidator } from '../../../../../src';
 import { Schema } from '../../../../../src/engine/json/schema/Schema';
 
 const repo = new KIRunSchemaRepository();
-test('schemaArray With Single Test', () => {
+test('schemaArray With Single Test', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -25,10 +25,10 @@ test('schemaArray With Single Test', () => {
         'exampleString',
     ];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrow();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrow();
 });
 
-test('schemaArray With out Single fail Test', () => {
+test('schemaArray With out Single fail Test', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -50,10 +50,10 @@ test('schemaArray With out Single fail Test', () => {
         'exampleString',
     ];
 
-    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrow();
+    expect(SchemaValidator.validate([], schema, repo, obj)).rejects.toThrow();
 });
 
-test('schemaArrayWithSingle pass Test', () => {
+test('schemaArrayWithSingle pass Test', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -75,10 +75,10 @@ test('schemaArrayWithSingle pass Test', () => {
         },
     ];
 
-    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+    expect(await SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
 });
 
-test('schemaArray With Tuple Test ', () => {
+test('schemaArray With Tuple Test ', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: {
@@ -108,10 +108,10 @@ test('schemaArray With Tuple Test ', () => {
         'mla',
     ];
 
-    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+    expect(await SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
 });
 
-test('schemaArray With out Tuple Test ', () => {
+test('schemaArray With out Tuple Test ', async () => {
     let schema = Schema.from({
         type: 'ARRAY',
         items: [
@@ -137,5 +137,5 @@ test('schemaArray With out Tuple Test ', () => {
         true,
         false,
     ];
-    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+    expect(await SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
 });