@fincity/kirun-js 1.1.3 → 1.1.4

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

@@ -0,0 +1,108 @@
+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 () => {
+    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", () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository()
+    ).setArguments(
+        new Map([['value', "-1.2"]]),
+    );
+
+    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 () => {
+    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", () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository()
+    ).setArguments(
+        new Map([['value', "-1"]]),
+    );
+
+    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 () => {
+    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 () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository()
+    ).setArguments(
+        new Map([['value1', 2], ['value2', 3]]),
+    );
+
+    expect((await MathFunction.find(Namespaces.MATH, "Power")?.execute(fep))?.allResults()[0]?.getResult()?.get("value")).toBe(8);
+})
+
+test("test Math Functions 8", () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository()
+    ).setArguments(
+        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");
+})
+
+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 () => {
+    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);
+})

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

@@ -0,0 +1,38 @@
+import { Maximum } from "../../../../../src/engine/function/system/math/Maximum";
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+
+const max = new Maximum();
+
+test('Minimum Test 1', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([['value', [3, 2, 3, 5, 3]]]),
+    )
+
+    expect((await max.execute(fep)).allResults()[0].getResult().get('value')).toBe(5);
+})
+
+test('Minimum Test 2', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([['value', [-1, -1, 0, -1, -2]]]),
+    )
+
+    expect((await max.execute(fep)).allResults()[0].getResult().get('value')).toBe(0);
+})
+
+test('Minimum Test 3', () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        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");
+})

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

@@ -0,0 +1,38 @@
+import { Minimum } from "../../../../../src/engine/function/system/math/Minimum";
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+
+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]]]),
+    )
+
+    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]]]),
+    )
+
+    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");
+})
+
+test('Minimum Test 3', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        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/function/system/math/RandomFloatTest.ts

@@ -0,0 +1,83 @@
+import { RandomFloat } from "../../../../../src/engine/function/system/math/RandomFloat";
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+
+const rand = new RandomFloat();
+
+test('rand Float 1', async () => {
+    let min = 1,
+        max = 10;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 2', async () => {
+    let min = 0.1,
+        max = 0.9;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 3', async () => {
+    let min = 1, max = 2147483647;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})
+
+test('rand Float 4', async () => {
+    let min = 1.1,
+        max = 1.2;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository,
+        new KIRunSchemaRepository
+    ).setArguments(
+        new Map([
+            ['minValue', min],
+            ['maxValue', max],
+        ]),
+    );
+
+    let num: number = (await rand.execute(fep)).allResults()[0].getResult().get('value');
+
+    expect(num).toBeLessThanOrEqual(max);
+    expect(num).toBeGreaterThanOrEqual(min);
+})

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

@@ -0,0 +1,38 @@
+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", () => {
+    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", () => {
+    let arraySchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.ARRAY));
+
+    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')]]));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], objSchema, repo, { "key": "value" })).toStrictEqual({ "key": "value" });
+})
+
+test("Any Of All Of One Validator Test 3", () => {
+    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", () => {
+    let nullSchema: Schema = new Schema().setType(TypeUtil.of(SchemaType.BOOLEAN));
+
+    expect(AnyOfAllOfOneOfValidator.validate([], nullSchema, repo, null)).toBe(null);
+})
+

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

@@ -53,3 +53,41 @@ test('Schema Validator Test 2', () => {
 
     expect(SchemaValidator.validate(undefined, Schema.ofRef('Test.Location'), repo, obj)).toBe(obj);
 });
+
+test('Schema Validator Test 3', () => {
+    const obj = { url: 'http://xxxx.com' };
+
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+        defaultValue: obj,
+    });
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace, name): Schema | undefined {
+                if (namespace === 'Test' && name === 'Location') {
+                    return locationSchema;
+                }
+                return undefined;
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    const obj1 = { url: 'http://yyyy.com' };
+
+    expect(
+        SchemaValidator.validate(
+            undefined,
+            Schema.ofRef('Test.Location').setDefaultValue(obj1),
+            repo,
+            undefined,
+        ),
+    ).toMatchObject(obj1);
+});