@ray-js/lamp-schedule-core 1.0.1-beta-10 → 1.0.2-beta-2

package/lib/utils/__test__/ScheduleSupport.test.js

@@ -1,55 +1,69 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+/* eslint-disable no-bitwise */
 import { Support, DeviceCapability, getBitValue } from '../ScheduleSupport';
-import { setScheduleCache, getScheduleCache } from '../ScheduleCache';
-import { getDpCodeByDpId, getDpIdByDpCode } from '../ScheduleUtils';
-
-// 模拟依赖
+import { setScheduleCache, getScheduleCache, devIdOrGroupIdCache } from '../ScheduleCache';
+import { setDpState } from '../dpState';
+import { getDpCodeByDpId } from '../ScheduleUtils';
+import { getDeviceInfo, getGroupInfo } from '@ray-js/ray';
+jest.mock('@ray-js/ray', () => ({
+  getDeviceInfo: jest.fn(),
+  getGroupInfo: jest.fn()
+}));
 jest.mock('../ScheduleCache', () => ({
   setScheduleCache: jest.fn(),
   getScheduleCache: jest.fn(),
-  clearScheduleCache: jest.fn()
+  devIdOrGroupIdCache: {
+    set: jest.fn(),
+    get: jest.fn().mockReturnValue({
+      devId: '',
+      groupId: ''
+    })
+  }
 }));
 jest.mock('../dpState', () => ({
-  setDpState: jest.fn(),
-  clearDpState: jest.fn()
+  setDpState: jest.fn()
 }));
 jest.mock('../ScheduleUtils', () => ({
-  getDpCodeByDpId: jest.fn(),
-  getDpIdByDpCode: jest.fn()
+  getDpCodeByDpId: jest.fn()
+}));
+jest.mock('../ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn()
+  }
 }));
 describe('ScheduleSupport', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
+    jest.resetAllMocks();
   });
   describe('getBitValue', () => {
-    it('应该正确获取数字指定位的值', () => {
-      expect(getBitValue(0b1010, 0)).toBe(0); // 第0位是0
-      expect(getBitValue(0b1010, 1)).toBe(1); // 第1位是1
-      expect(getBitValue(0b1010, 2)).toBe(0); // 第2位是0
-      expect(getBitValue(0b1010, 3)).toBe(1); // 第3位是1
-      expect(getBitValue(0b1010, 4)).toBe(0); // 第4位是0（超出范围）
+    it('returns the specific bit value', () => {
+      expect(getBitValue(0b1011, 0)).toBe(1);
+      expect(getBitValue(0b1011, 1)).toBe(1);
+      expect(getBitValue(0b1011, 2)).toBe(0);
+      expect(getBitValue(0b1011, 3)).toBe(1);
     });
-    it('当数字为0时应该返回0', () => {
-      expect(getBitValue(0, 0)).toBe(0);
-      expect(getBitValue(0, 1)).toBe(0);
-      expect(getBitValue(0, 10)).toBe(0);
+    it('returns 0 when bit not set', () => {
+      expect(getBitValue(0, 5)).toBe(0);
     });
   });
-  describe('DeviceCapability枚举', () => {
-    it('应该定义了正确的设备能力枚举值', () => {
+  describe('DeviceCapability enum', () => {
+    it('contains expected bit definitions', () => {
       expect(DeviceCapability.WIFI).toBe(0);
       expect(DeviceCapability.ZIGBEE).toBe(12);
       expect(DeviceCapability.SIGMESH).toBe(15);
       expect(DeviceCapability.BLUETOOTH).toBe(10);
     });
   });
-  describe('Support类', () => {
-    let support;
-    const mockDevInfo = {
-      devId: 'test-device-id',
-      capability: 12,
+  describe('Support class', () => {
+    const baseDevInfo = {
+      devId: 'dev-1',
+      capability: 0,
       dps: {
-        1: true
+        1: true,
+        2: false
       },
       schema: [{
         id: 1,
@@ -57,154 +71,274 @@ describe('ScheduleSupport', () => {
       }, {
         id: 2,
         code: 'bright_value'
-      }]
+      }],
+      panelConfig: {
+        bic: [{
+          code: 'timer',
+          selected: true
+        }]
+      },
+      isMatter: false,
+      isTripartiteMatter: false
     };
-    const mockGroupInfo = {
-      groupId: 'test-group-id',
-      capability: DeviceCapability.ZIGBEE,
+    const baseGroupInfo = {
+      groupId: 'group-1',
+      capability: 0,
       dps: {
         1: true
       },
-      schema: [{
-        id: 1,
-        code: 'switch_led'
-      }, {
-        id: 2,
-        code: 'bright_value'
-      }]
+      deviceList: [],
+      panelConfig: {
+        bic: [{
+          code: 'timer',
+          selected: true
+        }]
+      }
+    };
+    const setCachedDevInfo = info => {
+      getScheduleCache.mockReturnValue(info);
     };
-    beforeEach(() => {
-      support = new Support({
-        devId: 'test-device-id'
+    describe('init workflow', () => {
+      it('fails when neither devId nor groupId provided', async () => {
+        const support = new Support({
+          devId: '',
+          groupId: ''
+        });
+        await expect(support.init()).rejects.toThrow('devId and groupId are undefined');
       });
-      // 模拟getScheduleCache返回null，表示缓存中没有数据
-      getScheduleCache.mockReturnValue(null);
-    });
-    describe('初始化', () => {
-      it('应该正确初始化设备信息', () => {
-        support.setDevInfo(mockDevInfo);
-        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', mockDevInfo);
+      it('initializes device info when devId provided', async () => {
+        const support = new Support({
+          devId: 'dev-1',
+          groupId: undefined
+        });
+        const deviceInfo = _objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          capability: 1 << DeviceCapability.WIFI
+        });
+        getDpCodeByDpId.mockReturnValue('switch_led');
+        getDeviceInfo.mockImplementation(_ref => {
+          let {
+            success
+          } = _ref;
+          return success(deviceInfo);
+        });
+        await expect(support.init()).resolves.toBe(true);
+        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', deviceInfo);
+        expect(setDpState).toHaveBeenCalledWith('switch_led', true);
+        expect(devIdOrGroupIdCache.set).toHaveBeenCalledWith('dev-1', '');
+      });
+      it('initializes group info when groupId provided', async () => {
+        const support = new Support({
+          devId: '',
+          groupId: 'group-1'
+        });
+        const groupInfo = _objectSpread(_objectSpread({}, baseGroupInfo), {}, {
+          dps: {
+            1: true
+          },
+          deviceList: []
+        });
+        getDpCodeByDpId.mockReturnValue('switch_led');
+        getGroupInfo.mockImplementation(_ref2 => {
+          let {
+            success
+          } = _ref2;
+          return success(groupInfo);
+        });
+        await expect(support.init()).resolves.toBe(true);
+        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', groupInfo);
+        expect(setDpState).toHaveBeenCalledWith('switch_led', true);
+        expect(devIdOrGroupIdCache.set).toHaveBeenCalledWith('', 'group-1');
       });
-      it('应该正确初始化群组信息', () => {
-        support.setGroupDevInfo(mockGroupInfo);
-        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', mockGroupInfo);
+      it('propagates device info failure', async () => {
+        const support = new Support({
+          devId: 'dev-1',
+          groupId: undefined
+        });
+        getDeviceInfo.mockImplementation(_ref3 => {
+          let {
+            fail
+          } = _ref3;
+          setTimeout(() => fail(new Error('boom')), 0);
+        });
+        await expect(support.init()).rejects.toThrow('get dev info fail');
       });
-    });
-    describe('设备信息获取', () => {
-      it('getCachedDevInfo应该返回缓存的设备信息', () => {
-        getScheduleCache.mockReturnValue(mockDevInfo);
-        const result = support.getCachedDevInfo();
-        expect(result).toEqual(mockDevInfo);
-        expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
-      });
-      it('getDevInfo应该返回设备信息', () => {
-        getScheduleCache.mockReturnValue(mockDevInfo);
-        const result = support.getDevInfo();
-        expect(result).toEqual(mockDevInfo);
-      });
-      it('getGroupDevInfo应该返回群组信息', () => {
-        support.setGroupDevInfo('mock-group-id');
-        const result = support.getGroupDevInfo();
-        expect(result).toEqual(mockGroupInfo);
+      it('propagates group info failure', async () => {
+        const support = new Support({
+          devId: '',
+          groupId: 'group-1'
+        });
+        getGroupInfo.mockImplementation(_ref4 => {
+          let {
+            fail
+          } = _ref4;
+          setTimeout(() => fail(new Error('boom')), 0);
+        });
+        await expect(support.init()).rejects.toThrow('get group info fail');
       });
     });
-    describe('设备类型判断', () => {
-      beforeEach(() => {
-        getScheduleCache.mockReturnValue(mockDevInfo);
-      });
-      it('isWifiDevice应该正确判断WIFI设备', () => {
-        // 修改capability
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          capability: 1 << DeviceCapability.WIFI
+    describe('capability checks', () => {
+      it('hasCapability reads cached info when no argument provided', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        const capabilityMask = 1 << DeviceCapability.WIFI | 1 << DeviceCapability.ZIGBEE;
+        setCachedDevInfo(_objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          capability: capabilityMask
         }));
-        expect(support.isWifiDevice()).toBe(true);
+        expect(support.hasCapability(DeviceCapability.WIFI)).toBe(true);
+        expect(support.hasCapability(DeviceCapability.ZIGBEE)).toBe(true);
+        expect(support.hasCapability(DeviceCapability.SIGMESH)).toBe(false);
       });
-      it('isZigbeeDevice应该正确判断ZIGBEE设备', () => {
-        // 修改capability
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          capability: 1 << DeviceCapability.ZIGBEE
-        }));
-        expect(support.isZigbeeDevice()).toBe(true);
-      });
-      it('isSigMeshDevice应该正确判断SIGMESH设备', () => {
-        expect(support.isSigMeshDevice()).toBe(false);
-
-        // 修改capability
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          capability: 1 << DeviceCapability.SIGMESH
-        }));
-        expect(support.isSigMeshDevice()).toBe(true);
-      });
-      it('isBleDevice应该正确判断BLE设备', () => {
-        expect(support.isBleDevice()).toBe(false);
-
-        // 修改capability
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          capability: 1 << DeviceCapability.BLUETOOTH
+      it('isBleDevice returns true when any BLE related bit is set', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        setCachedDevInfo(_objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          capability: 1 << DeviceCapability.BLEMESH
         }));
         expect(support.isBleDevice()).toBe(true);
       });
+      it('isMatter device helpers work with either argument or cached info', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        const devInfo = _objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          isMatter: true,
+          isTripartiteMatter: false
+        });
+        expect(support.isMatterDevice(devInfo)).toBe(true);
+        expect(support.isTuyaMatterDevice(devInfo)).toBe(true);
+        expect(support.isTripartiteMatter(_objectSpread(_objectSpread({}, devInfo), {}, {
+          isTripartiteMatter: true
+        }))).toBe(true);
+        setCachedDevInfo(devInfo);
+        expect(support.isMatterDevice()).toBe(true);
+      });
     });
-    describe('设备能力判断', () => {
-      it('hasCapability应该正确判断设备能力', () => {
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          capability: 1 << DeviceCapability.WIFI | 1 << DeviceCapability.ZIGBEE
-        }));
-        expect(support.hasCapability(DeviceCapability.WIFI)).toBe(true);
-        expect(support.hasCapability(DeviceCapability.ZIGBEE)).toBe(true);
-        expect(support.hasCapability(DeviceCapability.SIGMESH)).toBe(false);
+    describe('isSupportCloudTimer', () => {
+      it('returns true when panelConfig contains selected timer', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        expect(support.isSupportCloudTimer(_objectSpread({}, baseDevInfo))).toBe(true);
       });
-      it('isGroupDevice应该正确判断是否为群组设备', () => {
-        // 没有groupId时返回false
-        getScheduleCache.mockReturnValue(mockDevInfo);
-        expect(support.isGroupDevice()).toBe(false);
-
-        // 有groupId时返回true
-        getScheduleCache.mockReturnValue(mockGroupInfo);
-        expect(support.isGroupDevice()).toBe(true);
+      it('returns false when device list contains unsupported member', () => {
+        const support = new Support({
+          devId: '',
+          groupId: 'group-1'
+        });
+        const groupInfo = _objectSpread(_objectSpread({}, baseGroupInfo), {}, {
+          deviceList: [{
+            panelConfig: {
+              bic: [{
+                code: 'timer',
+                selected: true
+              }]
+            }
+          }, {
+            panelConfig: {
+              bic: [{
+                code: 'timer',
+                selected: false
+              }]
+            }
+          }]
+        });
+        expect(support.isSupportCloudTimer(groupInfo)).toBe(false);
       });
-      it('isSupportCloudTimer应该正确判断是否支持云端定时', () => {
-        // 设置支持云端定时的设备信息
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          panelConfig: {
-            bic: [{
-              code: 'timer',
-              selected: true
-            }]
-          }
-        }));
-        expect(support.isSupportCloudTimer()).toBe(true);
-
-        // 测试不支持云端定时的情况
-        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
-          panelConfig: {
-            bic: [{
-              code: 'timer',
-              selected: false
-            }]
+      it('returns true only when all group members support timer', () => {
+        const support = new Support({
+          devId: '',
+          groupId: 'group-1'
+        });
+        const groupInfo = _objectSpread(_objectSpread({}, baseGroupInfo), {}, {
+          deviceList: [{
+            panelConfig: {
+              bic: [{
+                code: 'timer',
+                selected: true
+              }]
+            }
+          }, {
+            panelConfig: {
+              bic: [{
+                code: 'timer',
+                selected: true
+              }]
+            }
+          }]
+        });
+        expect(support.isSupportCloudTimer(groupInfo)).toBe(true);
+      });
+    });
+    describe('supportDp & isSupportDp', () => {
+      const support = new Support({
+        devId: 'dev-1'
+      });
+      beforeEach(() => {
+        support.isInit = true;
+        setCachedDevInfo(_objectSpread({}, baseDevInfo));
+      });
+      it('supports schema array lookup', () => {
+        expect(support.supportDp('switch_led', baseDevInfo)).toBe(true);
+        expect(support.supportDp('not_exist', baseDevInfo)).toBe(false);
+      });
+      it('supports schema object lookup', () => {
+        const devInfoObjectSchema = _objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          schema: {
+            switch_led: {},
+            another: {}
           }
+        });
+        expect(support.supportDp('switch_led', devInfoObjectSchema)).toBe(true);
+        expect(support.supportDp('not_exist', devInfoObjectSchema)).toBe(false);
+      });
+      it('isSupportDp caches results when not forced', () => {
+        const devInfo = _objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          schema: [{
+            code: 'cached_dp'
+          }]
+        });
+        expect(support.isSupportDp('cached_dp', false, devInfo)).toBe(true);
+        // After caching, flip schema to empty but expect true without isForce
+        setCachedDevInfo(_objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          schema: []
         }));
-        expect(support.isSupportCloudTimer()).toBe(false);
+        expect(support.isSupportDp('cached_dp')).toBe(true);
+        // Forcing bypasses cache
+        expect(support.isSupportDp('cached_dp', true)).toBe(false);
+      });
+      it('returns false when not initialized', () => {
+        const notInitSupport = new Support({
+          devId: 'dev-1'
+        });
+        notInitSupport.isInit = false;
+        expect(notInitSupport.isSupportDp('switch_led')).toBe(false);
       });
     });
-    describe('DP点支持判断', () => {
-      beforeEach(() => {
-        getScheduleCache.mockReturnValue(mockDevInfo);
-        getDpCodeByDpId.mockImplementation(dpId => {
-          if (dpId === 1) return 'switch_led';
-          if (dpId === 2) return 'bright_value';
-          return null;
-        });
-        getDpIdByDpCode.mockImplementation(dpCode => {
-          if (dpCode === 'switch_led') return 1;
-          if (dpCode === 'bright_value') return 2;
-          return null;
-        });
-      });
-      it('supportDp应该正确判断是否支持DP点（通过dpCode）', () => {
-        expect(support.supportDp('switch_led')).toBe(true);
-        expect(support.supportDp('bright_value')).toBe(true);
-        expect(support.supportDp('unsupported_dp')).toBe(false);
+    describe('getMergeDevInfo & group detection', () => {
+      it('merges cached dev and group info', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        setCachedDevInfo(baseDevInfo);
+        support.groupDevInfo = baseGroupInfo;
+        const merged = support.getMergeDevInfo();
+        expect(merged.devId).toBe('dev-1');
+        expect(support.groupDevInfo.groupId).toBe('group-1');
+      });
+      it('isGroupDevice uses cached info when argument omitted', () => {
+        const support = new Support({
+          devId: 'dev-1'
+        });
+        setCachedDevInfo(_objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          groupId: 'group-1'
+        }));
+        expect(support.isGroupDevice()).toBe(true);
+        setCachedDevInfo(_objectSpread(_objectSpread({}, baseDevInfo), {}, {
+          groupId: undefined
+        }));
+        expect(support.isGroupDevice()).toBe(false);
       });
     });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lamp-schedule-core",
-  "version": "1.0.1-beta-10",
+  "version": "1.0.2-beta-2",
   "description": "照明计划模块核心能力",
   "main": "./lib/index.js",
   "files": [