@homebridge-plugins/homebridge-tuya 2.2.1 → 3.0.0-beta.1

package/test/zigbee/CloudLocalReconciliation.test.ts

@@ -0,0 +1,284 @@
+import { describe, expect, it, beforeEach, jest } from '@jest/globals';
+import {
+  reconcileDeviceSources,
+  getPreferredSource,
+  filterDevicesBySource,
+  markDeviceConnected,
+  shouldHideFromSource,
+  logReconciliationSummary,
+  DeviceSourceInfo,
+} from '../../src/local/CloudLocalReconciliation';
+import TuyaDevice from '../../src/cloud/device/TuyaDevice';
+import Logger from '../../src/shared/util/Logger';
+
+function makeMockLog(): Logger {
+  return {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+  } as unknown as Logger;
+}
+
+function createMockDevice(id: string, uuid: string): TuyaDevice {
+  return {
+    id,
+    uuid,
+    name: `Device ${id}`,
+  } as TuyaDevice;
+}
+
+describe('CloudLocalReconciliation - Phase 4', () => {
+  let log: Logger;
+
+  beforeEach(() => {
+    log = makeMockLog();
+  });
+
+  describe('reconcileDeviceSources', () => {
+    it('reconciles cloud-only devices', () => {
+      const cloudDevices = [
+        createMockDevice('cloud_001', 'uuid_001'),
+        createMockDevice('cloud_002', 'uuid_002'),
+      ];
+
+      const result = reconcileDeviceSources(cloudDevices, [], log);
+
+      expect(result.size).toBe(2);
+      expect(result.get('uuid_001')).toEqual({
+        cloud: true,
+        local: false,
+        connectedTo: 'cloud',
+      });
+    });
+
+    it('reconciles local-only devices', () => {
+      const localDevices = [
+        createMockDevice('local_001', 'uuid_101'),
+      ];
+
+      const result = reconcileDeviceSources([], localDevices, log);
+
+      expect(result.size).toBe(1);
+      expect(result.get('uuid_101')).toEqual({
+        cloud: false,
+        local: true,
+        localIP: undefined,
+        localVersion: undefined,
+        connectedTo: 'local',
+      });
+    });
+
+    it('reconciles hybrid devices (same UUID, both sources)', () => {
+      const cloudDevices = [createMockDevice('device_a', 'uuid_hybrid')];
+      const localDevices = [createMockDevice('device_a', 'uuid_hybrid')];
+
+      const result = reconcileDeviceSources(cloudDevices, localDevices, log);
+
+      expect(result.size).toBe(1);
+      const info = result.get('uuid_hybrid');
+      expect(info?.cloud).toBe(true);
+      expect(info?.local).toBe(true);
+      expect(info?.connectedTo).toBe('both');
+
+      const infoSpy = log.info as jest.MockedFunction<typeof log.info>;
+      expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('available via cloud AND local'));
+    });
+
+    it('handles mixed cloud-only, local-only, and hybrid devices', () => {
+      const cloudDevices = [
+        createMockDevice('cloud_only', 'uuid_cloud'),
+        createMockDevice('hybrid', 'uuid_hybrid'),
+      ];
+      const localDevices = [
+        createMockDevice('local_only', 'uuid_local'),
+        createMockDevice('hybrid', 'uuid_hybrid'),
+      ];
+
+      const result = reconcileDeviceSources(cloudDevices, localDevices, log);
+
+      expect(result.size).toBe(3);
+      expect(result.get('uuid_cloud')?.cloud).toBe(true);
+      expect(result.get('uuid_cloud')?.local).toBe(false);
+      expect(result.get('uuid_local')?.cloud).toBe(false);
+      expect(result.get('uuid_local')?.local).toBe(true);
+      expect(result.get('uuid_hybrid')?.cloud).toBe(true);
+      expect(result.get('uuid_hybrid')?.local).toBe(true);
+    });
+
+    it('logs hybrid device detection', () => {
+      const cloudDevices = [createMockDevice('device', 'uuid_123')];
+      const localDevices = [createMockDevice('device', 'uuid_123')];
+
+      reconcileDeviceSources(cloudDevices, localDevices, log);
+
+      const infoSpy = log.info as jest.MockedFunction<typeof log.info>;
+      expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('available via cloud AND local'));
+    });
+  });
+
+  describe('getPreferredSource', () => {
+    it('prefers local when available', () => {
+      const sourceInfo: DeviceSourceInfo = { cloud: true, local: true };
+      expect(getPreferredSource(sourceInfo)).toBe('local');
+    });
+
+    it('uses cloud when local unavailable', () => {
+      const sourceInfo: DeviceSourceInfo = { cloud: true, local: false };
+      expect(getPreferredSource(sourceInfo)).toBe('cloud');
+    });
+
+    it('always prefers local when both available (ignores default param)', () => {
+      const sourceInfo: DeviceSourceInfo = { cloud: true, local: true };
+      // The defaultSource param is only used when local is unavailable
+      // When both are available, local is always preferred
+      expect(getPreferredSource(sourceInfo, 'local')).toBe('local');
+      expect(getPreferredSource(sourceInfo, 'cloud')).toBe('local');
+    });
+  });
+
+  describe('filterDevicesBySource', () => {
+    let sourceMap: Map<string, DeviceSourceInfo>;
+
+    beforeEach(() => {
+      sourceMap = new Map([
+        ['uuid_cloud', { cloud: true, local: false }],
+        ['uuid_local', { cloud: false, local: true }],
+        ['uuid_hybrid', { cloud: true, local: true }],
+      ]);
+    });
+
+    it('filters to local-only devices', () => {
+      const devices = [
+        createMockDevice('cloud', 'uuid_cloud'),
+        createMockDevice('local', 'uuid_local'),
+        createMockDevice('hybrid', 'uuid_hybrid'),
+      ];
+
+      const result = filterDevicesBySource(devices, 'local', sourceMap);
+
+      expect(result.length).toBe(2);
+      expect(result.map(d => d.uuid)).toContain('uuid_local');
+      expect(result.map(d => d.uuid)).toContain('uuid_hybrid');
+      expect(result.map(d => d.uuid)).not.toContain('uuid_cloud');
+    });
+
+    it('filters to cloud-only devices', () => {
+      const devices = [
+        createMockDevice('cloud', 'uuid_cloud'),
+        createMockDevice('local', 'uuid_local'),
+        createMockDevice('hybrid', 'uuid_hybrid'),
+      ];
+
+      const result = filterDevicesBySource(devices, 'cloud', sourceMap);
+
+      expect(result.length).toBe(2);
+      expect(result.map(d => d.uuid)).toContain('uuid_cloud');
+      expect(result.map(d => d.uuid)).toContain('uuid_hybrid');
+      expect(result.map(d => d.uuid)).not.toContain('uuid_local');
+    });
+
+    it('returns all devices for both source filter', () => {
+      const devices = [
+        createMockDevice('cloud', 'uuid_cloud'),
+        createMockDevice('local', 'uuid_local'),
+        createMockDevice('hybrid', 'uuid_hybrid'),
+      ];
+
+      const result = filterDevicesBySource(devices, 'both', sourceMap);
+
+      expect(result.length).toBe(3);
+    });
+
+    it('excludes unknown devices from filter', () => {
+      const devices = [
+        createMockDevice('cloud', 'uuid_cloud'),
+        createMockDevice('unknown', 'uuid_unknown'),
+      ];
+
+      const result = filterDevicesBySource(devices, 'cloud', sourceMap);
+
+      expect(result.length).toBe(1);
+      expect(result[0].uuid).toBe('uuid_cloud');
+    });
+  });
+
+  describe('markDeviceConnected', () => {
+    let sourceMap: Map<string, DeviceSourceInfo>;
+
+    beforeEach(() => {
+      sourceMap = new Map([
+        ['uuid_001', { cloud: true, local: true, connectedTo: 'cloud' }],
+      ]);
+    });
+
+    it('updates device connection state to local', () => {
+      markDeviceConnected('uuid_001', 'local', sourceMap, log);
+
+      expect(sourceMap.get('uuid_001')?.connectedTo).toBe('both');
+    });
+
+    it('warns if marking unknown device as connected', () => {
+      markDeviceConnected('uuid_unknown', 'local', sourceMap, log);
+
+      const warnSpy = log.warn as jest.MockedFunction<typeof log.warn>;
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('unknown device'));
+    });
+
+    it('warns if marking device connected to unavailable source', () => {
+      const sourceInfo: DeviceSourceInfo = {
+        cloud: true,
+        local: false,
+      };
+      sourceMap.set('uuid_002', sourceInfo);
+
+      markDeviceConnected('uuid_002', 'local', sourceMap, log);
+
+      const warnSpy = log.warn as jest.MockedFunction<typeof log.warn>;
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('not available locally'));
+    });
+  });
+
+  describe('shouldHideFromSource', () => {
+    it('does not hide when source is both', () => {
+      const device = createMockDevice('test', 'uuid_test');
+      expect(shouldHideFromSource(device, 'cloud', 'both')).toBe(false);
+      expect(shouldHideFromSource(device, 'local', 'both')).toBe(false);
+    });
+
+    it('hides cloud devices when source is local-only', () => {
+      const device = createMockDevice('test', 'uuid_test');
+      expect(shouldHideFromSource(device, 'cloud', 'local')).toBe(true);
+    });
+
+    it('hides local devices when source is cloud-only', () => {
+      const device = createMockDevice('test', 'uuid_test');
+      expect(shouldHideFromSource(device, 'local', 'cloud')).toBe(true);
+    });
+
+    it('defaults to cloud-only when source undefined', () => {
+      const device = createMockDevice('test', 'uuid_test');
+      expect(shouldHideFromSource(device, 'local', undefined)).toBe(true);
+      expect(shouldHideFromSource(device, 'cloud', undefined)).toBe(false);
+    });
+  });
+
+  describe('logReconciliationSummary', () => {
+    it('logs reconciliation counts', () => {
+      const sourceMap = new Map<string, DeviceSourceInfo>([
+        ['uuid_1', { cloud: true, local: true }],
+        ['uuid_2', { cloud: true, local: false }],
+        ['uuid_3', { cloud: false, local: true }],
+      ]);
+
+      logReconciliationSummary(sourceMap, log);
+
+      const infoSpy = log.info as jest.MockedFunction<typeof log.info>;
+      const call = String(infoSpy.mock.calls[0][0]);
+      expect(call).toContain('1 hybrid');
+      expect(call).toContain('1 cloud-only');
+      expect(call).toContain('1 local-only');
+    });
+  });
+});

package/test/zigbee/DynamicChildDiscovery.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, it } from '@jest/globals';
+import {
+  discoverFromCloudList,
+  parseSubDeviceListResponse,
+  getOnlineCids,
+  buildDiscoveredChildConfig,
+  isValidDiscoveredCid,
+  supportsChildDiscovery,
+  logDiscoveryResults,
+} from '../../src/local/DynamicChildDiscovery';
+import { LocalDeviceConfig } from '../../src/local/config';
+import Logger from '../../src/shared/util/Logger';
+import { jest } from '@jest/globals';
+
+describe('DynamicChildDiscovery', () => {
+  describe('discoverFromCloudList', () => {
+    it('discovers parent-child relationships from cloud device list', () => {
+      const cloudDevices = [
+        { id: 'gateway_001', gateway_id: undefined },
+        { id: 'child_001', gateway_id: 'gateway_001' },
+        { id: 'child_002', gateway_id: 'gateway_001' },
+        { id: 'device_standalone', gateway_id: undefined },
+      ];
+
+      const result = discoverFromCloudList(cloudDevices);
+
+      expect(result.size).toBe(1);
+      expect(result.get('gateway_001')).toEqual(['child_001', 'child_002']);
+      expect(result.has('device_standalone')).toBe(false);
+    });
+
+    it('ignores devices with same gateway_id as their own id', () => {
+      const cloudDevices = [{ id: 'device_001', gateway_id: 'device_001' }];
+
+      const result = discoverFromCloudList(cloudDevices);
+
+      expect(result.size).toBe(0);
+    });
+
+    it('handles multiple gateways', () => {
+      const cloudDevices = [
+        { id: 'gw_001' },
+        { id: 'child_001', gateway_id: 'gw_001' },
+        { id: 'gw_002' },
+        { id: 'child_002', gateway_id: 'gw_002' },
+      ];
+
+      const result = discoverFromCloudList(cloudDevices);
+
+      expect(result.size).toBe(2);
+      expect(result.get('gw_001')).toEqual(['child_001']);
+      expect(result.get('gw_002')).toEqual(['child_002']);
+    });
+
+    it('returns empty map for no cloud devices', () => {
+      const result = discoverFromCloudList([]);
+      expect(result.size).toBe(0);
+    });
+  });
+
+  describe('parseSubDeviceListResponse', () => {
+    it('parses nested data.subdevList format', () => {
+      const response = {
+        data: {
+          subdevList: [
+            { cid: '00112233445566aa', online: 1, productName: 'Light' },
+            { cid: '00112233445566bb', online: 1, productName: 'Switch' },
+          ],
+        },
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].cid).toBe('00112233445566aa');
+      expect(result[1].cid).toBe('00112233445566bb');
+    });
+
+    it('parses flat subdevList format', () => {
+      const response = {
+        subdevList: [{ cid: '00aabbccddeeff00', online: 1 }],
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].cid).toBe('00aabbccddeeff00');
+    });
+
+    it('parses flat deviceList format', () => {
+      const response = {
+        deviceList: [
+          { cid: 'aabbccddee112233', online: 0 },
+          { cid: 'aabbccddee112234', online: 1 },
+        ],
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toHaveLength(2);
+    });
+
+    it('parses DPS format with CID keys', () => {
+      const response = {
+        dps: {
+          '00112233445566aa': { online: 1, productName: 'Light' },
+          '00112233445566bb': { online: 0, productName: 'Switch' },
+          '1': { value: 100 }, // Non-CID DPs ignored
+        },
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].cid).toBe('00112233445566aa');
+      expect(result[1].cid).toBe('00112233445566bb');
+    });
+
+    it('merges multiple list formats if present', () => {
+      const response = {
+        subdevList: [{ cid: 'aaaa0000aaaa0001', online: 1 }],
+        data: {
+          subdevs: [{ cid: 'aaaa0000aaaa0002', online: 1 }],
+        },
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toHaveLength(2);
+      expect(result.map(r => r.cid)).toContain('aaaa0000aaaa0001');
+      expect(result.map(r => r.cid)).toContain('aaaa0000aaaa0002');
+    });
+
+    it('returns empty array for null/undefined response', () => {
+      expect(parseSubDeviceListResponse(null)).toEqual([]);
+      expect(parseSubDeviceListResponse(undefined)).toEqual([]);
+      expect(parseSubDeviceListResponse({})).toEqual([]);
+    });
+
+    it('handles malformed subdevList gracefully', () => {
+      const response = {
+        data: {
+          subdevList: 'not an array', // Invalid format
+        },
+      };
+
+      const result = parseSubDeviceListResponse(response);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getOnlineCids', () => {
+    it('filters online sub-devices (online === 1)', () => {
+      const subdevs = [
+        { cid: '00112233445566aa', online: 1 as const },
+        { cid: '00112233445566bb', online: 0 as const },
+        { cid: '00112233445566cc', online: 1 as const },
+      ];
+
+      const result = getOnlineCids(subdevs);
+
+      expect(result).toEqual(['00112233445566aa', '00112233445566cc']);
+    });
+
+    it('treats missing online field as online (undefined counts as online)', () => {
+      const subdevs = [
+        { cid: '00112233445566aa' }, // No online field
+        { cid: '00112233445566bb', online: 1 as const },
+      ];
+
+      const result = getOnlineCids(subdevs);
+
+      expect(result).toEqual(['00112233445566aa', '00112233445566bb']);
+    });
+
+    it('ignores sub-devices without CID', () => {
+      const subdevs = [
+        { cid: '00112233445566aa', online: 1 as const },
+        { id: 'device_002', online: 1 as const } as any, // No CID
+        { cid: undefined, online: 1 as const } as any,
+      ];
+
+      const result = getOnlineCids(subdevs);
+
+      expect(result).toEqual(['00112233445566aa']);
+    });
+
+    it('returns empty array for offline-only devices', () => {
+      const subdevs = [
+        { cid: '00112233445566aa', online: 0 as const },
+        { cid: '00112233445566bb', online: 0 as const },
+      ];
+
+      const result = getOnlineCids(subdevs);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('buildDiscoveredChildConfig', () => {
+    it('builds child config from gateway and CID', () => {
+      const config = buildDiscoveredChildConfig('gateway_001', '00112233445566aa', undefined, '192.168.1.100', 'key123');
+
+      expect(config.parentDeviceId).toBe('gateway_001');
+      expect(config.zigbeeChildId).toBe('00112233445566aa');
+      expect(config.tuyaDeviceId).toBe('gateway_001_00112233445566aa');
+      expect(config.ip).toBe('192.168.1.100');
+      expect(config.tuyaKey).toBe('key123');
+    });
+
+    it('uses subdevInfo.id if provided', () => {
+      const subdevInfo = { id: 'custom_child_id', cid: '00112233445566aa' };
+      const config = buildDiscoveredChildConfig('gw_001', '00112233445566aa', subdevInfo, '192.168.1.1', 'key');
+
+      expect(config.tuyaDeviceId).toBe('custom_child_id');
+    });
+
+    it('includes productName in device name if available', () => {
+      const subdevInfo = { id: 'light_001', productName: 'Smart Light', cid: '00112233445566aa' };
+      const config = buildDiscoveredChildConfig('gw_001', '00112233445566aa', subdevInfo);
+
+      expect(config.name).toContain('Smart Light');
+      expect(config.name).toContain('00112233445566aa');
+    });
+
+    it('includes category from subdevInfo', () => {
+      const subdevInfo = { id: 'child_001', category: 'dj', cid: '00112233445566aa' };
+      const config = buildDiscoveredChildConfig('gw_001', '00112233445566aa', subdevInfo);
+
+      expect(config.category).toBe('dj');
+    });
+
+    it('generates fallback name if no productName', () => {
+      const config = buildDiscoveredChildConfig('gw_001', '00112233445566aa');
+
+      expect(config.name).toContain('Child');
+      expect(config.name).toContain('00112233445566aa');
+    });
+  });
+
+  describe('isValidDiscoveredCid', () => {
+    it('accepts valid 16-character lowercase hex CIDs', () => {
+      expect(isValidDiscoveredCid('00112233445566aa')).toBe(true);
+      expect(isValidDiscoveredCid('aabbccddee112233')).toBe(true);
+      expect(isValidDiscoveredCid('0000000000000000')).toBe(true);
+      expect(isValidDiscoveredCid('ffffffffffffffff')).toBe(true);
+    });
+
+    it('rejects uppercase hex', () => {
+      expect(isValidDiscoveredCid('00112233445566AA')).toBe(false);
+      expect(isValidDiscoveredCid('AABBCCDDEE112233')).toBe(false);
+    });
+
+    it('rejects mixed case', () => {
+      expect(isValidDiscoveredCid('00112233445566Aa')).toBe(false);
+    });
+
+    it('rejects wrong length', () => {
+      expect(isValidDiscoveredCid('00112233445566')).toBe(false); // Too short
+      expect(isValidDiscoveredCid('00112233445566aa00')).toBe(false); // Too long
+    });
+
+    it('rejects non-hex characters', () => {
+      expect(isValidDiscoveredCid('00112233445566xx')).toBe(false);
+      expect(isValidDiscoveredCid('00112233445566gg')).toBe(false);
+    });
+
+    it('rejects non-string input', () => {
+      expect(isValidDiscoveredCid(1234567890123456 as any)).toBe(false);
+      expect(isValidDiscoveredCid(null as any)).toBe(false);
+      expect(isValidDiscoveredCid(undefined as any)).toBe(false);
+    });
+  });
+
+  describe('supportsChildDiscovery', () => {
+    it('returns true for explicit isZigbeeGateway: true', () => {
+      const config: LocalDeviceConfig = {
+        tuyaDeviceId: 'gw_001',
+        isZigbeeGateway: true,
+      };
+
+      expect(supportsChildDiscovery(config)).toBe(true);
+    });
+
+    it('returns false for explicit isZigbeeGateway: false', () => {
+      const config: LocalDeviceConfig = {
+        tuyaDeviceId: 'device_001',
+        isZigbeeGateway: false,
+      };
+
+      expect(supportsChildDiscovery(config)).toBe(false);
+    });
+
+    it('returns true when isZigbeeGateway is undefined (assumes it might be gateway)', () => {
+      const config: LocalDeviceConfig = {
+        tuyaDeviceId: 'device_001',
+      };
+
+      expect(supportsChildDiscovery(config)).toBe(true);
+    });
+  });
+
+  describe('logDiscoveryResults', () => {
+    it('logs debug message for no discoveries', () => {
+      const mockLog = { debug: jest.fn() } as unknown as Logger;
+
+      logDiscoveryResults('gw_001', [], mockLog);
+
+      expect((mockLog.debug as jest.Mock).mock.calls[0][0]).toContain('no sub-devices discovered');
+    });
+
+    it('logs info message with discovered CID count', () => {
+      const mockLog = { info: jest.fn() } as unknown as Logger;
+
+      logDiscoveryResults('gw_001', ['00112233445566aa', '00112233445566bb'], mockLog);
+
+      const call = (mockLog.info as jest.Mock).mock.calls[0][0];
+      expect(call).toContain('gw_001');
+      expect(call).toContain('2 sub-device');
+    });
+
+    it('logs CID list in discovery message', () => {
+      const mockLog = { info: jest.fn() } as unknown as Logger;
+
+      logDiscoveryResults('gw_001', ['aaaa0000aaaa0001', 'bbbb0000bbbb0001'], mockLog);
+
+      const call = (mockLog.info as jest.Mock).mock.calls[0][0];
+      expect(call).toContain('aaaa0000aaaa0001');
+      expect(call).toContain('bbbb0000bbbb0001');
+    });
+  });
+});