@fincity/kirun-js 2.3.1 → 2.3.2

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

@@ -0,0 +1,74 @@
+import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository } from "../../../../../src";
+import { DateToEpoch } from "../../../../../src/engine/function/system/date/DateToEpoch";
+
+const dte: DateToEpoch = new DateToEpoch();
+
+const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository()
+);
+
+describe('invalid date', () => {
+
+    test('invalid date one', async () => {
+
+        fep.setArguments(new Map([['isoDate', 'surendhar']]));
+
+        await expect( () => dte.execute(fep)).rejects.toThrow();
+        
+    })
+
+
+    test('invalid date one', async () => {
+
+        fep.setArguments(new Map([['isoDate', '2023-02-30T12:12:12.123Z']]));
+
+        await expect( () => dte.execute(fep)).rejects.toThrow();
+        
+    })
+
+})
+
+describe('valid date', () => {
+
+    test('valid date one', async () => {
+
+        fep.setArguments(new Map([['isoDate', '2023-10-21T16:11:50.978Z']]));
+        
+        expect((await dte.execute(fep)).allResults()[0].getResult().get('result')).toBe(1697904710978);
+
+    })
+
+    test('valid date two', async () => {
+
+        fep.setArguments(new Map([['isoDate', '2507-08-07T11:41:50.000Z']]));
+        
+        expect((await dte.execute(fep)).allResults()[0].getResult().get('result')).toBe(16964941310000);
+
+    })
+    
+    test('valid date three', async () => {
+
+        fep.setArguments(new Map([['isoDate', '1970-01-20T15:13:51.000Z']]));
+        
+        expect((await dte.execute(fep)).allResults()[0].getResult().get('result')).toBe(1696431000);
+
+    })
+
+    test('valid date four', async () => {
+
+        fep.setArguments(new Map([['isoDate', '2024-02-29T12:13:41.189-12:01']]));
+        
+        expect((await dte.execute(fep)).allResults()[0].getResult().get('result')).toBe(1709252081189);
+
+    })
+
+    test('valid date five', async () => {
+
+        fep.setArguments(new Map([['isoDate', '2028-02-29T12:13:49.200+02:01']]));
+        
+        expect((await dte.execute(fep)).allResults()[0].getResult().get('result')).toBe(1835431969200);
+
+    })
+
+});

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

@@ -0,0 +1,53 @@
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { DifferenceOfTimestamps } from '../../../../../src/engine/function/system/date/DifferenceOfTimestamps';
+
+const differenceOfTimestamps: DifferenceOfTimestamps = new DifferenceOfTimestamps();
+
+const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository()
+);
+
+
+describe('testing DifferenceOfTimestamps for invalid dates', () => {
+    
+
+    test('invalid date one', async () => {
+
+        fep.setArguments(new Map([['isoDateOne', '2029-05-95T06:04:18.073Z'], ['isoDateTwo', '2029-05-05T06:04:18.073Z']]));
+
+        await expect( () => differenceOfTimestamps.execute(fep)).rejects.toThrow();
+    })
+
+    test('invalid date one', async () => {
+
+        fep.setArguments(new Map([['isoDateOne', '2029-05-05T06:04:18.073Z']]));
+
+        await expect( () => differenceOfTimestamps.execute(fep)).rejects.toThrow();
+    })
+})
+
+describe('testing DifferenceOfTimestamps for valid dates', () => {
+
+    test('valid one', async () => {
+
+        fep.setArguments(new Map([['isoDateOne', '2024-09-13T23:52:34.633-05:30'], ['isoDateTwo', '2024-09-13T23:52:34.633Z']]));
+
+        expect((await differenceOfTimestamps.execute(fep)).allResults()[0].getResult().get('result')).toBe(-330);
+    })
+
+    test('valid two', async () => {
+
+        fep.setArguments(new Map([['isoDateOne', '2024-09-13T23:52:34.633-05:30'], ['isoDateTwo', '2024-09-12T23:52:34.633Z']]));
+
+        expect((await differenceOfTimestamps.execute(fep)).allResults()[0].getResult().get('result')).toBe(-1770);
+    })
+
+    test('valid three', async () => {
+
+        fep.setArguments(new Map([['isoDateOne', '2023-09-12T23:52:34.633Z'], ['isoDateTwo', '2024-09-13T23:52:34.633-05:30']]));
+
+        expect((await differenceOfTimestamps.execute(fep)).allResults()[0].getResult().get('result')).toBe(528810);
+    })
+})

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

@@ -0,0 +1,105 @@
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { EpochToDate } from '../../../../../src/engine/function/system/date/EpochToDate';
+
+const epochToDate: EpochToDate = new EpochToDate();
+
+describe('testing EpochToDateFunction', () => {
+    test('Epoch To Date', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epoch', 1694072117]]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).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([['epoch', 1694072117000]]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).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([['epoch', 169407211700]]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).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([['epoch', '1696489387']]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).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([['epoch', 'a1696489387']]));
+
+        expect(async () =>
+            (await epochToDate.execute(fep)).allResults()[0].getResult().get('date'),
+        ).rejects.toThrowError('Please provide a valid value for epoch.');
+    });
+
+    test('epoch string to date 3', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epoch', '169648938as7']]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).toBe(
+            '1975-05-18T12:42:18.000Z',
+        );
+    });
+
+    test('epoch string to date 4 all chars', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epoch', 'abcdef']]));
+
+        expect(async () =>
+            (await epochToDate.execute(fep)).allResults()[0].getResult().get('date'),
+        ).rejects.toThrow('Please provide a valid value for epoch.');
+    });
+
+    test('epoch test for large string function', async () => {
+        let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map([['epoch', '1696494131']]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).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([['epoch', '169640']]));
+
+        expect((await epochToDate.execute(fep)).allResults()[0].getResult().get('date')).toBe(
+            '1970-01-02T23:07:20.000Z',
+        );
+    });
+});

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

@@ -0,0 +1,35 @@
+import { FunctionExecutionParameters } from '../../../../../src/engine/runtime/FunctionExecutionParameters';
+import { KIRunFunctionRepository, KIRunSchemaRepository } from '../../../../../src';
+import { GetCurrentTimeStamp } from '../../../../../src/engine/function/system/date/GetCurrentTimeStamp';
+
+const gcts: GetCurrentTimeStamp = new GetCurrentTimeStamp();
+
+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)
+        );
+    });
+})
+
+describe('testing false case of 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()-1000000);
+
+        expect((await gcts.execute(fep)).allResults()[0].getResult().get('date')).not.toBe(
+            d.toISOString()
+        );
+    });
+})

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

@@ -0,0 +1,85 @@
+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";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const getDateFunction = await dfr.find(Namespaces.DATE, 'GetDate');
+
+    if (!getDateFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-05T06:04:18.073Z' ]]));
+
+    await expect( () => getDateFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+
+test('check for invalid dates', async () => {
+
+    const getDateFunction = await dfr.find(Namespaces.DATE, 'GetDate');
+
+    if (!getDateFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, false ]]));
+
+    await expect( () => getDateFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+test('fetching for valid date' , async () => {
+
+    const getDateFunction = await dfr.find(Namespaces.DATE, 'GetDate');
+
+    if (!getDateFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30' ]]));
+
+
+    expect( (await getDateFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(14);
+
+})
+
+test('fetching for valid date' , async () => {
+
+    const getDateFunction = await dfr.find(Namespaces.DATE, 'GetDate');
+
+    if (!getDateFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633Z' ]]));
+
+
+    expect( (await getDateFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(13);
+
+})
+
+
+test('fetching for valid date' , async () => {
+
+    const getDateFunction = await dfr.find(Namespaces.DATE, 'GetDate');
+
+    if (!getDateFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2023-12-31T07:35:17.000-12:00' ]]));
+
+
+    expect( (await getDateFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(31);
+
+})

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

@@ -0,0 +1,85 @@
+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";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const getDayFunction = await dfr.find(Namespaces.DATE, 'GetDay');
+
+    if (!getDayFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2029-05-95T06:04:18.073Z' ]]));
+
+    await expect( () => getDayFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+
+test('check for invalid dates', async () => {
+
+    const getDayFunction = await dfr.find(Namespaces.DATE, 'GetDay');
+
+    if (!getDayFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, 1234 ]]));
+
+    await expect( () => getDayFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+test('fetching for valid date' , async () => {
+
+    const getDayFunction = await dfr.find(Namespaces.DATE, 'GetDay');
+
+    if (!getDayFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30' ]]));
+
+
+    expect( (await getDayFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(6);
+
+})
+
+test('fetching for valid date' , async () => {
+
+    const getDayFunction = await dfr.find(Namespaces.DATE, 'GetDay');
+
+    if (!getDayFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-10T23:52:34.633Z' ]]));
+
+
+    expect( (await getDayFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(2);
+
+})
+
+
+test('fetching for valid date' , async () => {
+
+    const getDayFunction = await dfr.find(Namespaces.DATE, 'GetDay');
+
+    if (!getDayFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2023-12-31T07:35:17.000-12:00' ]]));
+
+
+    expect( (await getDayFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(0);
+
+})

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

@@ -0,0 +1,85 @@
+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";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const getFullYearFunction = await dfr.find(Namespaces.DATE, 'GetFullYear');
+
+    if (!getFullYearFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-95T06:04:18.073Z' ]]));
+
+    await expect( () => getFullYearFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+
+test('check for invalid dates', async () => {
+
+    const getFullYearFunction = await dfr.find(Namespaces.DATE, 'GetFullYear');
+
+    if (!getFullYearFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, 987654 ]]));
+
+    await expect( () => getFullYearFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+test('fetching for valid date' , async () => {
+
+    const getFullYearFunction = await dfr.find(Namespaces.DATE, 'GetFullYear');
+
+    if (!getFullYearFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30' ]]));
+
+
+    expect( (await getFullYearFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(2024);
+
+})
+
+test('fetching for valid date' , async () => {
+
+    const getFullYearFunction = await dfr.find(Namespaces.DATE, 'GetFullYear');
+
+    if (!getFullYearFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2019-09-13T23:52:34.633Z' ]]));
+
+
+    expect( (await getFullYearFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(2019);
+
+})
+
+
+test('fetching for valid date' , async () => {
+
+    const getFullYearFunction = await dfr.find(Namespaces.DATE, 'GetFullYear');
+
+    if (!getFullYearFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2023-12-31T07:35:17.000-12:00' ]]));
+
+
+    expect( (await getFullYearFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(2023);
+
+})

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

@@ -0,0 +1,85 @@
+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";
+
+
+const dfr : DateFunctionRepository = new DateFunctionRepository();
+
+const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository());
+
+test('check for invalid dates', async () => {
+
+    const getHoursFunction = await dfr.find(Namespaces.DATE, 'GetHours');
+
+    if (!getHoursFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2029-02-00T06:04:18.073Z' ]]));
+
+    await expect( () => getHoursFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+
+test('check for invalid dates', async () => {
+
+    const getHoursFunction = await dfr.find(Namespaces.DATE, 'GetHours');
+
+    if (!getHoursFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, 'cvb' ]]));
+
+    await expect( () => getHoursFunction.execute(fep)).rejects.toThrow();
+    
+});
+
+test('fetching for valid date' , async () => {
+
+    const getHoursFunction = await dfr.find(Namespaces.DATE, 'GetHours');
+
+    if (!getHoursFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-01T23:52:34.633-05:30' ]]));
+
+
+    expect( (await getHoursFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(5);
+
+})
+
+test('fetching for valid date' , async () => {
+
+    const getHoursFunction = await dfr.find(Namespaces.DATE, 'GetHours');
+
+    if (!getHoursFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2019-11-13T00:52:34.633Z' ]]));
+
+
+    expect( (await getHoursFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(0);
+
+})
+
+
+test('fetching for valid date' , async () => {
+
+    const getHoursFunction = await dfr.find(Namespaces.DATE, 'GetHours');
+
+    if (!getHoursFunction) {
+        throw new Error("Function not found");
+    }
+
+    fep.setArguments(new Map([[AbstractDateFunction.PARAMETER_DATE_NAME, '2023-12-31T07:35:17.000-12:00' ]]));
+
+
+    expect( (await getHoursFunction.execute(fep)).allResults()[0].getResult().get(AbstractDateFunction.EVENT_RESULT_NAME)).toBe(19);
+
+})