@fincity/kirun-js 2.7.0 → 2.8.2

package/__tests__/engine/function/system/date/ToDateStringTest.ts

@@ -0,0 +1,48 @@
+import { FunctionExecutionParameters } from '../../../../../src';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../../../src';
+import { ToDateString } from '../../../../../src/engine/function/system/date/ToDateString';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('ToDateString', () => {
+    test('should return the date string in the given format', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                [ToDateString.PARAMETER_TIMESTAMP_NAME, '2024-01-01T00:00:00.000+05:30'],
+                [ToDateString.PARAMETER_FORMAT_NAME, 'yyyy-MM-dd'],
+            ]),
+        );
+
+        const result = await (await new ToDateString().execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe('2024-01-01');
+    });
+
+    test('should return the date string in the given format with locale', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                [ToDateString.PARAMETER_TIMESTAMP_NAME, '2024-01-01T00:00:00.000+05:30'],
+                [ToDateString.PARAMETER_FORMAT_NAME, 'DDD'],
+                [ToDateString.PARAMETER_LOCALE_NAME, 'fr-CA'],
+            ]),
+        );
+
+        const result = await (await new ToDateString().execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe('1 janvier 2024');
+    });
+});

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

@@ -1,16 +1,15 @@
-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();
+import { KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from '../../../../../src';
+import { MathFunctionRepository } from '../../../../../src/engine/function/system/math/MathFunctionRepository';
 
 test('rand Float 1', async () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomFloat'))!;
     let min = 1,
         max = 10;
 
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
     ).setArguments(
         new Map([
             ['minValue', min],
@@ -22,15 +21,16 @@ test('rand Float 1', async () => {
 
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
-})
+});
 
 test('rand Float 2', async () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomFloat'))!;
     let min = 0.1,
         max = 0.9;
 
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
     ).setArguments(
         new Map([
             ['minValue', min],
@@ -42,33 +42,32 @@ test('rand Float 2', async () => {
 
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
-})
+});
 
 test('rand Float 3', async () => {
-    let min = 1, max = 2147483647;
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomFloat'))!;
+    let min = 1,
+        max = 2147483647;
 
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
-    ).setArguments(
-        new Map([
-            ['minValue', min],
-        ]),
-    );
+        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 () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomFloat'))!;
     let min = 1.1,
         max = 1.2;
 
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository,
-        new KIRunSchemaRepository
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
     ).setArguments(
         new Map([
             ['minValue', min],
@@ -80,4 +79,4 @@ test('rand Float 4', async () => {
 
     expect(num).toBeLessThanOrEqual(max);
     expect(num).toBeGreaterThanOrEqual(min);
-})
+});

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

@@ -1,10 +1,9 @@
-import { RandomInt } from '../../../../../src/engine/function/system/math/RandomInt';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
-import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
-
-const rand = new RandomInt();
+import { KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from '../../../../../src';
+import { MathFunctionRepository } from '../../../../../src/engine/function/system/math/MathFunctionRepository';
 
 test(' rand int 1', async () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomInt'))!;
     let min = 100,
         max = 1000123;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
@@ -23,6 +22,7 @@ test(' rand int 1', async () => {
 });
 
 test(' rand int 2', async () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomInt'))!;
     let min = 100;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
         new KIRunFunctionRepository(),
@@ -35,6 +35,7 @@ test(' rand int 2', async () => {
 });
 
 test(' rand int 3', async () => {
+    const rand = (await new MathFunctionRepository().find(Namespaces.MATH, 'RandomInt'))!;
     let min = 100,
         max = 101;
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(

package/__tests__/engine/repository/RepositoryFilterTest.ts

@@ -24,7 +24,10 @@ test('Repository Filter Test', async () => {
     expect(await schemaRepo.filter('ny')).toStrictEqual(['System.any']);
 
     expect((await schemaRepo.filter('')).sort()).toStrictEqual([
-        'System.Date.timeStamp',
+        'System.Date.Duration',
+        'System.Date.TimeObject',
+        'System.Date.Timestamp',
+        'System.Date.Timeunit',
         'System.Null',
         'System.ParameterExpression',
         'System.Schema',

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

@@ -0,0 +1,76 @@
+import {
+    ExpressionEvaluator,
+    KIRunSchemaRepository,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+} from '../../../../src';
+
+let obj = {
+    number: 20,
+    zero: 0,
+    booleanTrue: true,
+    booleanFalse: false,
+    string: 'Hello',
+    emptyString: '',
+    nullValue: null,
+    undefinedValue: undefined,
+    emptyObject: {},
+    emptyArray: [],
+};
+
+let inMap: Map<string, any> = new Map();
+inMap.set('name', 'Kiran');
+inMap.set('obj', obj);
+
+let output: Map<string, Map<string, Map<string, any>>> = new Map([
+    ['step1', new Map([['output', inMap]])],
+]);
+
+let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository(),
+)
+    .setArguments(new Map())
+    .setSteps(output);
+
+test('Expression Equality Test', () => {
+    let exp = new ExpressionEvaluator(
+        'Steps.step1.output.obj.number = Steps.step1.output.obj.zero',
+    );
+    let result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(false);
+
+    exp = new ExpressionEvaluator(
+        'Steps.step1.output.obj.booleanFalse = (not Steps.step1.output.obj.number)',
+    );
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(true);
+
+    exp = new ExpressionEvaluator(
+        'Steps.step1.output.obj.booleanFalse = (not Steps.step1.output.obj.emptyString)',
+    );
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(true);
+
+    exp = new ExpressionEvaluator(
+        'Steps.step1.output.obj.booleanTrue = (not Steps.step1.output.obj.zero)',
+    );
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(true);
+
+    exp = new ExpressionEvaluator("Steps.step1.output.obj.emptyString = ''");
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(true);
+
+    exp = new ExpressionEvaluator("Steps.step1.output.obj.emptyString != ''");
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(false);
+
+    exp = new ExpressionEvaluator("Steps.step1.output.obj.string != ''");
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(true);
+
+    exp = new ExpressionEvaluator("Steps.step1.output.obj.string = ''");
+    result = exp.evaluate(parameters.getValuesMap());
+    expect(result).toBe(false);
+});