@fincity/kirun-js 2.7.0 → 2.8.2

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

@@ -0,0 +1,71 @@
+import { Settings } from 'luxon';
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+} from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { FromNow } from '../../../../../src/engine/function/system/date/FromNow';
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('From Now', () => {
+    test('should return the relative date', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
+                [FromNow.PARAMETER_FROM_NAME, '2024-04-25'],
+            ]),
+        );
+
+        const result = await new FromNow().execute(fep);
+
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            'in 8 months',
+        );
+    });
+
+    test('should return the relative date with units', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
+                [FromNow.PARAMETER_FROM_NAME, '2023-04-25'],
+                [FromNow.PARAMETER_UNIT_NAME, ['MONTHS', 'DAYS']],
+                [FromNow.PARAMETER_FORMAT_NAME, 'SHORT'],
+            ]),
+        );
+
+        const result = await new FromNow().execute(fep);
+
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            'in 20 mo',
+        );
+    });
+
+    test('should return the relative date with locale', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map<string, any>([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
+                [FromNow.PARAMETER_FROM_NAME, '2023-04-25'],
+                [FromNow.PARAMETER_UNIT_NAME, ['DAYS']],
+                [FromNow.PARAMETER_FORMAT_NAME, 'LONG'],
+                [FromNow.PARAMETER_LOCALE_NAME, 'fr'],
+            ]),
+        );
+
+        const result = await new FromNow().execute(fep);
+
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            'dans 617 jours',
+        );
+    });
+});

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

@@ -1,35 +1,27 @@
-import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
-import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
-import { GetCurrentTimeStamp } from '../../../../../src/engine/function/system/date/GetCurrentTimeStamp';
+import { KIRunSchemaRepository, Namespaces } from '../../../../../src';
+import { KIRunFunctionRepository } from '../../../../../src';
+import { FunctionExecutionParameters } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
 
-const gcts: GetCurrentTimeStamp = new GetCurrentTimeStamp();
+import { Settings } from 'luxon';
 
-describe('testing GetCurrentTimeStamp', () => {
-    test('checking with current time stamp', async () => {
-        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).setArguments(new Map([]));
-
-        const d = new Date(Date.now());
-
-        expect((await gcts.execute(fep)).allResults()[0].getResult().get('date').substring(0,21)).toBe(
-            d.toISOString().substring(0,21)
-        );
-    });
-})
+Settings.defaultZone = 'Asia/Kolkata';
 
-describe('testing false case of GetCurrentTimeStamp', () => {
-    test('checking with current time stamp', async () => {
-        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+describe('GetCurrentTimestamp', () => {
+    test('should return the current timestamp', async () => {
+        const fep = new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
-        ).setArguments(new Map([]));
+        ).setArguments(new Map());
 
-        const d = new Date(Date.now()-1000000);
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'GetCurrentTimestamp',
+        ))!.execute(fep);
 
-        expect((await gcts.execute(fep)).allResults()[0].getResult().get('date')).not.toBe(
-            d.toISOString()
-        );
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBeDefined();
     });
-})
+});

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

@@ -0,0 +1,105 @@
+import { KIRunFunctionRepository, KIRunSchemaRepository, MapUtil } from '../../../../../src';
+import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
+import { GetNames } from '../../../../../src/engine/function/system/date/GetNames';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+const getNames = new GetNames();
+
+describe('GetNames', () => {
+    test('should return the names of the units', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(MapUtil.of(GetNames.PARAMETER_UNIT_NAME, 'TIMEZONES'));
+
+        const result = (await getNames.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(GetNames.EVENT_NAMES_NAME);
+
+        expect(result).toEqual(Intl.supportedValuesOf('timeZone'));
+    });
+
+    test('should return the names of the months', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(MapUtil.of(GetNames.PARAMETER_UNIT_NAME, 'MONTHS'));
+
+        const result = (await getNames.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(GetNames.EVENT_NAMES_NAME);
+
+        expect(result).toEqual([
+            'January',
+            'February',
+            'March',
+            'April',
+            'May',
+            'June',
+            'July',
+            'August',
+            'September',
+            'October',
+            'November',
+            'December',
+        ]);
+    });
+
+    test('should return the names of the weekdays', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(MapUtil.of(GetNames.PARAMETER_UNIT_NAME, 'WEEKDAYS'));
+
+        const result = (await getNames.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(GetNames.EVENT_NAMES_NAME);
+
+        expect(result).toEqual([
+            'Monday',
+            'Tuesday',
+            'Wednesday',
+            'Thursday',
+            'Friday',
+            'Saturday',
+            'Sunday',
+        ]);
+    });
+
+    test('should return the names of months in french', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                GetNames.PARAMETER_UNIT_NAME,
+                'MONTHS',
+                GetNames.PARAMETER_LOCALE_NAME,
+                'fr',
+            ),
+        );
+
+        const result = (await getNames.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(GetNames.EVENT_NAMES_NAME);
+
+        expect(result).toEqual([
+            'janvier',
+            'février',
+            'mars',
+            'avril',
+            'mai',
+            'juin',
+            'juillet',
+            'août',
+            'septembre',
+            'octobre',
+            'novembre',
+            'décembre',
+        ]);
+    });
+});

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

@@ -0,0 +1,53 @@
+import { IsBetween } from '../../../../../src/engine/function/system/date/IsBetween';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'UTC+05:30';
+
+const isBetween = new IsBetween();
+
+describe('IsBetween', () => {
+    test('should return true if the check timestamp is between the start and end timestamps', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                IsBetween.PARAMETER_START_TIMESTAMP_NAME,
+                '2024-01-01T00:00:00.000Z',
+                IsBetween.PARAMETER_END_TIMESTAMP_NAME,
+                '2024-01-02T00:00:00.000Z',
+                IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME,
+                '2024-01-01T12:00:00.000Z',
+            ),
+        );
+
+        const result = await isBetween.execute(fep);
+
+        expect(result.allResults()[0].getResult().get(IsBetween.EVENT_RESULT_NAME)).toBe(true);
+    });
+
+    test('should return false if the check timestamp is not between the start and end timestamps', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                IsBetween.PARAMETER_START_TIMESTAMP_NAME,
+                '2024-01-01T00:00:00.000Z',
+                IsBetween.PARAMETER_END_TIMESTAMP_NAME,
+                '2024-01-02T00:00:00.000Z',
+                IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME,
+                '2024-01-03T00:00:00.000Z',
+            ),
+        );
+
+        const result = await isBetween.execute(fep);
+
+        expect(result.allResults()[0].getResult().get(IsBetween.EVENT_RESULT_NAME)).toBe(false);
+    });
+});

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

@@ -1,79 +1,67 @@
-import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository } from "../../../../../src";
-import { IsValidISODate } from "../../../../../src/engine/function/system/date/IsValidISODate";
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+} from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { IsValidISODate } from '../../../../../src/engine/function/system/date/IsValidISODate';
 
+import { Settings } from 'luxon';
 
-const validIso: IsValidISODate = new IsValidISODate();
+Settings.defaultZone = 'Asia/Kolkata';
 
-describe('checking the validity for not string types ',() => {
+const isValidISODate = new IsValidISODate();
 
-    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-        new KIRunFunctionRepository(),
-        new KIRunSchemaRepository(),
-    );
-
-    test('number test' , async () => {
-
-        fep.setArguments(new Map([['isoDate',1234]]))
-        await expect( validIso.execute(fep)).rejects.toThrow();
-
-    });
-
-    test('boolean test' , async () => {
-
-        fep.setArguments(new Map([['isoDate',true]]))
-        await expect(validIso.execute(fep)).rejects.toThrow();
-
-    })
-})
-
-describe('checking validity for string date types' , () => {
-
-    test('Date1', async () => {
-        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
-            new KIRunFunctionRepository(),
-            new KIRunSchemaRepository(),
-        ).setArguments(new Map([['isoDate', "aws"]]));
-
-        expect((await validIso.execute(fep)).allResults()[0].getResult().get('output')).toBeFalsy();
-    });
-});
-
-describe('checking validity', () => {
-
-    test('Date1', async () => {
+describe('IsValidISODate', () => {
+    it('should return true for a valid ISO date', async () => {
         let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
-        ).setArguments(new Map([['isoDate', "2023-10-04T11:45:38.939ss"]]));
-
-        expect((await validIso.execute(fep)).allResults()[0].getResult().get('output')).toBeFalsy();
+        ).setArguments(
+            new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01T00:00:00.000Z']]),
+        );
+
+        const result = await isValidISODate.execute(fep);
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            true,
+        );
     });
 
-    test('Date2', async () => {
+    it('should return false for an invalid ISO date', async () => {
         let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
-        ).setArguments(new Map([['isoDate', "2023-10-04T11:45:38.939Z"]]));
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, 'invalid']]));
 
-        expect((await validIso.execute(fep)).allResults()[0].getResult().get('output')).toBeTruthy();
+        const result = await isValidISODate.execute(fep);
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            false,
+        );
     });
 
-    test('Date3', async () => {
+    it('should return false for an invalid ISO date', async () => {
         let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
-        ).setArguments(new Map([['isoDate', "2023-10-10T10:02:54.959Z"]]));
+        ).setArguments(new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-02-31']]));
 
-        expect((await validIso.execute(fep)).allResults()[0].getResult().get('output')).toBeTruthy();
+        const result = await isValidISODate.execute(fep);
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            false,
+        );
     });
 
-    test('Date4', async () => {
+    it('should return false for an invalid leap year ISO date', async () => {
         let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
-        ).setArguments(new Map([['isoDate', "2023-10-10T10:02:54.959-12:12"]]));
-
-        expect((await validIso.execute(fep)).allResults()[0].getResult().get('output')).toBeTruthy();
+        ).setArguments(
+            new Map([[AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2022-02-29T00:00:00.000Z']]),
+        );
+
+        const result = await isValidISODate.execute(fep);
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            false,
+        );
     });
-    
-})
+});

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

@@ -0,0 +1,64 @@
+import {
+    FunctionExecutionParameters,
+    KIRunSchemaRepository,
+    KIRunFunctionRepository,
+    MapUtil,
+} from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { LastFirstOf } from '../../../../../src/engine/function/system/date/LastFirstOf';
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'UTC+05:30';
+
+const lastOf = new LastFirstOf(true);
+const firstOf = new LastFirstOf(false);
+
+describe('LastFirstOf', () => {
+    test('should return the last timestamp', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, [
+                '2024-01-03T05:50:00.000+05:30',
+                '2024-01-02T00:00:00.000Z',
+                '2024-01-03T10:00:00.000Z',
+            ]),
+        );
+
+        const result = await lastOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-01-03T15:30:00.000+05:30');
+    });
+
+    test('should return the first timestamp', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, [
+                '2024-01-03T05:50:00.000+05:30',
+                '2024-01-02T00:00:00.000Z',
+                '2024-01-03T10:00:00.000Z',
+            ]),
+        );
+
+        const result = await firstOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-01-02T05:30:00.000+05:30');
+    });
+
+    test('should throw an error if no timestamps are provided', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(MapUtil.of(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, []));
+
+        await expect(lastOf.execute(fep)).rejects.toThrow('No timestamps provided');
+        await expect(firstOf.execute(fep)).rejects.toThrow('No timestamps provided');
+    });
+});

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

@@ -0,0 +1,48 @@
+import { KIRunFunctionRepository, MapUtil, KIRunSchemaRepository } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { SetTimeZone } from '../../../../../src/engine/function/system/date/SetTimeZone';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+
+const setTimeZone = new SetTimeZone();
+
+describe('SetTimeZone', () => {
+    test('should set the time zone', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                '2024-01-01T00:00:00.000Z',
+                SetTimeZone.PARAMETER_TIMEZONE_NAME,
+                'Asia/Tokyo',
+            ),
+        );
+
+        const result = await setTimeZone.execute(fep);
+
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            '2024-01-01T09:00:00.000+09:00',
+        );
+    });
+
+    test('shoud set the time zone with offset', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                '2024-01-01T00:00:00.000Z',
+                SetTimeZone.PARAMETER_TIMEZONE_NAME,
+                'UTC+05:30',
+            ),
+        );
+
+        const result = await setTimeZone.execute(fep);
+
+        expect(result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(
+            '2024-01-01T05:30:00.000+05:30',
+        );
+    });
+});

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

@@ -0,0 +1,53 @@
+import { KIRunSchemaRepository } from '../../../../../src/engine/repository/KIRunSchemaRepository';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { FunctionExecutionParameters, MapUtil } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { StartEndOf } from '../../../../../src/engine/function/system/date/StartEndOf';
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'UTC+05:30';
+
+const startOf = new StartEndOf(true);
+const endOf = new StartEndOf(false);
+
+describe('StartEndOf', () => {
+    test('should return the start of the year', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                '2023-12-31T22:00:00.000Z',
+                AbstractDateFunction.PARAMETER_UNIT_NAME,
+                'YEAR',
+            ),
+        );
+
+        const result = await startOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-01-01T00:00:00.000+05:30');
+    });
+
+    test('should return the end of the year', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                '2023-12-31T22:00:00.000Z',
+                AbstractDateFunction.PARAMETER_UNIT_NAME,
+                'YEAR',
+            ),
+        );
+
+        const result = await endOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-12-31T23:59:59.999+05:30');
+    });
+});

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

@@ -0,0 +1,24 @@
+import { MapUtil } from '../../../../../src/engine/util/MapUtil';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { TimeAs } from '../../../../../src/engine/function/system/date/TimeAs';
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { Settings } from 'luxon';
+const timeAsArray = new TimeAs(true);
+const timeAsObject = new TimeAs(false);
+
+Settings.defaultZone = 'UTC+05:30';
+
+describe('TimeAs', () => {
+    it('should return the time as an array', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(TimeAs.PARAMETER_TIMESTAMP_NAME, '2024-11-10T10:10:10.100+05:30'),
+        );
+        const result = await timeAsArray.execute(fep);
+        expect(result.allResults()[0].getResult().get(TimeAs.EVENT_TIME_ARRAY_NAME)).toEqual([
+            2024, 11, 10, 10, 10, 10, 100,
+        ]);
+    });
+});

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

@@ -0,0 +1,45 @@
+import { KIRunSchemaRepository } from '../../../../../src';
+import { KIRunFunctionRepository } from '../../../../../src/engine/repository/KIRunFunctionRepository';
+import { FunctionExecutionParameters } from '../../../../../src';
+import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
+import { TimestampToEpoch } from '../../../../../src/engine/function/system/date/TimestampToEpoch';
+
+import { Settings } from 'luxon';
+
+Settings.defaultZone = 'Asia/Kolkata';
+
+describe('TimestampToEpoch', () => {
+    test('should return the epoch time in seconds', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01T00:00:00.000+05:30'],
+            ]),
+        );
+
+        const result = await (await new TimestampToEpoch('TimestampToEpoch', true).execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(1704047400);
+    });
+
+    test('should return the epoch time in milliseconds', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            new Map([
+                [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2024-01-01T00:00:00.000+05:30'],
+            ]),
+        );
+
+        const result = await (await new TimestampToEpoch('TimestampToEpoch', false).execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe(1704047400000);
+    });
+});