@fincity/kirun-js 1.1.6 → 1.3.0

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

@@ -1,4 +1,10 @@
-import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../src';
+import {
+    ArgumentsTokenValueExtractor,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    MapUtil,
+    TokenValueExtractor,
+} 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';
@@ -130,3 +136,78 @@ test('Expression Test', () => {
         17.3533,
     );
 });
+
+test('ExpressionEvaluation deep tests', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['c', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+            ['d', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+        ]),
+    );
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev = new ExpressionEvaluator('Arguments.a = Arugments.b');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.c = Arguments.d');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.e = null');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.e != null');
+    expect(ev.evaluate(valuesMap)).toBeFalsy();
+
+    ev = new ExpressionEvaluator('Arguments.e = false');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+
+    ev = new ExpressionEvaluator('Arguments.c != null');
+    expect(ev.evaluate(valuesMap)).toBeTruthy();
+});
+
+test('Expression Evaluation nullish coalescing', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['b1', 4],
+            ['c', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+            ['d', { a: 2, b: [true, false], c: { x: 'kiran' } }],
+        ]),
+    );
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev = new ExpressionEvaluator('(Arguments.e ?? Arguments.b ?? Arguments.b1) + 4');
+    expect(ev.evaluate(valuesMap)).toBe(6);
+
+    ev = new ExpressionEvaluator('(Arguments.e ?? Arguments.b2 ?? Arguments.b1) + 4');
+    expect(ev.evaluate(valuesMap)).toBe(8);
+});
+
+test('Expression Evaluation nesting expression', () => {
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['b1', 4],
+            ['b2', 4],
+            ['c', { a: 2, b: [true, false], c: { x: 'Arguments.b2' } }],
+            ['d', 'c'],
+        ]),
+    );
+    let valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    let ev = new ExpressionEvaluator(
+        'Arguments.{{Arguments.d}}.a + {{Arguments.{{Arguments.d}}.c.x}}',
+    );
+    expect(ev.evaluate(valuesMap)).toBe(6);
+
+    ev = new ExpressionEvaluator(
+        "'There are {{{{Arguments.{{Arguments.d}}.c.x}}}} boys in the class room...' * Arguments.b",
+    );
+    expect(ev.evaluate(valuesMap)).toBe(
+        'There are 4 boys in the class room...There are 4 boys in the class room...',
+    );
+});

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

@@ -0,0 +1,77 @@
+import {
+    ArgumentsTokenValueExtractor,
+    Expression,
+    MapUtil,
+    TokenValueExtractor,
+} from '../../../../src';
+import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+
+test('Expression with String Literal - 1 ', () => {
+    let ex: Expression = new Expression("'ki/run'+'ab'");
+
+    let ev: ExpressionEvaluator = new ExpressionEvaluator(ex);
+
+    expect(ev.evaluate(MapUtil.of())).toBe('ki/runab');
+
+    let evt: ExpressionEvaluator = new ExpressionEvaluator('"Steps.a');
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    expect(() => evt.evaluate(valuesMap)).toThrow();
+
+    ev = new ExpressionEvaluator("Arguments.a+'kiran'");
+
+    expect(ev.evaluate(valuesMap)).toBe('kirun kiran');
+
+    ev = new ExpressionEvaluator("Arguments.b+'kiran'");
+
+    expect(ev.evaluate(valuesMap)).toBe('2kiran');
+
+    ev = new ExpressionEvaluator('Arguments.c+\'k"ir"an\'');
+
+    expect(ev.evaluate(valuesMap)).toBe('truek"ir"an');
+
+    ev = new ExpressionEvaluator("Arguments.b+\"'kir\" + ' an'");
+
+    expect(ev.evaluate(valuesMap)).toBe("2'kir an");
+
+    ev = new ExpressionEvaluator("Arguments.a+'kiran'+ Arguments.b");
+
+    expect(ev.evaluate(valuesMap)).toBe('kirun kiran2');
+});
+
+test('Expression with String Literal - 2 ', () => {
+    let ev: ExpressionEvaluator = new ExpressionEvaluator("'a' * 10");
+
+    let atv: ArgumentsTokenValueExtractor = new ArgumentsTokenValueExtractor(
+        new Map<string, any>([
+            ['a', 'kirun '],
+            ['b', 2],
+            ['c', true],
+            ['d', 1.5],
+        ]),
+    );
+    const valuesMap: Map<string, TokenValueExtractor> = MapUtil.of(atv.getPrefix(), atv);
+
+    expect(ev.evaluate(valuesMap)).toBe('aaaaaaaaaa');
+
+    ev = new ExpressionEvaluator('2.5*Arguments.a');
+    expect(ev.evaluate(valuesMap)).toBe('kirun kirun kir');
+
+    ev = new ExpressionEvaluator('-0.5*Arguments.a');
+    expect(ev.evaluate(valuesMap)).toBe('rik');
+
+    ev = new ExpressionEvaluator("'asdf' * -1");
+    expect(ev.evaluate(valuesMap)).toBe('fdsa');
+
+    ev = new ExpressionEvaluator("'asdf' * 0");
+    expect(ev.evaluate(valuesMap)).toBe('');
+});

package/__tests__/engine/util/deepEqualTest.ts

@@ -0,0 +1,13 @@
+import { deepEqual } from '../../../src/engine/util/deepEqual';
+
+test('deepEqual', () => {
+    expect(deepEqual(true, false)).toBeFalsy();
+    expect(deepEqual(2, 2)).toBeTruthy();
+    expect(deepEqual(null, undefined)).toBeTruthy();
+    expect(deepEqual([1, 2, 3, { a: [3, 4] }], [1, 2, 3, { a: [3, 4] }])).toBeTruthy();
+    expect(deepEqual([1, 2, 3, { a: [3, 4] }], [1, 2, 3, { a: [3] }])).toBeFalsy();
+    expect(deepEqual([1, 2, 3, { a: [3, 4] }], [1, 2, 3, { a: [3, '4'] }])).toBeFalsy();
+    expect(
+        deepEqual([1, 2, 3, { a: [3, 4], b: null }], [1, 2, 3, { a: [3, 4], b: undefined }]),
+    ).toBeTruthy();
+});