@ray-js/lamp-schedule-core 1.0.1-beta-9 → 1.0.2-beta-1

package/lib/hooks/__test__/useTimerFlushList.test.js

@@ -0,0 +1,117 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { renderHook } from '@testing-library/react-hooks';
+import { useCloudTimerListFlush, useRtcTimerListFlush, useTimerListFlush } from '../useTimerFlushList';
+import { useTimerContext } from '../../context/timer/context';
+import { useSupportLocalTimer } from '../useTimerSupport';
+jest.mock('../../context/timer/context', () => ({
+  useTimerContext: jest.fn()
+}));
+jest.mock('../useTimerSupport', () => ({
+  useSupportLocalTimer: jest.fn()
+}));
+describe('useTimerFlushList hooks', () => {
+  const mockDispatch = jest.fn();
+  const mockFlushCloud = jest.fn();
+  const mockFlushRtc = jest.fn();
+  const setContextMock = overrides => {
+    useTimerContext.mockReturnValue(_objectSpread({
+      actions: {
+        flushCloudTimerList: mockFlushCloud,
+        flushRtcTimerList: mockFlushRtc
+      },
+      dispatch: mockDispatch,
+      state: {
+        cloudTimerList: [],
+        rtcTimerList: []
+      }
+    }, overrides));
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    setContextMock({});
+  });
+  describe('useCloudTimerListFlush', () => {
+    it('dispatches flushCloudTimerList with provided payload', () => {
+      const mockActionResult = {
+        type: 'cloud'
+      };
+      mockFlushCloud.mockReturnValue(mockActionResult);
+      const payload = [{
+        timerId: '1'
+      }];
+      const {
+        result
+      } = renderHook(() => useCloudTimerListFlush());
+      result.current.flushCloudTimerList(payload);
+      expect(mockFlushCloud).toHaveBeenCalledWith(payload);
+      expect(mockDispatch).toHaveBeenCalledWith(mockActionResult);
+    });
+  });
+  describe('useRtcTimerListFlush', () => {
+    it('dispatches flushRtcTimerList with provided payload', () => {
+      const mockActionResult = {
+        type: 'rtc'
+      };
+      mockFlushRtc.mockReturnValue(mockActionResult);
+      const payload = [{
+        id: 'rtc_1'
+      }];
+      const {
+        result
+      } = renderHook(() => useRtcTimerListFlush());
+      result.current.flushRtcTimerList(payload);
+      expect(mockFlushRtc).toHaveBeenCalledWith(payload);
+      expect(mockDispatch).toHaveBeenCalledWith(mockActionResult);
+    });
+  });
+  describe('useTimerListFlush', () => {
+    const setSupportMock = value => {
+      useSupportLocalTimer.mockReturnValue(_objectSpread({
+        isReady: true,
+        isSupport: false
+      }, value));
+    };
+    it('uses rtc flush when local timer is supported', () => {
+      const mockRtcAction = {
+        type: 'rtc'
+      };
+      mockFlushRtc.mockReturnValue(mockRtcAction);
+      setSupportMock({
+        isSupport: true,
+        isReady: true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerListFlush());
+      const payload = [{
+        id: 'rtc_1'
+      }];
+      result.current.flushTimerList(payload);
+      expect(mockFlushRtc).toHaveBeenCalledWith(payload);
+      expect(mockFlushCloud).not.toHaveBeenCalled();
+      expect(mockDispatch).toHaveBeenCalledWith(mockRtcAction);
+      expect(result.current.isReady).toBe(true);
+    });
+    it('falls back to cloud flush when local timer is not supported', () => {
+      const mockCloudAction = {
+        type: 'cloud'
+      };
+      mockFlushCloud.mockReturnValue(mockCloudAction);
+      setSupportMock({
+        isSupport: false,
+        isReady: false
+      });
+      const {
+        result
+      } = renderHook(() => useTimerListFlush());
+      const payload = [{
+        id: 'cloud_1'
+      }];
+      result.current.flushTimerList(payload);
+      expect(mockFlushCloud).toHaveBeenCalledWith(payload);
+      expect(mockFlushRtc).not.toHaveBeenCalled();
+      expect(mockDispatch).toHaveBeenCalledWith(mockCloudAction);
+      expect(result.current.isReady).toBe(false);
+    });
+  });
+});

package/lib/hooks/__test__/useTimerOperate.test.js

@@ -1,6 +1,6 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { renderHook, act } from '@testing-library/react-hooks';
-import { useTimerAdd, useTimerAddWithFlush, useTimerUpdate, useTimerRemove, useTimerUpdateStatus } from '../useTimerOperate';
+import { useTimerAdd, useTimerAddWithFlush, useTimerUpdate, useTimerRemove, useTimerUpdateStatus, useTimerUpdateWithFlush, useTimerRemoveWithFlush, useTimerUpdateStatusWithFlush } from '../useTimerOperate';
 import { useSupportLocalTimer } from '../useTimerSupport';
 import { useSupport } from '../useCommonSupport';
 import { useTimerDp } from '../useTimerDp';
@@ -29,6 +29,25 @@ const mockTimer = {
   aliasName: 'Test Timer',
   isAppPush: false
 };
+const mockTimerAddPayload = {
+  time: '12:00',
+  loops: '1111111',
+  dps: {
+    power: true
+  },
+  aliasName: 'Test Timer',
+  isAppPush: true
+};
+const mockTimerUpdatePayload = {
+  timerId: '1',
+  time: '12:30',
+  loops: '1111111',
+  dps: {
+    power: false
+  },
+  aliasName: 'Updated Timer',
+  isAppPush: false
+};
 describe('useTimerOperate Hooks', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -152,7 +171,7 @@ describe('useTimerOperate Hooks', () => {
       const {
         result
       } = renderHook(() => useTimerAdd());
-      const response = await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      const response = await result.current.addTimer(mockTimerAddPayload, CLOUD_TIMER_CATEGORY);
       expect(response).toBeTruthy();
     });
     it('should add cloud timer when device is in group', async () => {
@@ -165,13 +184,50 @@ describe('useTimerOperate Hooks', () => {
       await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
       expect(useTimerOperateCloud.useCloudTimerAdd).toHaveBeenCalled();
     });
+    it('should generate missing timerId for local timer addition', async () => {
+      var _createdTimer;
+      const mockUpdateDp = jest.fn();
+      useTimerDp.mockReturnValue({
+        updateDp: mockUpdateDp
+      });
+      getTimerState.mockReturnValue({
+        rtcTimerList: [{
+          timerId: '2',
+          time: '10:00',
+          loops: '1111111',
+          status: true,
+          dps: {},
+          aliasName: '',
+          isAppPush: false
+        }]
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAdd());
+      const timerInput = {
+        time: '09:00',
+        loops: '0000000',
+        dps: {
+          power: false
+        },
+        aliasName: 'Auto Id',
+        isAppPush: false
+      };
+      let createdTimer = null;
+      await act(async () => {
+        createdTimer = await result.current.addTimer(timerInput, CLOUD_TIMER_CATEGORY);
+      });
+      expect(mockUpdateDp).toHaveBeenCalledWith(expect.objectContaining({
+        timerId: '1',
+        status: true,
+        time: '09:00'
+      }));
+      expect((_createdTimer = createdTimer) === null || _createdTimer === void 0 ? void 0 : _createdTimer.timerId).toBe('1');
+    });
   });
   describe('useTimerAddWithFlush', () => {
     it('should add timer and flush list', async () => {
       const mockFlushTimerList = jest.fn();
-      jest.fn().mockResolvedValue({
-        timers: []
-      });
       useTimerListFlush.mockReturnValue({
         flushTimerList: mockFlushTimerList,
         isReady: true
@@ -193,6 +249,33 @@ describe('useTimerOperate Hooks', () => {
       });
       expect(mockFlushTimerList).toHaveBeenCalled();
     });
+    it('should reset loading when refresh list fails', async () => {
+      const refreshError = new Error('refresh failed');
+      const mockFlushTimerList = jest.fn();
+      useTimerListFlush.mockReturnValue({
+        flushTimerList: mockFlushTimerList,
+        isReady: true
+      });
+      useTimerOperateLocal.useLocalTimerList.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        getTimerList: jest.fn().mockRejectedValue(refreshError)
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAddWithFlush());
+      let caughtError = null;
+      await act(async () => {
+        try {
+          await result.current.addTimerWithFlush(mockTimerAddPayload);
+        } catch (err) {
+          caughtError = err;
+        }
+      });
+      expect(caughtError).toBe(refreshError);
+      expect(mockFlushTimerList).not.toHaveBeenCalled();
+      expect(result.current.isLoading).toBe(false);
+    });
   });
   describe('useTimerUpdate', () => {
     it('should handle local timer update when supported', async () => {
@@ -232,6 +315,21 @@ describe('useTimerOperate Hooks', () => {
       }));
       expect(useTimerOperateCloud.useCloudTimerUpdate).toHaveBeenCalled();
     });
+    it('should propagate errors from local timer update', async () => {
+      const updateError = new Error('update failed');
+      const mockUpdate = jest.fn().mockRejectedValue(updateError);
+      useTimerOperateLocal.useLocalTimerUpdate.mockReturnValue({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        updateTimer: mockUpdate
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdate());
+      await expect(act(async () => {
+        await result.current.updateTimer(mockTimerUpdatePayload, mockTimerUpdatePayload);
+      })).rejects.toThrow(updateError);
+    });
   });
   describe('useTimerRemove', () => {
     it('should handle local timer removal when supported', async () => {
@@ -283,4 +381,140 @@ describe('useTimerOperate Hooks', () => {
       expect(useTimerOperateCloud.useCloudTimerUpdateStatus).toHaveBeenCalled();
     });
   });
+  describe('useTimerUpdateWithFlush', () => {
+    it('should flush list after successful update', async () => {
+      const timersResponse = {
+        timers: [mockTimer]
+      };
+      const mockFlushTimerList = jest.fn();
+      useTimerListFlush.mockReturnValue({
+        flushTimerList: mockFlushTimerList,
+        isReady: true
+      });
+      useTimerOperateLocal.useLocalTimerList.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        getTimerList: jest.fn().mockResolvedValue(timersResponse)
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateWithFlush());
+      await act(async () => {
+        const success = await result.current.updateTimerWithFlush(mockTimerUpdatePayload, mockTimerUpdatePayload, CLOUD_TIMER_CATEGORY);
+        expect(success).toBe(true);
+      });
+      expect(mockFlushTimerList).toHaveBeenCalledWith(timersResponse.timers);
+    });
+    it('should reset loading when update fails', async () => {
+      const updateError = new Error('update with flush failed');
+      useTimerOperateLocal.useLocalTimerUpdate.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        updateTimer: jest.fn().mockRejectedValue(updateError)
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateWithFlush());
+      let caught = null;
+      await act(async () => {
+        try {
+          await result.current.updateTimerWithFlush(mockTimerUpdatePayload, mockTimerUpdatePayload, CLOUD_TIMER_CATEGORY);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      expect(caught).toBe(updateError);
+      expect(result.current.isLoading).toBe(false);
+    });
+  });
+  describe('useTimerRemoveWithFlush', () => {
+    it('should flush list after removing timer', async () => {
+      const mockFlushTimerList = jest.fn();
+      useTimerListFlush.mockReturnValue({
+        flushTimerList: mockFlushTimerList,
+        isReady: true
+      });
+      useTimerOperateLocal.useLocalTimerList.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        getTimerList: jest.fn().mockResolvedValue({
+          timers: [mockTimer]
+        })
+      });
+      const {
+        result
+      } = renderHook(() => useTimerRemoveWithFlush());
+      await act(async () => {
+        const res = await result.current.removeTimerWithFlush('1', CLOUD_TIMER_CATEGORY);
+        expect(res).toBe(true);
+      });
+      expect(mockFlushTimerList).toHaveBeenCalledWith([mockTimer]);
+    });
+    it('should stop loading when remove fails', async () => {
+      const removeError = new Error('remove failed');
+      useTimerOperateLocal.useLocalTimerRemove.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        removeTimer: jest.fn().mockRejectedValue(removeError)
+      });
+      const {
+        result
+      } = renderHook(() => useTimerRemoveWithFlush());
+      let caught = null;
+      await act(async () => {
+        try {
+          await result.current.removeTimerWithFlush('1', CLOUD_TIMER_CATEGORY);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      expect(caught).toBe(removeError);
+      expect(result.current.isLoading).toBe(false);
+    });
+  });
+  describe('useTimerUpdateStatusWithFlush', () => {
+    it('should flush list after updating status', async () => {
+      const mockFlushTimerList = jest.fn();
+      useTimerListFlush.mockReturnValue({
+        flushTimerList: mockFlushTimerList,
+        isReady: true
+      });
+      useTimerOperateLocal.useLocalTimerList.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        getTimerList: jest.fn().mockResolvedValue({
+          timers: [mockTimer]
+        })
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateStatusWithFlush());
+      await act(async () => {
+        const success = await result.current.updateStatusTimerWithFlush('1', false, CLOUD_TIMER_CATEGORY);
+        expect(success).toBe(true);
+      });
+      expect(mockFlushTimerList).toHaveBeenCalledWith([mockTimer]);
+    });
+    it('should reset loading when status update fails', async () => {
+      const statusError = new Error('status update failed');
+      useTimerOperateLocal.useLocalTimerUpdateStatus.mockReturnValueOnce({
+        isLoading: false,
+        isSupportLocalTimer: true,
+        updateTimerStatus: jest.fn().mockRejectedValue(statusError)
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateStatusWithFlush());
+      let caught = null;
+      await act(async () => {
+        try {
+          await result.current.updateStatusTimerWithFlush('1', false, CLOUD_TIMER_CATEGORY);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      expect(caught).toBe(statusError);
+      expect(result.current.isLoading).toBe(false);
+    });
+  });
 });