biz-a-cli 2.3.2 → 2.3.3

package/tests/hub.test.js

@@ -0,0 +1,87 @@
+import { Server } from 'socket.io';
+import { createServer } from 'node:http'
+import hubEvent from '../bin/hubEvent.js'
+import { io as ioc } from "socket.io-client";
+import { jest } from '@jest/globals';
+import { of } from "rxjs";
+import { Axios } from "axios-observable";
+
+let socketsBySubdomain = {};
+
+const createSocket2CLI = (socket) => {
+  return (subdomain, responseCb) => {
+    const responseCallback = (error) => { if (responseCb) responseCb(error) }
+    let subdomainStr = subdomain.toString();
+
+    socketsBySubdomain[subdomainStr] = socket;
+    socket.subdomain = subdomainStr;
+    // console.log(new Date() + ': ' + subdomainStr + ' registered successfully');
+
+    responseCallback(null);
+  }
+}
+
+const deleteSubdomain = (socket) => () => {
+  if (socket.subdomain) {
+    delete socketsBySubdomain[socket.subdomain];
+    console.log(new Date() + ': ' + socket.subdomain + ' unregistered');
+  }
+}
+
+const toPromise = (cb) => new Promise((resolve, reject) => {
+  cb(resolve)
+  setTimeout(() => reject(new Error('timeout')), 1000)
+})
+
+describe('cli req test', () => {
+  let io, port;
+  const startSocket = function startSocket(server) {
+    let io = new Server(server);
+    io.on('connection', (socket) => {
+      // console.log('socket client connect')
+      socket.on('createTunnel', createSocket2CLI(socket));
+      socket.on('disconnect', deleteSubdomain(socket));
+    });
+
+    return io;
+  }
+
+  beforeAll((done) => {
+    const httpServer = createServer()
+    io = startSocket(httpServer)
+
+    httpServer.listen(async () => {
+      port = httpServer.address().port;
+      done()
+    })
+  })
+
+  afterAll(() => {
+    io.close();
+  })
+
+  test('request to cli', async () => {
+    jest.spyOn(Axios, 'request').mockReturnValue(of({ data: 'OK' }));
+
+    let socket;
+    try {
+      socket = ioc(`http://localhost:${port}`);
+
+      await hubEvent(socket, {
+        server: `http://localhost:${port}`,
+        subdomain: 'scy',
+        hostname: 'localhost',
+        port: 212,
+      });
+
+      const result = await toPromise(resolve => socketsBySubdomain['scy'].emit(
+        'cli-req', { d: 1, }, cb => resolve(cb)
+      ))
+
+      expect(result).toStrictEqual('OK');
+      socket.disconnect();
+    } catch (error) {
+      console.log(error);
+    }
+  })
+})

package/tests/mailCtl.test.js

@@ -0,0 +1,34 @@
+
+import { jest } from '@jest/globals'
+
+const mockSendMail = jest.fn();
+const mockCreateTransport = jest.fn();
+mockCreateTransport.mockImplementation(() => ({
+    sendMail: mockSendMail
+}))
+
+jest.unstable_mockModule('nodemailer', () => ({
+    createTransport: (data) => mockCreateTransport(data)
+}))
+
+const { sendMailWatcher } = await import('../mailController.js');
+
+describe('Mail Controller', () => {
+    let req;
+
+    test('transporter.sendmailWatcher is called', () => {
+        req = {
+            body: {
+                companyname: 'abc',
+                smtpConfig: {
+                    smtp: 'test'
+                }
+            },
+        }
+
+        sendMailWatcher(req);
+        expect(mockSendMail).toBeCalledTimes(1);
+        expect(mockCreateTransport).toHaveBeenCalledWith({ smtp: 'test' });
+
+    })
+})

package/tests/timer.test.js

@@ -0,0 +1,91 @@
+import { jest } from '@jest/globals'
+
+const mockCheckSchedule = jest.fn();
+jest.unstable_mockModule("../scheduler/datalib.js", () => ({
+    checkSchedule: mockCheckSchedule.mockResolvedValue('OK'),
+    queryData: jest.fn().mockResolvedValue('OK'),
+    crudData: jest.fn().mockResolvedValue('OK'),
+    genId: jest.fn().mockResolvedValue('OK'),
+    delay: jest.fn().mockResolvedValue('OK')
+}))
+
+const {
+    SCHEDULE_INTERVAL,
+    getSelectedData,
+    increaseInterval,
+    runHistory
+} = await import('../scheduler/timer.js');
+const { ObjectId } = await import('mongodb');
+
+describe('timer and mitigation test', () => {
+    test('increase interval', async () => {
+        const nextTime = increaseInterval('2024-02-16T10:30:10.593Z');
+        expect(new Date(nextTime).toISOString()).toStrictEqual('2024-02-16T10:31:10.593Z');
+    });
+
+    test('get selected data from array', async () => {
+        const SELECTED_HISTORY = {
+            _id: new ObjectId('65c34df55e7c9d9448804738'),
+            timerObjectId: new ObjectId('65c34bd774ae2595b5efb5a9'),
+            latestRun: '2024-02-03T10:30:10.593Z'
+        };
+        const HISTORIES = [
+            {
+                _id: new ObjectId('65c34df55e7c9d9448804737'),
+                timerObjectId: new ObjectId('65c34bd774ae2595b5efb5a8'),
+                latestRun: '2024-02-16T10:30:10.593Z'
+            },
+            SELECTED_HISTORY,
+            {
+                _id: new ObjectId('65c3613d5e7c9d94489a32d2'),
+                timerObjectId: new ObjectId('65c35aa937be3a626388ba6e'),
+                latestRun: '2024-02-04T11:00:26.783Z'
+            }
+        ]
+        expect(getSelectedData(HISTORIES, 'timerObjectId', '65c34bd774ae2595b5efb5a9')).toStrictEqual(SELECTED_HISTORY);
+    });
+
+    test('run history', async () => {
+        function decreaseInterval(now) {
+            const subtractInterval = new Date(now).getMilliseconds() - (3 * SCHEDULE_INTERVAL);
+            return new Date(now).setMilliseconds(subtractInterval);
+        }
+
+        const NOW = new Date('2024-02-29T07:00:00.000Z');
+        const HISTORIES = [
+            {
+                _id: new ObjectId('65c34df55e7c9d9448804737'),
+                timerObjectId: new ObjectId('65c34bd774ae2595b5efb5a8'),
+                latestRun: new Date(decreaseInterval(NOW)).toISOString()
+            }
+        ]
+        const CONFIGS = [{
+            companyObjectId: new ObjectId('62948492f7d559fba6f32196')
+        }]
+        const WATCHERS = [
+            {
+                _id: new ObjectId('65c34bd674ae2595b5efb5a7'),
+                companyObjectId: new ObjectId('62948492f7d559fba6f32196'),
+                timer: [
+                    {
+                        _id: new ObjectId('65c34bd774ae2595b5efb5a8'),
+                        name: 'New Watcher 1',
+                        active: true,
+                        timezone: 'Asia/Jakarta',
+                        templateName: 'cekUser.js',
+                        daily: [
+                            0, 1, 2, 3,
+                            4, 5, 6
+                        ],
+                        minutely: { everyMin: 1, from: '09:00', to: '18:00' },
+                        watcherObjectId: new ObjectId('65c34bd674ae2595b5efb5a7'),
+                        seq: 0,
+                    }
+                ]
+            }
+        ]
+
+        await runHistory(HISTORIES, CONFIGS, WATCHERS, new Date('2024-02-29T07:00:00.000Z'));
+        expect(mockCheckSchedule).toBeCalledTimes(3);
+    });
+})

package/tests/watcher.test.js

@@ -0,0 +1,350 @@
+import { isItTime, loopTimer } from "../scheduler/watcherlib.js"
+
+describe('isItTime', () => {
+    // Note: 2023-11-6 is Monday
+
+    test('1 daily 1 day 1 hourly', () => {
+        let dataWatcher = {
+            active: true,
+            daily: [1],
+            hourly: ['10:15']
+        }
+        expect(isItTime(dataWatcher, '2023-11-5 10:15:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 10:15:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 10:15:59')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 10:15:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 10:14:59')).toBe(false)
+    })
+
+    test('1 daily 1 day 2 hourly', () => {
+        let dataWatcher = {
+            active: true,
+            daily: [1],
+            hourly: ['10:15', '1:05']
+        }
+        expect(isItTime(dataWatcher, '2023-11-6 1:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 1:04:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-5 1:05:01')).toBe(false)
+    })
+
+    test('1 daily 3 days 2 hourly', () => {
+        let dataWatcher = {
+            active: true,
+            daily: [1, 3, 5],
+            hourly: ['9:05', '17:05']
+        }
+        expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 9:04:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 9:06:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 17:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 17:04:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 17:06:01')).toBe(false)
+
+        expect(isItTime(dataWatcher, '2023-11-8 9:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-8 9:04:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-8 9:06:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-8 17:05:59')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-8 17:04:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-8 17:06:01')).toBe(false)
+
+
+        expect(isItTime(dataWatcher, '2023-11-10 9:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-10 17:05:01')).toBe(true)
+
+
+        expect(isItTime(dataWatcher, '2023-11-5 17:05:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 17:05:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-9 17:05:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-11 17:05:01')).toBe(false)
+
+        expect(isItTime(dataWatcher, '2023-11-13 17:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-14 17:05:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-15 17:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-16 17:05:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-17 17:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-18 17:05:01')).toBe(false)
+    })
+
+    test('1 daily 1 days 1 hourly data incomplete', () => {
+        let dataWatcher = {
+            active: true,
+            daily: [1],
+            hourly: '9:05'
+        }
+        expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(false)
+        dataWatcher.hourly = ['9:05']
+        expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(true)
+
+        // dataWatcher[0].time = {}
+        // expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(false)
+        // dataWatcher[0].time = { hourly: ['9:05'] }
+        // dataWatcher[0].hourly = ['9:05'];
+        // expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(true)
+
+        dataWatcher.daily = 1
+        expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(false)
+        dataWatcher.daily = [1]
+        expect(isItTime(dataWatcher, '2023-11-6 9:05:01')).toBe(true)
+    })
+
+    test('1 daily 1 day everyMin', () => {
+        let dataWatcher = {
+            active: true,
+            daily: [2],
+            minutely: {
+                everyMin: 5,
+                from: '9:00',
+                to: '17:00'
+            }
+        }
+        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: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)
+        expect(isItTime(dataWatcher, '2023-11-7 9:01:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 9:04:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 9:06:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 17:01:00')).toBe(false)
+
+        dataWatcher.minutely.everyMin = 7
+        expect(isItTime(dataWatcher, '2023-11-7 9:00:00')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:07:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:14:59')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:21:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:28:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:35:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:42:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:49:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 9:56:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 10:00:32')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 10:07:32')).toBe(true)
+    })
+
+    test('1 weekly 1 day', () => {
+        let dataWatcher = {
+            active: true,
+            weekly: {
+                ordinal: [1],
+                days: [2]
+            },
+            hourly: ['9:01']
+        } //every first Tuesday at 9:01
+
+        expect(isItTime(dataWatcher, '2023-11-7 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-14 9:01:01')).toBe(false)
+
+        dataWatcher.weekly.ordinal = [1, 3]
+        expect(isItTime(dataWatcher, '2023-11-21 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-28 9:01:01')).toBe(false)
+    })
+
+    test('1 weekly 3 day', () => {
+        let dataWatcher = {
+            active: true,
+            weekly: {
+                ordinal: [1],
+                days: [1, 3, 5]
+            },
+            hourly: ['9:01']
+        } //every first Mon, Wed, Fri at 9:01
+
+        expect(isItTime(dataWatcher, '2023-11-1 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-3 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-6 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-8 9:01:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-10 9:01:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-2 9:01:01')).toBe(false)
+
+        dataWatcher.weekly.ordinal = [1, 3]
+        expect(isItTime(dataWatcher, '2023-11-15 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-17 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-20 9:01:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-22 9:01:01')).toBe(false)
+    })
+
+    test('weekly incorrect data', () => {
+        let dataWatcher = {
+            active: true,
+            weekly: {
+                ordinal: [1],
+                days: 1
+            },
+            hourly: ['9:01']
+        }
+        expect(isItTime(dataWatcher, '2023-11-1 9:01:01')).toBe(false)
+
+        dataWatcher.weekly.days = [1]
+        dataWatcher.weekly.ordinal = 1
+        expect(isItTime(dataWatcher, '2023-11-1 9:01:01')).toBe(false)
+    })
+
+    test('1 monthly', () => {
+        let dataWatcher = {
+            active: true,
+            monthly: [2],
+            minutely: {
+                everyMin: 10,
+                from: '9:00',
+                to: '17:00'
+            }
+        }
+        expect(isItTime(dataWatcher, '2023-11-2 9:00:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-2 9:10:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-2 16:50:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-3 16:50:01')).toBe(false)
+
+        dataWatcher.monthly.push(15)
+        expect(isItTime(dataWatcher, '2023-11-15 16:50:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-16 16:50:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-14 16:50:01')).toBe(false)
+    })
+
+    test('eom monthly', () => {
+        let dataWatcher = {
+            active: true,
+            monthly: ['eom'],
+            minutely: {
+                everyMin: 10,
+                from: '9:00',
+                to: '17:00'
+            }
+        }
+        expect(isItTime(dataWatcher, '2023-11-2 9:00:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-2 9:10:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-2 16:50:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-3 16:50:01')).toBe(false)
+
+        expect(isItTime(dataWatcher, '2023-11-30 9:00:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-30 9:10:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-30 16:50:01')).toBe(true)
+
+        expect(isItTime(dataWatcher, '2023-11-29 16:50:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-12-1 16:50:01')).toBe(false)
+    })
+
+    test('1 monthly incorrect data', () => {
+        let dataWatcher = {
+            active: true,
+            monthly: 2,
+            minutely: {
+                everyMin: 10,
+                from: '9:00',
+                to: '17:00'
+            }
+        }
+        expect(isItTime(dataWatcher, '2023-11-15 16:50:01')).toBe(false)
+    })
+
+    test('1 monthly from to overlap', () => {
+        let dataWatcher = {
+            active: true,
+            monthly: [2],
+            minutely: {
+                everyMin: 10,
+                from: '09:00',
+                to: '08:00'
+            }
+        }
+        expect(isItTime(dataWatcher, '2023-11-2 9:00:01')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 9:00:00')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 8:59:59')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 8:00:01')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 8:00:00')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 7:59:59')).toBe(false);
+    })
+
+    test('1 monthly from to overlap different day', () => {
+        let dataWatcher = {
+            active: true,
+            monthly: [2],
+            minutely: {
+                everyMin: 10,
+                from: '22:00',
+                to: '02:00'
+            }
+        }
+        expect(isItTime(dataWatcher, '2023-11-2 22:00:01')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 22:00:00')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 21:59:59')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 2:00:01')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 2:00:00')).toBe(false);
+        expect(isItTime(dataWatcher, '2023-11-2 1:59:59')).toBe(false);
+    })
+
+    test('watcher not active', () => {
+        let dataWatcher = {
+            active: false,
+            daily: [1],
+            hourly: ['10:15']
+        }
+        expect(isItTime(dataWatcher, '2023-11-5 10:15:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-7 10:15:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 10:15:59')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 10:15:01')).toBe(false)
+        expect(isItTime(dataWatcher, '2023-11-6 10:14:59')).toBe(false)
+    })
+
+    test('Mix daily weekly monthly', () => {
+        let dataWatchers = [
+            {   //every sunday at 10:00
+                active: true,
+                daily: [0],
+                // time: { hourly: ['10:00'] }
+                hourly: ['10:00']
+            },
+            {   //or every first Monday at 9:00
+                active: true,
+                weekly: { ordinal: [1], days: [1] },
+                // time: { hourly: ['9:00'] }
+                hourly: ['9:00']
+            },
+            {  //or every 15th at 11:00
+                active: true,
+                monthly: [15],
+                // time: { hourly: ['11:00'] }
+                hourly: ['11:00']
+            }
+        ]
+
+        let dummyConfig = { companyObjectId: '62948492f7d559fba6f32196' };
+
+        expect(loopTimer(dataWatchers, '2023-11-5 10:00:01', dummyConfig)).toStrictEqual([true, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-12 10:00:01', dummyConfig)).toStrictEqual([true, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-19 10:00:01', dummyConfig)).toStrictEqual([true, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-26 10:00:01', dummyConfig)).toStrictEqual([true, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-6 9:00:01', dummyConfig)).toStrictEqual([false, true, false])
+        expect(loopTimer(dataWatchers, '2023-11-15 11:00:01', dummyConfig)).toStrictEqual([false, false, true])
+        expect(loopTimer(dataWatchers, '2023-11-16 11:00:01', dummyConfig)).toStrictEqual([false, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-13 9:00:01', dummyConfig)).toStrictEqual([false, false, false])
+        expect(loopTimer(dataWatchers, '2023-11-5 9:59:01', dummyConfig)).toStrictEqual([false, false, false])
+    })
+
+    test('watcher has timezone (UTC + 8) (UTC + 9)', () => {
+        let dataWatcher = [{
+            active: true,
+            timezone: 'Asia/Makassar',
+            daily: [1],
+            hourly: ['10:15']
+        }, {
+            active: true,
+            timezone: 'Asia/Jayapura',
+            daily: [1],
+            hourly: ['10:15']
+        }]
+
+        let dummyConfig = { companyObjectId: '62948492f7d559fba6f32196' };
+
+        expect(loopTimer(dataWatcher, '2023-11-5 8:15:59', dummyConfig)).toStrictEqual([false, false])
+        expect(loopTimer(dataWatcher, '2023-11-7 8:15:59', dummyConfig)).toStrictEqual([false, false])
+        expect(loopTimer(dataWatcher, '2023-11-6 8:15:59', dummyConfig)).toStrictEqual([false, true])
+        expect(loopTimer(dataWatcher, '2023-11-6 8:15:01', dummyConfig)).toStrictEqual([false, true])
+        expect(loopTimer(dataWatcher, '2023-11-6 8:14:59', dummyConfig)).toStrictEqual([false, false])
+
+        expect(loopTimer(dataWatcher, '2023-11-5 9:15:59', dummyConfig)).toStrictEqual([false, false])
+        expect(loopTimer(dataWatcher, '2023-11-7 9:15:59', dummyConfig)).toStrictEqual([false, false])
+        expect(loopTimer(dataWatcher, '2023-11-6 9:15:59', dummyConfig)).toStrictEqual([true, false])
+        expect(loopTimer(dataWatcher, '2023-11-6 9:15:01', dummyConfig)).toStrictEqual([true, false])
+        expect(loopTimer(dataWatcher, '2023-11-6 9:14:59', dummyConfig)).toStrictEqual([false, false])
+    })
+})

package/tests/watcherCtl.test.js

@@ -0,0 +1,128 @@
+import { jest } from '@jest/globals';
+import { of } from "rxjs";
+
+let mockQueryData = jest.fn();
+let mockCrudData = jest.fn().mockImplementation(param => of(param));
+
+jest.unstable_mockModule('../scheduler/datalib.js', () => ({
+    // queryData: jest.fn().mockReturnValue(of([{ history_id: '10' }])),
+    queryData: mockQueryData,
+    genId: jest.fn().mockReturnValue(of(20)),
+    crudData: mockCrudData
+}));
+
+const {
+    getWatcherParameters,
+    getInsertHistoryParameters,
+    getHistoryParameters,
+    getHistoryField,
+    formatDate2API,
+    insertHistory
+} = await import("../scheduler/watcherController.js");
+
+describe('Get Watcher Parameters', () => {
+    test('get parameters', () => {
+        expect(getWatcherParameters()).toStrictEqual({
+            // filter: [{ junction: '', column: 'ID', operator: '=', value1: `'${watcherFilter?.companyObjectId}'` }],
+            columns: [
+                { data: "SYS$WATCHER.ID", key: 'watcher_id' },
+                { data: "SYS$WATCHER.COMPANY_OBJ_ID", key: 'company_id' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.ID", key: 'timer_id' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.WATCHER_ID", key: 'timer_watcher_id' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.NAME", key: 'name' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.ACTIVE", key: 'active' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.TIME_ZONE", key: 'timezone' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SCRIPT_NAME", key: 'templateName' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SEQ", key: 'seq' },
+                { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SCRIPT_ID", key: 'scriptId' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$DAILY.DAYS", key: 'daily_days' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$WEEKLY.ORDINAL", key: 'weekly_ordinal' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$WEEKLY.DAYS", key: 'weekly_days' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$MONTHLY.DAYS", key: 'monthly_days' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.EVERYMIN", key: 'minutely_everymin' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.TIME_FROM", key: 'minutely_time_from' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.TIME_TO", key: 'minutely_time_to' },
+                { data: "SYS$TIMER.ID.TIMER_ID.SYS$HOURLY.HOURS", key: 'hourly_hours' },
+                { data: "SYS$TIMER.SCRIPT_ID.ID.SYS$CLI_SCRIPT.SCRIPT", key: 'cli_script' }
+            ]
+        });
+    })
+})
+
+describe('Get Insert History Parameters', () => {
+    test('get parameters', () => {
+        expect(getInsertHistoryParameters('abc')).toStrictEqual({
+            filter: [{
+                junction: '',
+                column: 'TIMER_ID',
+                operator: '=',
+                value1: "'abc'"
+            }],
+            columns: [
+                { data: "HISTORY.ID", key: 'history_id' },
+            ]
+        })
+    })
+})
+
+describe('Format Date to API', () => {
+    test('date conversion', () => {
+        expect(formatDate2API('2024-03-06T14:37:16.610Z')).toStrictEqual('2024-03-06 14:37:16.610');
+    })
+})
+
+describe('Get History Field', () => {
+    test('get field', () => {
+        expect(getHistoryField('345', 12, '2024-03-06T14:37:16.610Z')).toStrictEqual({
+            SYS$HISTORY: {
+                ID: 12,
+                TIMER_ID: parseInt('345'),
+                LATEST_RUN: '2024-03-06 14:37:16.610'
+            }
+        })
+    })
+})
+
+describe('Get History Parameters', () => {
+    test('get parameters', () => {
+        expect(getHistoryParameters()).toStrictEqual({
+            columns: [
+                { data: "SYS$HISTORY.ID", key: 'history_id' },
+                { data: "SYS$HISTORY.TIMER_ID", key: 'timer_id' },
+                { data: "SYS$HISTORY.LATEST_RUN", key: 'latest_run' }
+            ]
+        })
+    })
+})
+
+describe('Insert History', () => {
+    test('has history', () => {
+        mockQueryData.mockReturnValue(of([{ history_id: '10' }]));
+
+        insertHistory({}, '1', '2024-03-06T14:37:16.610Z');
+        expect(mockCrudData).toHaveBeenCalledWith(
+            {
+                "SYS$HISTORY": {
+                    "ID": 10,
+                    "LATEST_RUN": "2024-03-06 14:37:16.610",
+                    "TIMER_ID": 1
+                }
+            }, {}, "put", "orm");
+    })
+
+    test('no history', () => {
+        jest.clearAllMocks();
+        mockQueryData.mockReturnValue(of([]));
+
+        insertHistory({}, '1', '2024-03-06T14:37:16.610Z');
+        expect(mockCrudData).toHaveBeenCalledWith(
+            {
+                "SYS$HISTORY": {
+                    "ID": 20,
+                    "LATEST_RUN": "2024-03-06 14:37:16.610",
+                    "TIMER_ID": 1
+                }
+            }, {}, "put", "orm");
+    })
+
+})