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

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

@@ -0,0 +1,92 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useCycleDp } from '../useCycleDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { getCycleParser } from '../../dpParser/cycle';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/cycle');
+describe('useCycleDp', () => {
+  const mockCycleData = {
+    version: 1,
+    length: 1,
+    nodes: [{
+      onOff: true,
+      channel: 1,
+      loops: '0000000',
+      startTime: 28800,
+      // 08:00
+      startTimeDuration: 3600,
+      // 1小时
+      endTime: 64800,
+      // 18:00
+      endTimeDuration: 3600,
+      // 1小时
+      index: 0,
+      color: {
+        hue: 0,
+        saturation: 100,
+        value: 100,
+        brightness: 100,
+        temperature: 5000
+      }
+    }]
+  };
+  const mockParser = {
+    formatter: jest.fn(),
+    parser: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: JSON.stringify(mockCycleData),
+      updateDp: jest.fn()
+    });
+    getCycleParser.mockReturnValue(mockParser);
+    mockParser.formatter.mockImplementation(data => data);
+    mockParser.parser.mockImplementation(data => JSON.parse(data));
+  });
+  it('should return correct initial values', () => {
+    const {
+      result
+    } = renderHook(() => useCycleDp());
+    expect(result.current.dpValue).toEqual(mockCycleData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: JSON.stringify(mockCycleData),
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useCycleDp());
+    act(() => {
+      result.current.updateDp(mockCycleData);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockCycleData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockCycleData);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockCycleData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useCycleDp());
+    expect(mockParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(mockCycleData);
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useCycleDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.CYCLE_TIMING);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = scheduleDpCodes.CYCLE_TIMING;
+    renderHook(() => useCycleDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

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

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

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

@@ -0,0 +1,88 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useRandomDp } from '../useRandomDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { getRandomParser } from '../../dpParser/random';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/random');
+describe('useRandomDp', () => {
+  const mockRandomData = {
+    version: 1,
+    length: 1,
+    nodes: [{
+      onOff: true,
+      channel: 1,
+      loops: '0000000',
+      startTime: 28800,
+      // 08:00
+      endTime: 64800,
+      // 18:00
+      index: 0,
+      color: {
+        hue: 0,
+        saturation: 100,
+        value: 100,
+        brightness: 100,
+        temperature: 5000
+      }
+    }]
+  };
+  const mockParser = {
+    formatter: jest.fn(),
+    parser: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: JSON.stringify(mockRandomData),
+      updateDp: jest.fn()
+    });
+    getRandomParser.mockReturnValue(mockParser);
+    mockParser.formatter.mockImplementation(data => data);
+    mockParser.parser.mockImplementation(data => JSON.parse(data));
+  });
+  it('should return correct initial values', () => {
+    const {
+      result
+    } = renderHook(() => useRandomDp());
+    expect(result.current.dpValue).toEqual(mockRandomData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: JSON.stringify(mockRandomData),
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useRandomDp());
+    act(() => {
+      result.current.updateDp(mockRandomData);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockRandomData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockRandomData);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockRandomData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useRandomDp());
+    expect(mockParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(mockRandomData);
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useRandomDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.RANDOM_TIMING);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = scheduleDpCodes.RANDOM_TIMING;
+    renderHook(() => useRandomDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

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

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

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

@@ -0,0 +1,81 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useRhythmsDp } from '../useRhythmsDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { rhythmParser } from '../../dpParser/rhythms';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/rhythms');
+describe('useRhythmsDp', () => {
+  const mockRhythmData = {
+    version: 1,
+    power: true,
+    mode: 1,
+    weeks: [0, 1, 2, 3, 4, 5, 6],
+    number: 1,
+    rhythms: [{
+      power: true,
+      hour: 8,
+      minute: 0,
+      hue: 0,
+      saturation: 100,
+      value: 100,
+      brightness: 100,
+      temperature: 5000,
+      icon: 'sun',
+      name: '日出'
+    }]
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockRhythmData,
+      updateDp: jest.fn()
+    });
+    rhythmParser.formatter.mockImplementation(data => data);
+    rhythmParser.parser.mockImplementation(data => data);
+  });
+  it('should return correct initial values', () => {
+    const {
+      result
+    } = renderHook(() => useRhythmsDp());
+    expect(result.current.dpValue).toEqual(mockRhythmData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockRhythmData,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useRhythmsDp());
+    act(() => {
+      result.current.updateDp(mockRhythmData);
+    });
+    expect(rhythmParser.formatter).toHaveBeenCalledWith(mockRhythmData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockRhythmData);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockRhythmData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useRhythmsDp());
+    expect(rhythmParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(JSON.stringify(mockRhythmData));
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useRhythmsDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.RHYTHM_MODE);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = scheduleDpCodes.RHYTHM_MODE;
+    renderHook(() => useRhythmsDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

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

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

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

@@ -0,0 +1,127 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useSleepDp } from '../useSleepDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { getSleepParser } from '../../dpParser/sleep';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/sleep');
+describe('useSleepDp', () => {
+  const mockSleepData = {
+    version: 1,
+    length: 1,
+    nodes: [{
+      onOff: true,
+      loops: '0000000',
+      step: 1,
+      hour: 22,
+      minute: 0,
+      hue: 0,
+      saturation: 100,
+      value: 100,
+      brightness: 100,
+      temperature: 5000,
+      index: 0,
+      time: '22:00'
+    }]
+  };
+  const mockSleepDataSigmesh = {
+    version: 1,
+    dataMode: '01',
+    length: 1,
+    nodes: [{
+      onOff: true,
+      loops: '0000000',
+      step: 1,
+      hour: 22,
+      minute: 0,
+      brightness: 100,
+      temperature: 5000,
+      index: 0,
+      time: '22:00'
+    }]
+  };
+  const mockParser = {
+    formatter: jest.fn(),
+    parser: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockSleepData,
+      updateDp: jest.fn()
+    });
+    getSleepParser.mockReturnValue(mockParser);
+    mockParser.formatter.mockImplementation(data => data);
+    mockParser.parser.mockImplementation(data => data);
+  });
+  it('should return correct initial values with TSleepData', () => {
+    const {
+      result
+    } = renderHook(() => useSleepDp());
+    expect(result.current.dpValue).toEqual(mockSleepData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should return correct initial values with TSleepDataSigmesh', () => {
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockSleepDataSigmesh,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useSleepDp());
+    expect(result.current.dpValue).toEqual(mockSleepDataSigmesh);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data for TSleepData', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockSleepData,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useSleepDp());
+    act(() => {
+      result.current.updateDp(mockSleepData);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockSleepData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockSleepData);
+  });
+  it('should call updateDp with formatted data for TSleepDataSigmesh', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockSleepDataSigmesh,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useSleepDp());
+    act(() => {
+      result.current.updateDp(mockSleepDataSigmesh);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockSleepDataSigmesh);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockSleepDataSigmesh);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockSleepData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useSleepDp());
+    expect(mockParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(JSON.stringify(mockSleepData));
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useSleepDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.SLEEP_MODE);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = 'custom_dp_code';
+    renderHook(() => useSleepDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

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

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

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

@@ -0,0 +1,109 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useTimerContext, useTimerListFlush } from '../useTimeFlush';
+import { TimerContext } from '../../context/timer/context';
+import { useSupportLocalTimer } from '../useTimerSupport';
+// Mock dependencies
+jest.mock('../useTimerSupport');
+jest.mock('../../context/timer/context', () => ({
+  TimerContext: {
+    _currentValue: {}
+  }
+}));
+describe('useTimeFlush Hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('useTimerContext', () => {
+    it('should return timer context', () => {
+      const mockContext = {
+        state: {},
+        dispatch: jest.fn(),
+        actions: {
+          flushRtcTimerList: jest.fn(),
+          flushCloudTimerList: jest.fn()
+        }
+      };
+      TimerContext._currentValue = mockContext;
+      const {
+        result
+      } = renderHook(() => useTimerContext());
+      expect(result.current).toEqual(mockContext);
+    });
+  });
+  describe('useTimerListFlush', () => {
+    it('should flush local timer list when local timer is supported', () => {
+      const mockDispatch = jest.fn();
+      const mockActions = {
+        flushRtcTimerList: jest.fn(),
+        flushCloudTimerList: jest.fn()
+      };
+      useSupportLocalTimer.mockReturnValue({
+        isSupport: true,
+        isReady: true
+      });
+      TimerContext._currentValue = {
+        dispatch: mockDispatch,
+        actions: mockActions
+      };
+      const {
+        result
+      } = renderHook(() => useTimerListFlush());
+      const mockTimerList = [{
+        timerId: '1',
+        time: '12:00',
+        loops: '1111111',
+        status: true,
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      }];
+      result.current.flushTimerList(mockTimerList);
+      expect(mockDispatch).toHaveBeenCalledWith(mockActions.flushRtcTimerList(mockTimerList));
+      expect(mockActions.flushCloudTimerList).not.toHaveBeenCalled();
+    });
+    it('should flush cloud timer list when local timer is not supported', () => {
+      const mockDispatch = jest.fn();
+      const mockActions = {
+        flushRtcTimerList: jest.fn(),
+        flushCloudTimerList: jest.fn()
+      };
+      useSupportLocalTimer.mockReturnValue({
+        isSupport: false,
+        isReady: true
+      });
+      TimerContext._currentValue = {
+        dispatch: mockDispatch,
+        actions: mockActions
+      };
+      const {
+        result
+      } = renderHook(() => useTimerListFlush());
+      const mockTimerList = [{
+        timerId: '1',
+        time: '12:00',
+        loops: '1111111',
+        status: true,
+        dps: {
+          power: true
+        },
+        aliasName: 'Test Timer',
+        isAppPush: true
+      }];
+      result.current.flushTimerList(mockTimerList);
+      expect(mockDispatch).toHaveBeenCalledWith(mockActions.flushCloudTimerList(mockTimerList));
+      expect(mockActions.flushRtcTimerList).not.toHaveBeenCalled();
+    });
+    it('should return correct ready status', () => {
+      useSupportLocalTimer.mockReturnValue({
+        isSupport: true,
+        isReady: false
+      });
+      const {
+        result
+      } = renderHook(() => useTimerListFlush());
+      expect(result.current.isReady).toBe(false);
+    });
+  });
+});

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

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

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

@@ -0,0 +1,79 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useTimerDp } from '../useTimerDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { rtcTimerParser } from '../../dpParser/rtcTimer';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/rtcTimer');
+describe('useTimerDp', () => {
+  const mockTimerData = {
+    timerId: '1',
+    status: true,
+    loops: '0000000',
+    time: '08:00',
+    deviceAction: 1,
+    dps: {
+      switch_led: true,
+      colour_data: {
+        hue: 0,
+        saturation: 100,
+        value: 100
+      },
+      bright_value: 100,
+      temp_value: 5000
+    }
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockTimerData,
+      updateDp: jest.fn()
+    });
+    rtcTimerParser.formatter.mockImplementation(data => data);
+    rtcTimerParser.parser.mockImplementation(data => data);
+  });
+  it('should return correct initial values', () => {
+    const {
+      result
+    } = renderHook(() => useTimerDp());
+    expect(result.current.dpValue).toEqual(mockTimerData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockTimerData,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useTimerDp());
+    act(() => {
+      result.current.updateDp(mockTimerData);
+    });
+    expect(rtcTimerParser.formatter).toHaveBeenCalledWith(mockTimerData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockTimerData);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockTimerData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useTimerDp());
+    expect(rtcTimerParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(JSON.stringify(mockTimerData));
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useTimerDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.RTC_TIMER);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = scheduleDpCodes.RTC_TIMER;
+    renderHook(() => useTimerDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

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

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