@ray-js/lamp-schedule-core 1.0.0-beta-1

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

@@ -0,0 +1,286 @@
+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 { useSupportLocalTimer } from '../useTimerSupport';
+import { useSupport } from '../useCommonSupport';
+import { useTimerDp } from '../useTimerDp';
+import { useTimerListFlush } from '../useTimeFlush';
+import * as useTimerOperateLocal from '../useTimerOperateLocal';
+import * as useTimerOperateCloud from '../useTimerOperateCloud';
+import { CLOUD_TIMER_CATEGORY } from '../../constant';
+import { getTimerState } from '../../context/timer';
+
+// Mock dependencies
+jest.mock('../useTimerSupport');
+jest.mock('../useCommonSupport');
+jest.mock('../useTimerDp');
+jest.mock('../useTimeFlush');
+jest.mock('../useTimerOperateCloud');
+jest.mock('../useTimerOperateLocal');
+jest.mock('../../context/timer', () => ({
+  getTimerState: jest.fn()
+}));
+const mockTimer = {
+  timerId: '1',
+  time: '12:00',
+  loops: '1,2,3',
+  status: true,
+  dps: {},
+  aliasName: 'Test Timer',
+  isAppPush: false
+};
+describe('useTimerOperate Hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useSupportLocalTimer.mockReturnValue({
+      isSupport: true,
+      isReady: true
+    });
+    useSupport.mockReturnValue({
+      isGroupDevice: () => false
+    });
+    useTimerDp.mockReturnValue({
+      updateDp: jest.fn()
+    });
+    useTimerListFlush.mockReturnValue({
+      flushTimerList: jest.fn(),
+      isReady: true
+    });
+    getTimerState.mockReturnValue({
+      rtcTimerList: [mockTimer]
+    });
+    useTimerOperateLocal.useLocalTimerAdd.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      addTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateLocal.useLocalTimerUpdate.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      updateTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateLocal.useLocalTimerRemove.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      removeTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateLocal.useLocalTimerList.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      getTimerList: jest.fn().mockResolvedValue({
+        timers: []
+      })
+    });
+    useTimerOperateLocal.useLocalTimerUpdateStatus.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      updateTimerStatus: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateCloud.useCloudTimerAdd.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      addTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateCloud.useCloudTimerUpdate.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      updateTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateCloud.useCloudTimerRemove.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      removeTimer: jest.fn().mockResolvedValue(true)
+    });
+    useTimerOperateCloud.useCloudTimerList.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      getTimerList: jest.fn().mockResolvedValue({
+        timers: []
+      })
+    });
+    useTimerOperateCloud.useCloudTimerUpdateStatus.mockReturnValue({
+      isLoading: false,
+      isSupportLocalTimer: true,
+      updateTimerStatus: jest.fn().mockResolvedValue(true)
+    });
+  });
+  describe('useTimerAdd', () => {
+    it('should handle local timer addition when supported', async () => {
+      const mockUpdateDp = jest.fn();
+      useTimerDp.mockReturnValue({
+        updateDp: mockUpdateDp
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAdd());
+      await result.current.addTimer({
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      }, CLOUD_TIMER_CATEGORY);
+      expect(mockUpdateDp).toHaveBeenCalled();
+    });
+    it('should handle cloud timer addition when local timer not supported', async () => {
+      useSupportLocalTimer.mockReturnValue({
+        isSupport: false,
+        isReady: true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAdd());
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await act(async () => {
+        await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      });
+
+      // Verify cloud timer addition was called
+      expect(result.current.isLoading).toBeDefined();
+    });
+    it('should add timer', async () => {
+      const {
+        result
+      } = renderHook(() => useTimerAdd());
+      const response = await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      expect(response).toBeTruthy();
+    });
+    it('should add cloud timer when device is in group', async () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAdd());
+      await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      expect(useTimerOperateCloud.useCloudTimerAdd).toHaveBeenCalled();
+    });
+  });
+  describe('useTimerAddWithFlush', () => {
+    it('should add timer and flush list', async () => {
+      const mockFlushTimerList = jest.fn();
+      jest.fn().mockResolvedValue({
+        timers: []
+      });
+      useTimerListFlush.mockReturnValue({
+        flushTimerList: mockFlushTimerList,
+        isReady: true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerAddWithFlush());
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await act(async () => {
+        await result.current.addTimerWithFlush(mockTimer);
+      });
+      expect(mockFlushTimerList).toHaveBeenCalled();
+    });
+  });
+  describe('useTimerUpdate', () => {
+    it('should handle local timer update when supported', async () => {
+      const mockUpdateDp = jest.fn();
+      useTimerDp.mockReturnValue({
+        updateDp: mockUpdateDp
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdate());
+      const mockTimer = {
+        timerId: '1',
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await act(async () => {
+        await result.current.updateTimer(mockTimer, _objectSpread(_objectSpread({}, mockTimer), {}, {
+          status: false
+        }));
+      });
+      expect(mockUpdateDp).toHaveBeenCalled();
+    });
+    it('should update cloud timer when device is in group', async () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdate());
+      await result.current.updateTimer(mockTimer, _objectSpread(_objectSpread({}, mockTimer), {}, {
+        status: false
+      }));
+      expect(useTimerOperateCloud.useCloudTimerUpdate).toHaveBeenCalled();
+    });
+  });
+  describe('useTimerRemove', () => {
+    it('should handle local timer removal when supported', async () => {
+      const mockUpdateDp = jest.fn();
+      useTimerDp.mockReturnValue({
+        updateDp: mockUpdateDp
+      });
+      const {
+        result
+      } = renderHook(() => useTimerRemove());
+      await act(async () => {
+        await result.current.removeTimer('1');
+      });
+      expect(mockUpdateDp).toHaveBeenCalled();
+    });
+    it('should remove cloud timer when device is in group', async () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerRemove());
+      await result.current.removeTimer('1');
+      expect(useTimerOperateCloud.useCloudTimerRemove).toHaveBeenCalled();
+    });
+  });
+  describe('useTimerUpdateStatus', () => {
+    it('should handle local timer status update when supported', async () => {
+      const mockUpdateDp = jest.fn();
+      useTimerDp.mockReturnValue({
+        updateDp: mockUpdateDp
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateStatus());
+      await act(async () => {
+        await result.current.updateTimerStatus('1', true);
+      });
+      expect(mockUpdateDp).toHaveBeenCalled();
+    });
+    it('should update cloud timer status when device is in group', async () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerUpdateStatus());
+      await result.current.updateTimerStatus('1', true);
+      expect(useTimerOperateCloud.useCloudTimerUpdateStatus).toHaveBeenCalled();
+    });
+  });
+});

package/lib/hooks/__test__/useTimerOperateCloud.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,190 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { device } from '@ray-js/ray';
+import { useCloudTimerAdd, useCloudTimerUpdate, useCloudTimerRemove, useCloudTimerList, useCloudTimerUpdateStatus } from '../useTimerOperateCloud';
+import { CLOUD_TIMER_CATEGORY } from '../../constant';
+// Mock dependencies
+jest.mock('@ray-js/ray', () => ({
+  device: {
+    addTimer: jest.fn().mockImplementation(_ref => {
+      let {
+        success
+      } = _ref;
+      return success({
+        timerId: '1',
+        id: '1'
+      });
+    }),
+    removeTimer: jest.fn().mockImplementation(_ref2 => {
+      let {
+        success
+      } = _ref2;
+      return success();
+    }),
+    updateTimer: jest.fn().mockImplementation(_ref3 => {
+      let {
+        success
+      } = _ref3;
+      return success();
+    }),
+    syncTimerTask: jest.fn().mockImplementation(_ref4 => {
+      let {
+        success
+      } = _ref4;
+      return success({
+        timers: []
+      });
+    }),
+    updateTimerStatus: jest.fn().mockImplementation(_ref5 => {
+      let {
+        success
+      } = _ref5;
+      return success();
+    })
+  }
+}));
+jest.mock('../../utils/ScheduleCache', () => ({
+  devIdOrGroupIdCache: {
+    get: jest.fn().mockReturnValue({
+      devId: 'test-device-id',
+      groupId: 'test-group-id'
+    }),
+    set: jest.fn()
+  },
+  getScheduleCache: jest.fn()
+}));
+describe('useTimerOperateCloud Hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('useCloudTimerAdd', () => {
+    it('should add cloud timer successfully', async () => {
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      const {
+        result
+      } = renderHook(() => useCloudTimerAdd(false));
+      await act(async () => {
+        await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      });
+      expect(device.addTimer).toHaveBeenCalledWith({
+        category: CLOUD_TIMER_CATEGORY,
+        groupId: 'test-group-id',
+        timer: expect.objectContaining({
+          time: '12:00',
+          loops: '1111111'
+        }),
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+    }, 10000);
+    it('should handle add timer error', async () => {
+      const mockError = new Error('Add failed');
+      device.addTimer.mockImplementation(_ref6 => {
+        let {
+          fail
+        } = _ref6;
+        fail(mockError);
+      });
+      const {
+        result
+      } = renderHook(() => useCloudTimerAdd(false));
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await expect(act(async () => {
+        await result.current.addTimer(mockTimer, CLOUD_TIMER_CATEGORY);
+      })).rejects.toThrow('Add failed');
+    }, 10000);
+  });
+  describe('useCloudTimerUpdate', () => {
+    it('should update cloud timer successfully', async () => {
+      const mockTimer = {
+        timerId: '1',
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      const {
+        result
+      } = renderHook(() => useCloudTimerUpdate(false));
+      await act(async () => {
+        await result.current.updateTimer(mockTimer);
+      });
+      expect(device.updateTimer).toHaveBeenCalledWith({
+        groupId: 'test-group-id',
+        timer: expect.objectContaining({
+          timerId: '1',
+          time: '12:00'
+        }),
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+    }, 10000);
+  });
+  describe('useCloudTimerRemove', () => {
+    it('should remove cloud timer successfully', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudTimerRemove(false));
+      await act(async () => {
+        await result.current.removeTimer('1');
+      });
+      expect(device.removeTimer).toHaveBeenCalledWith({
+        groupId: 'test-group-id',
+        timerId: '1',
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+    }, 10000);
+  });
+  describe('useCloudTimerList', () => {
+    it('should get cloud timer list successfully', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudTimerList(false));
+      await act(async () => {
+        await result.current.getTimerList();
+      });
+      expect(device.syncTimerTask).toHaveBeenCalledWith({
+        groupId: 'test-group-id',
+        category: CLOUD_TIMER_CATEGORY,
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+    }, 10000);
+  });
+  describe('useCloudTimerUpdateStatus', () => {
+    it('should update cloud timer status successfully', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudTimerUpdateStatus(false));
+      await act(async () => {
+        await result.current.updateTimerStatus('1', true);
+      });
+      expect(device.updateTimerStatus).toHaveBeenCalledWith({
+        groupId: 'test-group-id',
+        timerId: '1',
+        status: true,
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+    }, 10000);
+  });
+});

package/lib/hooks/__test__/useTimerOperateLocal.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,216 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useLocalTimerAdd, useLocalTimerUpdate, useLocalTimerRemove, useLocalTimerList, useLocalTimerUpdateStatus } from '../useTimerOperateLocal';
+import { useLocalTimerCloudProperty } from '../../utils/ScheduleCloudProperty';
+import { LOCAL_TIMER_CATEGORY } from '../../constant';
+import { getTimerState } from '../../context/timer/';
+
+// Mock dependencies
+jest.mock('../../utils/ScheduleCache', () => ({
+  devIdOrGroupIdCache: {
+    get: jest.fn().mockReturnValue({
+      devId: 'test-device-id',
+      groupId: 'test-group-id'
+    }),
+    set: jest.fn()
+  },
+  getScheduleCache: jest.fn()
+}));
+jest.mock('../../context/timer/', () => ({
+  getTimerState: jest.fn() // 直接模拟返回值
+}));
+
+// Mock ray functions
+jest.mock('@ray-js/ray', () => ({
+  offDpDataChange: jest.fn(),
+  onDpDataChange: jest.fn()
+}));
+jest.mock('../../utils/ScheduleCloudProperty', () => ({
+  useLocalTimerCloudProperty: jest.fn().mockReturnValue({
+    set: jest.fn().mockResolvedValue(true),
+    update: jest.fn().mockResolvedValue(true),
+    remove: jest.fn().mockResolvedValue(true),
+    updateStatus: jest.fn().mockResolvedValue(true),
+    getAll: jest.fn().mockResolvedValue({
+      properties: {}
+    })
+  })
+}));
+describe('useTimerOperateLocal Hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('useLocalTimerAdd', () => {
+    it('should add local timer successfully', async () => {
+      const mockSet = jest.fn().mockResolvedValue(true);
+      useLocalTimerCloudProperty.mockReturnValue({
+        set: mockSet
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerAdd(true));
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await act(async () => {
+        await result.current.addTimer(mockTimer);
+      });
+      expect(mockSet).toHaveBeenCalledWith(mockTimer, undefined);
+      expect(result.current.isLoading).toBe(false);
+    });
+    it('should handle add timer error', async () => {
+      const mockSet = jest.fn().mockRejectedValue(new Error('Add failed'));
+      useLocalTimerCloudProperty.mockReturnValue({
+        set: mockSet
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerAdd(true));
+      const mockTimer = {
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await expect(act(async () => {
+        await result.current.addTimer(mockTimer);
+      })).rejects.toThrow('Add failed');
+    });
+  });
+  describe('useLocalTimerUpdate', () => {
+    it('should update local timer successfully', async () => {
+      const mockUpdate = jest.fn().mockResolvedValue(true);
+      useLocalTimerCloudProperty.mockReturnValue({
+        update: mockUpdate
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerUpdate(true));
+      const mockTimer = {
+        timerId: '1',
+        time: '12:00',
+        loops: '1111111',
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      };
+      await act(async () => {
+        await result.current.updateTimer(mockTimer);
+      });
+      expect(mockUpdate).toHaveBeenCalledWith(mockTimer);
+    });
+  });
+  describe('useLocalTimerRemove', () => {
+    it('should remove local timer successfully', async () => {
+      const mockRemove = jest.fn().mockResolvedValue(true);
+      useLocalTimerCloudProperty.mockReturnValue({
+        remove: mockRemove
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerRemove(true));
+      await act(async () => {
+        await result.current.removeTimer('1');
+      });
+      expect(mockRemove).toHaveBeenCalledWith('1');
+    });
+  });
+  describe('useLocalTimerList', () => {
+    it('should get local timer list successfully', async () => {
+      const mockGetAll = jest.fn().mockResolvedValue({
+        properties: {
+          [`${LOCAL_TIMER_CATEGORY}_1`]: JSON.stringify({
+            time: '12:00',
+            loops: '1111111',
+            status: true,
+            dps: {
+              power: true
+            }
+          })
+        }
+      });
+      useLocalTimerCloudProperty.mockReturnValue({
+        getAll: mockGetAll
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerList(true));
+      await act(async () => {
+        const response = await result.current.getTimerList();
+        expect(response.timers).toHaveLength(1);
+        expect(response.timers[0]).toHaveProperty('timerId', '1');
+        expect(response.timers[0]).toHaveProperty('time', '12:00');
+      });
+    });
+    it('should handle invalid timer data', async () => {
+      const mockGetAll = jest.fn().mockResolvedValue({
+        properties: {
+          [`${LOCAL_TIMER_CATEGORY}_1`]: 'invalid_json',
+          [`${LOCAL_TIMER_CATEGORY}_2`]: '1',
+          [`${LOCAL_TIMER_CATEGORY}_3`]: 'null'
+        }
+      });
+      useLocalTimerCloudProperty.mockReturnValue({
+        getAll: mockGetAll
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerList(true));
+      await act(async () => {
+        const response = await result.current.getTimerList();
+        expect(response.timers).toHaveLength(0);
+      });
+    });
+    it('should get empty timer list when no timers exist', async () => {
+      const mockGetAll = jest.fn().mockResolvedValue({
+        properties: {}
+      });
+      useLocalTimerCloudProperty.mockReturnValue({
+        getAll: mockGetAll
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerList(false));
+      await act(async () => {
+        const response = await result.current.getTimerList();
+        expect(response.timers).toHaveLength(0);
+      });
+    });
+  });
+  describe('useLocalTimerUpdateStatus', () => {
+    it('should update timer status successfully', async () => {
+      const mockUpdateStatus = jest.fn().mockResolvedValue(true);
+      useLocalTimerCloudProperty.mockReturnValue({
+        updateStatus: mockUpdateStatus
+      });
+      getTimerState.mockReturnValue({
+        rtcTimerList: [{
+          timerId: '1',
+          time: '12:00',
+          loops: '1111111',
+          dps: {
+            power: true
+          }
+        }]
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerUpdateStatus(true));
+      await act(async () => {
+        await result.current.updateTimerStatus('1', true);
+      });
+      expect(mockUpdateStatus).toHaveBeenCalledWith('1', true);
+      expect(result.current.isLoading).toBe(false);
+    });
+  });
+});

package/lib/hooks/__test__/useTimerReportDp.test.d.ts

@@ -0,0 +1 @@
+export {};