@fincity/kirun-js 2.8.2 → 2.8.4

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

@@ -1,7 +1,10 @@
 import { Settings } from 'luxon';
-import { KIRunSchemaRepository, Namespaces } from '../../../../../src';
-import { FunctionExecutionParameters } from '../../../../../src';
-import { KIRunFunctionRepository } from '../../../../../src';
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    Namespaces,
+} from '../../../../../src';
 import { AbstractDateFunction } from '../../../../../src/engine/function/system/date/AbstractDateFunction';
 import { DateFunctionRepository } from '../../../../../src/engine/function/system/date/DateFunctionRepository';
 
@@ -66,7 +69,7 @@ describe('Difference of dates', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
-        ).toMatchObject({ months: 8, days: 6, hours: 13, minutes: 30 });
+        ).toMatchObject({ months: 8, days: 10, hours: 13, minutes: 30 });
     });
 
     test('should return the difference in negative months,days,hours,minutes', async () => {
@@ -88,6 +91,50 @@ describe('Difference of dates', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
-        ).toMatchObject({ months: -15, days: -24, hours: -10, minutes: -30 });
+        ).toMatchObject({ months: -16, days: 0, hours: -10, minutes: -30 });
+    });
+
+    test('should return the difference in fractions', 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, ['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: -480.4375 });
+    });
+
+    test('should return the difference in multiple fractions', 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-25T09:17:23-05:00'],
+                [AbstractDateFunction.PARAMETER_UNIT_NAME, ['DAYS', 'HOURS']],
+            ]),
+        );
+
+        const result = await (await new DateFunctionRepository().find(
+            Namespaces.DATE,
+            'Difference',
+        ))!.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME),
+        ).toMatchObject({ days: -480, hours: -9.448055555554674 });
     });
 });

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

@@ -48,4 +48,25 @@ describe('FromDateString', () => {
 
         expect(result).toEqual('2024-05-01T00:00:00.000+05:30');
     });
+
+    test('should return the timestamp with the only few fields', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                FromDateString.PARAMETER_TIMESTAMP_STRING_NAME,
+                '03 12 123',
+                FromDateString.PARAMETER_FORMAT_NAME,
+                'dd ss SSS',
+            ),
+        );
+
+        const result = (await fromDateString.execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(FromDateString.EVENT_RESULT_NAME);
+
+        expect(result).toEqual('2024-11-03T00:00:12.123+05:30');
+    });
 });

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

@@ -17,7 +17,7 @@ describe('From Now', () => {
         ).setArguments(
             new Map([
                 [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
-                [FromNow.PARAMETER_FROM_NAME, '2024-04-25'],
+                [FromNow.PARAMETER_BASE_NAME, '2024-04-25'],
             ]),
         );
 
@@ -35,7 +35,7 @@ describe('From Now', () => {
         ).setArguments(
             new Map<string, any>([
                 [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
-                [FromNow.PARAMETER_FROM_NAME, '2023-04-25'],
+                [FromNow.PARAMETER_BASE_NAME, '2023-04-25'],
                 [FromNow.PARAMETER_UNIT_NAME, ['MONTHS', 'DAYS']],
                 [FromNow.PARAMETER_FORMAT_NAME, 'SHORT'],
             ]),
@@ -55,7 +55,7 @@ describe('From Now', () => {
         ).setArguments(
             new Map<string, any>([
                 [AbstractDateFunction.PARAMETER_TIMESTAMP_NAME, '2025-01-01'],
-                [FromNow.PARAMETER_FROM_NAME, '2023-04-25'],
+                [FromNow.PARAMETER_BASE_NAME, '2023-04-25'],
                 [FromNow.PARAMETER_UNIT_NAME, ['DAYS']],
                 [FromNow.PARAMETER_FORMAT_NAME, 'LONG'],
                 [FromNow.PARAMETER_LOCALE_NAME, 'fr'],

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

@@ -30,7 +30,7 @@ describe('LastFirstOf', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
-        ).toBe('2024-01-03T15:30:00.000+05:30');
+        ).toBe('2024-01-03T10:00:00.000Z');
     });
 
     test('should return the first timestamp', async () => {
@@ -49,7 +49,7 @@ describe('LastFirstOf', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
-        ).toBe('2024-01-02T05:30:00.000+05:30');
+        ).toBe('2024-01-02T00:00:00.000Z');
     });
 
     test('should throw an error if no timestamps are provided', async () => {

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

@@ -21,9 +21,9 @@ describe('SetTimeZone', () => {
 
         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',
-        );
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-01-01T09:00:00.000+09:00');
     });
 
     test('shoud set the time zone with offset', async () => {
@@ -41,8 +41,8 @@ describe('SetTimeZone', () => {
 
         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',
-        );
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-01-01T05:30:00.000+05:30');
     });
 });

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

@@ -20,7 +20,7 @@ describe('StartEndOf', () => {
                 AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
                 '2023-12-31T22:00:00.000Z',
                 AbstractDateFunction.PARAMETER_UNIT_NAME,
-                'YEAR',
+                'YEARS',
             ),
         );
 
@@ -28,7 +28,7 @@ describe('StartEndOf', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
-        ).toBe('2024-01-01T00:00:00.000+05:30');
+        ).toBe('2023-01-01T00:00:00.000Z');
     });
 
     test('should return the end of the year', async () => {
@@ -40,7 +40,7 @@ describe('StartEndOf', () => {
                 AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
                 '2023-12-31T22:00:00.000Z',
                 AbstractDateFunction.PARAMETER_UNIT_NAME,
-                'YEAR',
+                'YEARS',
             ),
         );
 
@@ -48,6 +48,46 @@ describe('StartEndOf', () => {
 
         expect(
             result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
-        ).toBe('2024-12-31T23:59:59.999+05:30');
+        ).toBe('2023-12-31T23:59:59.999Z');
+    });
+
+    test('should return the end of day', 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,
+                'DAYS',
+            ),
+        );
+
+        const result = await endOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2023-12-31T23:59:59.999Z');
+    });
+
+    test('should return the end of day in a different timezone', async () => {
+        const fep = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(
+            MapUtil.of(
+                AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                '2024-12-31T22:00:00.000-06:00',
+                AbstractDateFunction.PARAMETER_UNIT_NAME,
+                'DAYS',
+            ),
+        );
+
+        const result = await endOf.execute(fep);
+
+        expect(
+            result.allResults()[0].getResult().get(AbstractDateFunction.EVENT_TIMESTAMP_NAME),
+        ).toBe('2024-12-31T23:59:59.999-06:00');
     });
 });

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

@@ -14,7 +14,7 @@ describe('TimeAs', () => {
             new KIRunFunctionRepository(),
             new KIRunSchemaRepository(),
         ).setArguments(
-            MapUtil.of(TimeAs.PARAMETER_TIMESTAMP_NAME, '2024-11-10T10:10:10.100+05:30'),
+            MapUtil.of(TimeAs.PARAMETER_TIMESTAMP_NAME, '2024-11-10T10:10:10.100-05:00'),
         );
         const result = await timeAsArray.execute(fep);
         expect(result.allResults()[0].getResult().get(TimeAs.EVENT_TIME_ARRAY_NAME)).toEqual([

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

@@ -45,4 +45,22 @@ describe('ToDateString', () => {
             .get(AbstractDateFunction.EVENT_RESULT_NAME);
         expect(result).toBe('1 janvier 2024');
     });
+
+    test('should return the date string in the given format and no 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'],
+            ]),
+        );
+
+        const result = await (await new ToDateString().execute(fep))
+            .allResults()[0]
+            .getResult()
+            .get(AbstractDateFunction.EVENT_RESULT_NAME);
+        expect(result).toBe('1 January 2024');
+    });
 });