biz-a-cli 2.3.53 → 2.3.54

package/scheduler/timer.js

@@ -1,7 +1,6 @@
 import { checkSchedule } from "./datalib.js"
 import { getWatchers, getHistories } from "./watcherController.js";
 import { isItTime, loopTimer } from "./watcherlib.js"
-import { setInterval } from 'timers/promises';
 import { getCompanyObjectId, getSelectedConfig } from "../scheduler/configController.js";
 import { historyRecordToJson, watcherRecordToJson, setUtcDate } from "./converter.js";
 
@@ -46,31 +45,44 @@ export async function runHistory(histories, config, watchers, now) {
     }
 }
 
+export async function runRecentSchedule(intervalTime, config) {
+    const result = await getWatchers(config);
+    const watchers = watcherRecordToJson(result);
+
+    for (const watcher of watchers) {
+        loopTimer(watcher.timer, intervalTime, config, true);
+    }
+
+    // reload == true ?
+}
+
+export async function* setConstantInterval(interval, start) {  //SCY BZ 4169
+    let nextTime = start;
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, nextTime - Date.now()));
+        yield nextTime;
+        nextTime += interval;
+    }
+}
 
 export const runScheduler = async (companyName) => {
     const company = await getCompanyObjectId(companyName);
     const config = await getSelectedConfig(company._id);
 
-    Promise.all([getHistories(config), getWatchers(config)])
-        .then(([historyResult, watcherResult]) => {
-            const histories = historyRecordToJson(historyResult);
-            const watchers = watcherRecordToJson(watcherResult);
-            runHistory(histories, config, watchers, new Date());
-        });
+    Promise.all([getHistories(config), getWatchers(config)]).then(([historyResult, watcherResult]) => {
+        const histories = historyRecordToJson(historyResult);
+        const historyWatchers = watcherRecordToJson(watcherResult);
+        runHistory(histories, config, historyWatchers, new Date());
+    });
+
 
     let intervalStartTime = '';
-    for await (const startTime of setInterval(SCHEDULE_INTERVAL, Date.now())) {
+    for await (const intervalTime of setConstantInterval(SCHEDULE_INTERVAL, Date.now())) {
         if (!intervalStartTime) {
-            console.log('Interval Time starts at :', new Date(startTime));
-            intervalStartTime = new Date(startTime);
-        }
-        
-        const result = await getWatchers(config);
-        const watchers = watcherRecordToJson(result);
-        for (const watcher of watchers) {
-            loopTimer(watcher.timer, Date.now(), config, true);
+            console.log('Interval Time starts at :', new Date(intervalTime));
+            intervalStartTime = new Date(intervalTime);
         }
 
-        // // reload == true ?
+        await runRecentSchedule(intervalTime, config);
     }
 }

package/tests/data.test.js

@@ -46,6 +46,8 @@ describe('data test', () => {
         "}";
 
     test('check schedule subscription no history', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -62,9 +64,13 @@ describe('data test', () => {
 
         await scheduleSubscription(config, data, trigger, false, true);
         expect(mockInsertHistory).toBeCalledTimes(0);
+        expect(logSpy).toHaveBeenCalledWith('Run Schedule : New Watcher 1');
+
+        logSpy.mockRestore();
     });
 
     test('check schedule subscription with history', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -82,6 +88,9 @@ describe('data test', () => {
 
         await scheduleSubscription(config, data, trigger, true, true);
         expect(mockInsertHistory).toBeCalledTimes(1);
+        expect(logSpy).toHaveBeenCalledWith('Run Recent Schedule : New Watcher 1');
+
+        logSpy.mockRestore();
     });
 
     test('get input data', () => {
@@ -339,6 +348,8 @@ describe('data test', () => {
     });
 
     test('should return undefined when data has error', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         const config = {};
         const data = { error: 'error' };
 
@@ -346,6 +357,9 @@ describe('data test', () => {
         const expected = undefined;
 
         expect(actual).toStrictEqual(expected);
+        expect(logSpy).toHaveBeenCalledWith('error', 'error');
+
+        logSpy.mockRestore();
     });
 
     test('should return undefined when no data', async () => {

package/tests/hub.test.js

@@ -58,6 +58,7 @@ describe('cli req test', () => {
     })
 
     test('request to cli', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
         let mockedRequest = jest.spyOn(axios, 'request').mockReturnValue({ data: 'OK' });
 
         let socket;
@@ -103,6 +104,10 @@ describe('cli req test', () => {
             });
 
             socket.disconnect();
+
+            expect(logSpy).toHaveBeenCalledWith('error', 'error');
+
+            logSpy.mockRestore();
         } catch (error) {
             console.log(error);
         }

package/tests/mailCtl.test.js

@@ -17,6 +17,8 @@ describe('Mail Controller', () => {
     let req;
 
     test('transporter.sendMailCliScript is called', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         req = {
             body: {
                 companyname: 'abc',
@@ -35,5 +37,8 @@ describe('Mail Controller', () => {
         expect(await sendMailCliScript(req)).toEqual('error');
 
         expect(mockSendMail).toBeCalledTimes(2);
+        expect(logSpy).toHaveBeenCalledWith('Error: error');
+
+        logSpy.mockRestore();
     })
 })

package/tests/timer.test.js

@@ -1,4 +1,31 @@
 import { jest } from '@jest/globals'
+const { ObjectId } = await import('mongodb');
+
+const CONFIGS = [{
+    companyObjectId: new ObjectId('62948492f7d559fba6f32196')
+}]
+
+const RAW_WATCHERS = [{
+    watcher_id: 1,
+    company_id: '62948492f7d559fba6f32196',
+    timer_id: 1,
+    timer_watcher_id: 1,
+    name: 'New Watcher 1',
+    active: true,
+    timezone: 'Asia/Jakarta',
+    templateName: 'cekUser.js',
+    seq: 0,
+    daily_days: '0,1,2,3,4,5,6',
+    weekly_ordinal: '',
+    weekly_days: '',
+    monthly_days: '',
+    minutely_everymin: 1,
+    minutely_time_from: '08:00',
+    minutely_time_to: '22:00',
+    hourly_hours: '',
+    scriptid: 1,
+    cli_script: 'abc'
+}];
 
 const mockCheckSchedule = jest.fn();
 jest.unstable_mockModule("../scheduler/datalib.js", () => ({
@@ -9,13 +36,29 @@ jest.unstable_mockModule("../scheduler/datalib.js", () => ({
     delay: jest.fn().mockResolvedValue('OK')
 }))
 
+jest.unstable_mockModule("../scheduler/watcherController.js", () => ({
+    getWatchers: jest.fn(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return RAW_WATCHERS;
+    }),
+    getHistories: jest.fn().mockResolvedValue('OK')
+}))
+
+const mockLoopTimer = jest.fn();
+jest.unstable_mockModule("../scheduler/watcherLib.js", () => ({
+    loopTimer: mockLoopTimer.mockResolvedValue('OK'),
+    isItTime: jest.fn().mockResolvedValue('OK'),
+}))
+
 const {
-    SCHEDULE_INTERVAL,
+    // SCHEDULE_INTERVAL,
     getSelectedData,
     increaseInterval,
-    runHistory
+    runHistory,
+    runRecentSchedule,
+    setConstantInterval
 } = await import('../scheduler/timer.js');
-const { ObjectId } = await import('mongodb');
+
 
 describe('timer and mitigation test', () => {
     test('increase interval', async () => {
@@ -60,9 +103,7 @@ describe('timer and mitigation test', () => {
                 // latestRun: new Date(decreaseInterval(NOW)).toISOString()
             }
         ]
-        const CONFIGS = [{
-            companyObjectId: new ObjectId('62948492f7d559fba6f32196')
-        }]
+
         const WATCHERS = [
             {
                 _id: new ObjectId('65c34bd674ae2595b5efb5a7'),
@@ -89,4 +130,58 @@ describe('timer and mitigation test', () => {
         await runHistory(HISTORIES, CONFIGS, WATCHERS, new Date('2024-02-29T07:00:00.000Z'));
         expect(mockCheckSchedule).toBeCalledTimes(3);
     });
+
+    test('run recent schedule with delay functions', async () => {
+        const startTime = Date.now();
+
+        const WATCHER_CONVERTED = [{
+            "_id": 1,
+            "watcherObjectId": 1,
+            "name": "New Watcher 1",
+            "active": true,
+            "timezone": "Asia/Jakarta",
+            "templateName": "cekUser.js",
+            "seq": 0,
+            "scriptid": 1,
+            "script": "\"abc\"",
+            "daily": [0, 1, 2, 3, 4, 5, 6],
+            "minutely": {
+                "everyMin": 1,
+                "from": "08:00",
+                "to": "22:00"
+            }
+        }];
+
+        await runRecentSchedule(startTime, CONFIGS[0]);
+        expect(mockLoopTimer).toHaveBeenCalledWith(WATCHER_CONVERTED, startTime, CONFIGS[0], true);
+    });
+
+    test('constant interval', async () => {
+        jest.useFakeTimers();
+        jest.spyOn(global, 'setTimeout');
+
+        const interval = 1000;
+        const startTime = Date.now();
+        const generator = setConstantInterval(interval, startTime);
+
+        let results = [];
+
+        const fetchNextValue = async () => {
+            const next = generator.next();
+            jest.advanceTimersByTime(interval);
+
+            return (await next).value;
+        };
+
+        results.push(await fetchNextValue());
+        results.push(await fetchNextValue());
+        results.push(await fetchNextValue());
+
+        expect(results[0]).toBe(startTime);
+        expect(results[1]).toBe(startTime + interval);
+        expect(results[2]).toBe(startTime + 2 * interval);
+        expect(results[3]).toBe(undefined);
+
+        jest.useRealTimers();
+    });
 })

package/tests/watcher.test.js

@@ -97,8 +97,10 @@ describe('isItTime', () => {
                 to: '17:00'
             }
         }
+        expect(isItTime(dataWatcher, '2023-11-7 9:00:00')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 9:00:01')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 9:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 17:00:00')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 17:00:01')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 16:55:59')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 8:59:59')).toBe(false)