@fincity/kirun-js 1.1.2 → 1.1.5

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

@@ -1,3 +1,4 @@
+import { 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';
@@ -24,3 +25,69 @@ test('Schema Validator Test 1', () => {
 
     // expect(SchemaValidator.validate([], schema, repo, 2.5)).toThrowError(new SchemaValidationException('', '2.5 is not a number of type Integer'));
 });
+
+test('Schema Validator Test 2', () => {
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+    });
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace, name): Schema | undefined {
+                if (namespace === 'Test' && name === 'Location') {
+                    return locationSchema;
+                }
+                return undefined;
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+
+    const obj = { url: 'http://xxxx.com' };
+
+    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);
+});

package/__tests__/engine/runtime/KIRuntimeTest.ts

@@ -147,9 +147,12 @@ test('KIRuntime Test 1', async () => {
                 .setParameters(
                     new Map([['Count', new Parameter('Count', Schema.ofInteger('Count'))]]),
                 ) as FunctionDefinition,
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Count', num]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Count', num]])),
+        )
     ).allResults();
     console.log('KIRunt Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);
@@ -193,9 +196,12 @@ test('KIRuntime Test 2', async () => {
                     ),
                 ]),
             ),
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', -10]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Value', -10]])),
+        )
     ).allResults();
 
     expect(out[0].getResult().get('result')).toBe(10);
@@ -238,9 +244,12 @@ test('KIRuntime Test 3', async () => {
                     ),
                 ]),
             ),
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', 27]])))
+        ).execute(
+            new FunctionExecutionParameters(
+                new KIRunFunctionRepository(),
+                new KIRunSchemaRepository(),
+            ).setArguments(new Map([['Value', 27]])),
+        )
     ).allResults();
 
     expect(out[0].getResult().get('result')).toBe(3);
@@ -335,9 +344,11 @@ test('KIRuntime Test 4', async () => {
                     ),
                 ]),
             ),
-            hybrid,
-            new KIRunSchemaRepository(),
-        ).execute(new FunctionExecutionParameters().setArguments(new Map([['Value', num]])))
+        ).execute(
+            new FunctionExecutionParameters(hybrid, new KIRunSchemaRepository()).setArguments(
+                new Map([['Value', num]]),
+            ),
+        )
     ).allResults();
     console.log('KIRun Logic : ' + (new Date().getTime() - start));
     expect(out[0].getResult().get('result')).toStrictEqual(array);

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -26,14 +26,14 @@ test('KIRuntime With Definition 1', async () => {
         name: 'getAppData',
         namespace: 'UIApp',
         parameters: {
-            a: { parameterName: 'a', schema: { name: 'integer', type: 'INTEGER' } },
-            b: { parameterName: 'b', schema: { name: 'integer', type: 'INTEGER' } },
-            c: { parameterName: 'c', schema: { name: 'integer', type: 'INTEGER' } },
+            a: { parameterName: 'a', schema: { name: 'integer', type: 'Integer' } },
+            b: { parameterName: 'b', schema: { name: 'integer', type: 'Integer' } },
+            c: { parameterName: 'c', schema: { name: 'integer', type: 'Integer' } },
         },
         events: {
             output: {
                 name: 'output',
-                parameters: { additionResult: { name: 'additionResult', type: 'INTEGER' } },
+                parameters: { additionResult: { name: 'additionResult', type: 'Integer' } },
             },
         },
         steps: {
@@ -71,12 +71,11 @@ test('KIRuntime With Definition 1', async () => {
 
     const fd = FunctionDefinition.from(def);
 
-    let result = await new KIRuntime(
-        fd,
-        new KIRunFunctionRepository(),
-        new KIRunSchemaRepository(),
-    ).execute(
-        new FunctionExecutionParameters().setArguments(
+    let result = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
             new Map([
                 ['a', 7],
                 ['b', 11],

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

@@ -1,3 +1,4 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../src';
 import { Schema } from '../../../../src/engine/json/schema/Schema';
 import { ContextElement } from '../../../../src/engine/runtime/ContextElement';
 import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
@@ -34,7 +35,10 @@ test('Expression Test', () => {
         ['loop', new Map([['iteration', new Map([['index', 2]])]])],
     ]);
 
-    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters()
+    let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
         .setArguments(new Map())
         .setContext(
             new Map([