@fincity/kirun-js 2.7.0 → 2.8.2

package/__tests__/engine/function/system/WaitTest.ts

@@ -42,7 +42,7 @@ test('wait test immediately', async () => {
     await waitFunction.execute(fep.setArguments(new Map()));
 
     const endTime = new Date().getTime();
-    expect(endTime - startTime).toBeLessThan(10);
+    expect(endTime - startTime).toBeLessThan(50);
 });
 
 test('wait test error with negative number', async () => {

package/__tests__/engine/function/system/array/AddFirstTest.ts

@@ -1,8 +1,4 @@
-import {
-    KIRunFunctionRepository,
-    KIRunSchemaRepository,
-    SchemaValidationException,
-} from '../../../../../src';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { AddFirst } from '../../../../../src/engine/function/system/array/AddFirst';
 
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
@@ -225,7 +221,7 @@ test('Add Test 4', async () => {
         .setArguments(
             new Map([
                 [AddFirst.PARAMETER_ARRAY_SOURCE.getParameterName(), null],
-                [AddFirst.PARAMETER_ANY_NOT_NULL.getParameterName(), temp],
+                [AddFirst.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), temp],
             ]),
         )
         .setSteps(new Map([]))

package/__tests__/engine/function/system/array/IndexOfTest.ts

@@ -1,6 +1,6 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { IndexOf } from '../../../../../src/engine/function/system/array/IndexOf';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
-import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 test('Index of Test 1', async () => {
     let ind: IndexOf = new IndexOf();
@@ -32,7 +32,7 @@ test('Index of Test 1', async () => {
     ).setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [IndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 2],
         ]),
     );
@@ -71,7 +71,7 @@ test('Index of Test 2', async () => {
     ).setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [IndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), -2],
         ]),
     );
@@ -81,7 +81,7 @@ test('Index of Test 2', async () => {
     fep.setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), []],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [IndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), -2],
         ]),
     );
@@ -120,7 +120,7 @@ test('Index of Test 3', async () => {
     ).setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [IndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 0],
         ]),
     );
@@ -213,7 +213,7 @@ test('Index of Test 4', async () => {
     ).setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), arr],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [IndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 2],
         ]),
     );
@@ -265,7 +265,7 @@ test('indexof test 5', async () => {
     ).setArguments(
         new Map<string, any>([
             [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), arr],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
         ]),
     );
 
@@ -273,11 +273,6 @@ test('indexof test 5', async () => {
         (await ind.execute(fep)).allResults()[0].getResult().get(IndexOf.EVENT_RESULT_NAME),
     ).toBe(5);
 
-    fep.setArguments(
-        new Map<string, any>([
-            [IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), arr],
-            [IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), null],
-        ]),
-    );
+    fep.setArguments(new Map<string, any>());
     await expect(ind.execute(fep)).rejects.toThrow();
 });

package/__tests__/engine/function/system/array/LastIndexOfTest.ts

@@ -1,6 +1,6 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 import { LastIndexOf } from '../../../../../src/engine/function/system/array/LastIndexOf';
 import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
-import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
 
 test('Last Index of Test 1', async () => {
     let lind: LastIndexOf = new LastIndexOf();
@@ -32,7 +32,7 @@ test('Last Index of Test 1', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 2],
         ]),
     );
@@ -71,8 +71,8 @@ test('Last Index of Test 2', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
-            [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 2],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
+            [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), -2],
         ]),
     );
     await expect(lind.execute(fep)).rejects.toThrow();
@@ -81,25 +81,6 @@ test('Last Index of Test 2', async () => {
 test('Last Index of Test 3', async () => {
     let lind: LastIndexOf = new LastIndexOf();
 
-    let array: string[] = [];
-
-    array.push('test');
-    array.push('Driven');
-    array.push('developement');
-    array.push('I');
-    array.push('am');
-    array.push('using');
-    array.push('eclipse');
-    array.push('I');
-    array.push('to');
-    array.push('test');
-    array.push('the');
-    array.push('changes');
-    array.push('with');
-    array.push('test');
-    array.push('Driven');
-    array.push('developement');
-
     let find;
 
     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
@@ -108,7 +89,7 @@ test('Last Index of Test 3', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), null],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 2],
         ]),
     );
@@ -145,7 +126,7 @@ test('Last Index of Test 4', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 12],
         ]),
     );
@@ -156,7 +137,7 @@ test('Last Index of Test 4', async () => {
     fep.setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), 'newas'],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), 'newas'],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 12],
         ]),
     );
@@ -195,7 +176,7 @@ test('Last Index of Test 5', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), array],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), find],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), find],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), -2],
         ]),
     );
@@ -250,7 +231,7 @@ test('Last Index of Test 6', async () => {
     ).setArguments(
         new Map<string, any>([
             [LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName(), arr],
-            [LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName(), js4],
+            [LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName(), js4],
             [LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName(), 1],
         ]),
     );

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

@@ -0,0 +1,93 @@
+import { DateTime, Settings } from 'luxon';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { AddSubtractTime } from '../../../../../src/engine/function/system/date/AddSubtractTime';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+const addFunction = new AddSubtractTime(true);
+const subtractFunction = new AddSubtractTime(false);
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('AddSubtractTime', () => {
+    test('should add time with no values', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01T10:20:35+05:30'],
+            ]),
+        );
+
+        const result = await addFunction.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2025-01-01T10:20:35.000+05:30');
+    });
+
+    test('shoudl subtract time with no values', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01T10:20:35+05:30'],
+            ]),
+        );
+
+        const result = await subtractFunction.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2025-01-01T10:20:35.000+05:30');
+    });
+
+    test('should add time with all values', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01T10:20:35+05:30'],
+                [AddSubtractTime.PARAMETER_YEARS_NAME, 1],
+                [AddSubtractTime.PARAMETER_MONTHS_NAME, 1],
+                [AddSubtractTime.PARAMETER_DAYS_NAME, 1],
+                [AddSubtractTime.PARAMETER_HOURS_NAME, 1],
+                [AddSubtractTime.PARAMETER_MINUTES_NAME, 1],
+                [AddSubtractTime.PARAMETER_SECONDS_NAME, 1],
+            ]),
+        );
+
+        const result = await addFunction.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2026-02-02T11:21:36.000+05:30');
+    });
+
+    test('should subtract time with all values', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01T10:20:35+05:30'],
+                [AddSubtractTime.PARAMETER_YEARS_NAME, 1],
+                [AddSubtractTime.PARAMETER_MONTHS_NAME, 1],
+                [AddSubtractTime.PARAMETER_DAYS_NAME, 1],
+                [AddSubtractTime.PARAMETER_HOURS_NAME, 1],
+                [AddSubtractTime.PARAMETER_MINUTES_NAME, 1],
+                [AddSubtractTime.PARAMETER_SECONDS_NAME, 1],
+                [AddSubtractTime.PARAMETER_MILLISECONDS_NAME, 8],
+            ]),
+        );
+
+        const result = await subtractFunction.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2023-11-30T09:19:33.992+05:30');
+    });
+});

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

@@ -0,0 +1,96 @@
+import { Settings } from 'luxon';
+import { Namespaces } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+const repo = new DateFunctionRepository();
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('DateFunctionRepository', () => {
+    test('should return Date by using GetDate', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01']]));
+
+        const result = (await (await repo.find(Namespaces.DATE, 'GetDay'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(1);
+    });
+
+    test('should return the days in month using GetDaysInMonth', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01']]));
+
+        const result = (await (await repo.find(Namespaces.DATE, 'GetDaysInMonth'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(31);
+    });
+
+    test('should return the days in year using GetDaysInYear', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01']]));
+
+        const result = (await (await repo.find(Namespaces.DATE, 'GetDaysInYear'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(366);
+    });
+
+    test('should return the day of week using GetDayOfWeek', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01']]));
+
+        const result = (await (await repo.find(Namespaces.DATE, 'GetDayOfWeek'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(1);
+    });
+
+    test('should return the days in a non leap year using GetDaysInYear', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2023-01-01']]));
+
+        const result = (await (await repo.find(Namespaces.DATE, 'GetDaysInYear'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(365);
+    });
+
+    test('should return the date with the day set using SetDay', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01'],
+                [AbstractDateFunction.PARAMETER_NUMBER_NAME, 2],
+            ]),
+        );
+
+        const result = (await (await repo.find(Namespaces.DATE, 'SetDay'))!.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe('2024-01-02T00:00:00.000+05:30');
+    });
+});

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

@@ -0,0 +1,93 @@
+import { Settings } from 'luxon';
+import { KIRunSchemaRepository, Namespaces } from '../../../../../src';
+import { FunctionExecutionParameters } from '../../../../../src';
+import { KIRunFunctionRepository } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('Difference of dates', () => {
+    test('should return the difference in default', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE, '2025-01-01'],
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO, '2024-04-25'],
+            ]),
+        );
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'Difference',
+        ))!.execute(fep);
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
+        ).toMatchObject({ milliseconds: 21686400000 });
+    });
+
+    test('should return the difference in days', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE, '2025-01-01T10:20:30+05:30'],
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO, '2024-04-25T10:20:30-05:00'],
+                [AbstractDateFunction.PARAMETER_UNIT_NAME, ['DAYS']],
+            ]),
+        );
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'Difference',
+        ))!.execute(fep);
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
+        ).toMatchObject({ days: 250.5625 });
+    });
+
+    test('should return the difference in months,days,hours,minutes', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE, '2025-01-01T10:20:30+05:30'],
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO, '2024-04-25T10:20:30-05:00'],
+                [AbstractDateFunction.PARAMETER_UNIT_NAME, ['MONTHS', 'DAYS', 'HOURS', 'MINUTES']],
+            ]),
+        );
+
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'Difference',
+        ))!.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
+        ).toMatchObject({ months: 8, days: 6, hours: 13, minutes: 30 });
+    });
+
+    test('should return the difference in negative months,days,hours,minutes', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE, '2024-01-01T10:20:30+05:30'],
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO, '2025-04-25T10:20:30-05:00'],
+                [AbstractDateFunction.PARAMETER_UNIT_NAME, ['MONTHS', 'DAYS', 'HOURS', 'MINUTES']],
+            ]),
+        );
+
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'Difference',
+        ))!.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
+        ).toMatchObject({ months: -15, days: -24, hours: -10, minutes: -30 });
+    });
+});

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

@@ -0,0 +1,133 @@
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from '../../../../../src';
+import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('testing EpochToDateFunction', () => {
+    test('Epoch To Date', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', 1694072117]]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('2023-09-07T07:35:17.000Z');
+    });
+
+    test('Epoch To Date 2', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochMilliseconds', 1694072117000]]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochMillisecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('2023-09-07T07:35:17.000Z');
+    });
+
+    test('Epoch To Date 3', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', 169407211700]]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('7338-04-20T14:48:20.000Z');
+    });
+    test('epoch string to date 1', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', '1696489387']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('2023-10-05T07:03:07.000Z');
+    });
+
+    test('epoch string to date 2', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', '1696489387']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('2023-10-05T07:03:07.000Z');
+    });
+
+    test('epoch string to date 3', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochMilliseconds', '1696489386']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochMillisecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('1970-01-20T15:14:49.386Z');
+    });
+
+    test('epoch string to date 4 all chars', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', 'abcdef']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(async () =>
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).rejects.toThrow('Please provide a valid value for epochSeconds.');
+    });
+
+    test('epoch test for large string function', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', '1696494131']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('2023-10-05T08:22:11.000Z');
+    });
+
+    test('epoch test for small string function', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epochSeconds', '169640']]));
+        const epochToDate = await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'EpochSecondsToTimestamp',
+        );
+        expect(
+            (await epochToDate!.execute(fep)).allResults()[0].getResult().get('isoTimeStamp'),
+        ).toBe('1970-01-02T23:07:20.000Z');
+    });
+});

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

@@ -0,0 +1,51 @@
+import { FromDateString } from '../../../../../src/engine/function/system/date/FromDateString';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+
+const fromDateString = new FromDateString();
+
+describe('FromDateString', () => {
+    test('should return the timestamp', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                FromDateString.PARAMETER_TIMESTAMP_STRING_NAME,
+                '2024-01-01',
+                FromDateString.PARAMETER_FORMAT_NAME,
+                'yyyy-MM-dd',
+            ),
+        );
+
+        const result = (await fromDateString.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(FromDateString.EVENT_RESULT_NAME);
+
+        expect(result).toEqual('2024-01-01T00:00:00.000+05:30');
+    });
+
+    test('should return the timestamp with the format', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                FromDateString.PARAMETER_TIMESTAMP_STRING_NAME,
+                '2024-05',
+                FromDateString.PARAMETER_FORMAT_NAME,
+                'yyyy-MM',
+            ),
+        );
+
+        const result = (await fromDateString.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(FromDateString.EVENT_RESULT_NAME);
+
+        expect(result).toEqual('2024-05-01T00:00:00.000+05:30');
+    });
+});