@fincity/kirun-js 1.3.1 → 1.4.1

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

@@ -1,4 +1,4 @@
-import { HybridRepository } from '../../../../../src';
+import { AdditionalPropertiesType, 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';
@@ -26,6 +26,56 @@ 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 validation when ref of ref', () => {
+    const locationSchema = Schema.from({
+        name: 'Location',
+        namespace: 'Test',
+        type: 'Object',
+        properties: {
+            url: { name: 'url', type: 'String' },
+        },
+        required: ['url'],
+    });
+
+    const urlParamsSchema = Schema.ofObject('UrlParameters')
+        .setNamespace('Test')
+        .setAdditionalProperties(
+            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.Location`)),
+        )
+        .setDefaultValue({});
+
+    const testSchema = Schema.ofObject('TestSchema')
+        .setNamespace('Test')
+        .setAdditionalProperties(
+            new AdditionalPropertiesType().setSchemaValue(Schema.ofRef(`Test.UrlParameters`)),
+        )
+        .setDefaultValue({});
+
+    const schemaMap = new Map([
+        ['Location', locationSchema],
+        ['UrlParameters', urlParamsSchema],
+        ['TestSchema', testSchema],
+    ]);
+
+    const repo = new HybridRepository<Schema>(
+        {
+            find(namespace: string, name: string): Schema | undefined {
+                if (namespace !== 'Test') return undefined;
+                return schemaMap.get(name);
+            },
+        },
+        new KIRunSchemaRepository(),
+    );
+    const obj = { url: 'http://xxxxxx.com' };
+    const queryParams = {
+        obj: { obj: { url: 'http://xxxxxx.com' } },
+    };
+
+    expect(
+        SchemaValidator.validate(undefined, Schema.ofRef('Test.TestSchema'), repo, queryParams),
+    ).toBe(queryParams);
+});
+
 test('Schema Validator Test 2', () => {
     const locationSchema = Schema.from({
         name: 'Location',

package/__tests__/engine/runtime/KIRuntimeWithDefinitionTest.ts

@@ -87,3 +87,40 @@ test('KIRuntime With Definition 1', async () => {
 
     expect(result.allResults()[0].getResult().get('additionResult')).toBe(31);
 });
+
+test('KIRuntime With Definition 2', async () => {
+    var def = {
+        name: 'checkWithNoParamsOrEvents',
+        namespace: 'UIApp',
+        steps: {
+            add: {
+                statementName: 'add',
+                namespace: Namespaces.MATH,
+                name: 'Add',
+                parameterMap: {
+                    value: {
+                        one: { key: 'one', type: 'VALUE', value: 2 },
+                        two: { key: 'two', type: 'VALUE', value: 5 },
+                    },
+                },
+            },
+            genOutput: {
+                statementName: 'genOutput',
+                namespace: Namespaces.SYSTEM,
+                name: 'GenerateEvent',
+                dependentStatements: { 'Steps.add.output': true },
+            },
+        },
+    };
+
+    const fd = FunctionDefinition.from(def);
+
+    let result = await new KIRuntime(fd).execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map()),
+    );
+
+    expect(result.allResults()[0].getResult()).toMatchObject({});
+});

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

@@ -0,0 +1,42 @@
+import {
+    ArgumentsTokenValueExtractor,
+    Expression,
+    MapUtil,
+    TokenValueExtractor,
+} from '../../../../src';
+import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+
+test('Expression with Ternary Operator - 1 ', () => {
+    var exp = new Expression('a > 10 ?  a - 2 : a + 3'.replace(' ', ''));
+    expect(exp.toString()).toBe('((a>10)?(a-2):(a+3))');
+
+    exp = new Expression('a > 10 ?  a - 2 : a + 3');
+    expect(exp.toString()).toBe('((a>10)?(a-2):(a+3))');
+
+    exp = new Expression('a > 10 ? a > 15 ? a + 2 : a - 2 : a + 3');
+    expect(exp.toString()).toBe('((a>10)?((a>15)?(a+2):(a-2)):(a+3))');
+});
+
+test('Expression Evaluation with Ternary Operator - 1 ', () => {
+    let x = { a: 2, b: [true, false], c: { x: 'Arguments.b2' } };
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['b1', 4],
+            ['b2', 4],
+            ['c', x],
+            ['d', 'c'],
+        ]),
+    );
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    var ev = new ExpressionEvaluator('Arguments.e = null ? Arguments.c.a : 3 ');
+    expect(ev.evaluate(valuesMap)).toBe(2);
+
+    ev = new ExpressionEvaluator('Arguments.f ? Arguments.c.a : 3 ');
+    expect(ev.evaluate(valuesMap)).toBe(3);
+
+    ev = new ExpressionEvaluator('Arguments.e = null ? Arguments.c : 3 ');
+    expect(ev.evaluate(valuesMap)).toMatchObject(x);
+});