@homebridge-plugins/homebridge-tuya 3.0.0-beta.2 → 3.0.0-beta.21

package/test/tuyaDeviceManager.test.ts

@@ -1,27 +1,21 @@
 /* eslint-disable no-console */
 import { describe, expect, test, beforeEach, jest } from '@jest/globals';
 import EventEmitter from 'events';
-import TuyaDeviceManager from '../src/cloud/device/TuyaDeviceManager';
+import TuyaDeviceManager from '../src/cloud/device/TuyaCloudDeviceManager';
 import TuyaDevice from '../src/cloud/device/TuyaDevice';
+import TuyaHomeDeviceManager from '../src/cloud/device/TuyaHomeDeviceManager';
+import { TuyaPlatformHomeConfig } from '../src/config';
+import { ExLogger, initLogger } from '../src/shared/util/Logger';
 
 // Mock Logger
-jest.mock('../src/shared/util/Logger', () => ({
-  __esModule: true,
-  default: class Logger {
-    log() {}
-    info() {}
-    warn() {}
-    error() {}
-    debug() {}
-  },
-  PrefixLogger: class PrefixLogger {
-    constructor(public log: any, public name: string, public debugEnabled: boolean) {}
-    info() {}
-    warn() {}
-    error() {}
-    debug() {}
-  },
-}));
+const mockLog: ExLogger = {
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  log: jest.fn(),
+  success: jest.fn(),
+} as unknown as ExLogger;
 
 // Mock TuyaOpenMQ
 jest.mock('../src/cloud/api/TuyaOpenMQ', () => {
@@ -41,773 +35,776 @@ jest.mock('../src/cloud/api/TuyaOpenAPI', () => {
   };
 });
 
-describe('TuyaDeviceManager', () => {
-  let manager: TuyaDeviceManager;
-  let mockAPI: any;
-
-  beforeEach(() => {
-    const getMock = jest.fn() as any;
-    getMock.mockImplementation((url: string) => {
-      if (url.includes('specifications')) {
+describe('TuyaDeviceManager', () => 
+  {
+    let manager: TuyaDeviceManager;
+    let mockAPI: any;
+    let mockConfig: TuyaPlatformHomeConfig;
+
+    beforeEach(() => {
+      initLogger(mockLog);
+      const getMock = jest.fn() as any;
+      getMock.mockImplementation((url: string) => {
+        if (url.includes('specifications')) {
+          return Promise.resolve({
+            success: true,
+            result: {
+              status: [],
+              functions: [],
+            },
+          });
+        }
         return Promise.resolve({
           success: true,
           result: {
+            id: 'device_001',
+            name: 'Test Device',
+            product_id: 'prod_001',
+            category: 'dj',
             status: [],
-            functions: [],
+            schema: [],
           },
         });
-      }
-      return Promise.resolve({
-        success: true,
-        result: {
-          id: 'device_001',
-          name: 'Test Device',
-          product_id: 'prod_001',
-          category: 'dj',
-          status: [],
-          schema: [],
-        },
       });
-    });
-    
-    mockAPI = {
-      log: { log: console.log } as any,
-      accessId: 'test_access_id',
-      accessKey: 'test_access_key',
-      get: getMock,
-    };
-
-    manager = new TuyaDeviceManager(mockAPI, false);
-  });
-
-  describe('initialization', () => {
-    test('creates device manager instance', () => {
-      expect(manager).toBeInstanceOf(EventEmitter);
-      expect(manager).toBeDefined();
-    });
+      
+      mockAPI = {
+        log: { log: console.log } as any,
+        accessId: 'test_access_id',
+        accessKey: 'test_access_key',
+        get: getMock,
+      };
 
-    test('stores API reference', () => {
-      expect(manager.api).toBe(mockAPI);
-    });
-
-    test('initializes with debug disabled', () => {
-      expect(manager.debug).toBe(false);
-    });
+      mockConfig =  {
+        projectType: '2',
+        accessId: 'test_id',
+        accessKey: 'test_key',
+        countryCode: 1,
+        username: 'user@example.com',
+        password: 'password',
+        appSchema: 'tuyaSmart',
+        generateWeatherAccessory: false,
+        weatherAPI: '',
+        forceIPv4: false,
+      } as TuyaPlatformHomeConfig;
 
-    test('initializes with debug enabled', () => {
-      const debugManager = new TuyaDeviceManager(mockAPI, true);
-      expect(debugManager.debug).toBe(true);
+      manager = new TuyaHomeDeviceManager(mockAPI, mockConfig, false);
     });
 
-    test('initializes MQTT connection', () => {
-      expect(manager.mq).toBeDefined();
-    });
+    describe('initialization', () => {
+      test('creates device manager instance', () => {
+        expect(manager).toBeInstanceOf(EventEmitter);
+        expect(manager).toBeDefined();
+      });
 
-    test('creates logger', () => {
-      expect(manager.log).toBeDefined();
-    });
+      test('stores API reference', () => {
+        expect(manager.api).toBe(mockAPI);
+      });
 
-    test('initializes empty owner IDs array', () => {
-      expect(manager.ownerIDs).toEqual([]);
-      expect(Array.isArray(manager.ownerIDs)).toBe(true);
-    });
+      test('initializes with debug disabled', () => {
+        expect(manager.debug).toBe(false);
+      });
 
-    test('initializes empty devices array', () => {
-      expect(manager.devices).toEqual([]);
-      expect(Array.isArray(manager.devices)).toBe(true);
-    });
-  });
+      test('initializes with debug enabled', () => {
+        const debugManager = new TuyaHomeDeviceManager(mockAPI, mockConfig, true);
+        expect(debugManager.debug).toBe(true);
+      });
 
-  describe('static events', () => {
-    test('has DEVICE_ADD event', () => {
-      expect(TuyaDeviceManager.Events.DEVICE_ADD).toBe('DEVICE_ADD');
-    });
+      test('initializes MQTT connection', () => {
+        expect(manager.mq).toBeDefined();
+      });
 
-    test('has DEVICE_INFO_UPDATE event', () => {
-      expect(TuyaDeviceManager.Events.DEVICE_INFO_UPDATE).toBe('DEVICE_INFO_UPDATE');
-    });
+      test('creates logger', () => {
+        expect(manager['log']).toBeDefined();
+        expect((manager['log'] as any).prefix).toEqual('TuyaHomeDeviceManager');
+      });
 
-    test('has DEVICE_STATUS_UPDATE event', () => {
-      expect(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE).toBe('DEVICE_STATUS_UPDATE');
-    });
+      test('initializes empty owner IDs array', () => {
+        expect(manager.ownerIDs).toEqual([]);
+        expect(Array.isArray(manager.ownerIDs)).toBe(true);
+      });
 
-    test('has DEVICE_DELETE event', () => {
-      expect(TuyaDeviceManager.Events.DEVICE_DELETE).toBe('DEVICE_DELETE');
+      test('initializes empty devices array', () => {
+        expect(manager.devices).toEqual([]);
+        expect(Array.isArray(manager.devices)).toBe(true);
+      });
     });
-  });
 
-  describe('virtual device creation', () => {
-    test('creates virtual device from base device', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_device_001',
-        product_id: 'product_001',
-        category: 'dj',
-        name: 'Base Light',
-        schema: [],
-        status: [],
+    describe('static events', () => {
+      test('has DEVICE_ADD event', () => {
+        expect(TuyaDeviceManager.Events.DEVICE_ADD).toBe('DEVICE_ADD');
       });
 
-      const virtualDevice = manager.createVirtualDevice(baseDevice, 'virtual_uuid');
+      test('has DEVICE_INFO_UPDATE event', () => {
+        expect(TuyaDeviceManager.Events.DEVICE_INFO_UPDATE).toBe('DEVICE_INFO_UPDATE');
+      });
 
-      expect(virtualDevice).toBeDefined();
-      expect(virtualDevice).toBeInstanceOf(TuyaDevice);
-      expect(virtualDevice.sub).toBe(true);
-      expect(virtualDevice.parent_id).toBe('base_device_001');
-    });
+      test('has DEVICE_STATUS_UPDATE event', () => {
+        expect(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE).toBe('DEVICE_STATUS_UPDATE');
+      });
 
-    test('sets virtual device properties', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Base',
-        schema: [],
-        status: [],
+      test('has DEVICE_DELETE event', () => {
+        expect(TuyaDeviceManager.Events.DEVICE_DELETE).toBe('DEVICE_DELETE');
       });
+    });
 
-      const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid_123');
+    describe('virtual device creation', () => {
+      test('creates virtual device from base device', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_device_001',
+          product_id: 'product_001',
+          category: 'dj',
+          name: 'Base Light',
+          schema: [],
+          status: [],
+        });
 
-      expect(virtualDevice.name).toBe('Virtual Device');
-      expect(virtualDevice.product_name).toBe('virtual product');
-      expect(virtualDevice.ip).toBe('');
-      expect(virtualDevice.remote_keys).toBeUndefined();
-    });
+        const virtualDevice = manager.createVirtualDevice(baseDevice, 'virtual_uuid');
 
-    test('generates UUID if not provided', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_001',
-        product_id: 'prod_001',
-        category: 'kg',
-        name: 'Base',
-        schema: [],
-        status: [],
+        expect(virtualDevice).toBeDefined();
+        expect(virtualDevice).toBeInstanceOf(TuyaDevice);
+        expect(virtualDevice.sub).toBe(true);
+        expect(virtualDevice.parent_id).toBe('base_device_001');
       });
 
-      const virtualDevice = manager.createVirtualDevice(baseDevice, '');
+      test('sets virtual device properties', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Base',
+          schema: [],
+          status: [],
+        });
 
-      expect(virtualDevice.id).toBeDefined();
-      expect(virtualDevice.id.length).toBeGreaterThan(0);
-    });
+        const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid_123');
 
-    test('clones base device schema', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Base',
-        schema: [
-          {
-            code: 'switch',
-            mode: 'rw' as any,
-            type: 'Boolean' as any,
-            property: {} as any,
-          },
-        ],
-        status: [],
+        expect(virtualDevice.name).toBe('Virtual Device');
+        expect(virtualDevice.product_name).toBe('virtual product');
+        expect(virtualDevice.ip).toBe('');
+        expect(virtualDevice.remote_keys).toBeUndefined();
       });
 
-      const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid');
+      test('generates UUID if not provided', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_001',
+          product_id: 'prod_001',
+          category: 'kg',
+          name: 'Base',
+          schema: [],
+          status: [],
+        });
 
-      expect(virtualDevice.schema).toBeDefined();
-      expect(virtualDevice.schema.length).toBeGreaterThan(0);
-    });
+        const virtualDevice = manager.createVirtualDevice(baseDevice, '');
 
-    test('clones base device status', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Base',
-        schema: [],
-        status: [{ code: 'switch_1', value: 1 }],
+        expect(virtualDevice.id).toBeDefined();
+        expect(virtualDevice.id.length).toBeGreaterThan(0);
       });
 
-      const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid');
+      test('clones base device schema', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Base',
+          schema: [
+            {
+              code: 'switch',
+              mode: 'rw' as any,
+              type: 'Boolean' as any,
+              property: {} as any,
+            },
+          ],
+          status: [],
+        });
 
-      expect(virtualDevice.status).toBeDefined();
-    });
-  });
+        const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid');
 
-  describe('device retrieval', () => {
-    test('finds device by ID', () => {
-      const device1 = new TuyaDevice({
-        id: 'device_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Device 1',
-        schema: [],
-        status: [],
+        expect(virtualDevice.schema).toBeDefined();
+        expect(virtualDevice.schema.length).toBeGreaterThan(0);
       });
 
-      manager.devices.push(device1);
-
-      const found = manager.getDevice('device_001');
-      expect(found).toBe(device1);
-    });
+      test('clones base device status', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Base',
+          schema: [],
+          status: [{ code: 'switch_1', value: 1 }],
+        });
 
-    test('returns undefined for non-existent device', () => {
-      manager.devices = [];
-      const found = manager.getDevice('non_existent');
+        const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_uuid');
 
-      expect(found).toBeUndefined();
+        expect(virtualDevice.status).toBeDefined();
+      });
     });
 
-    test('finds correct device among multiple', () => {
-      const device1 = new TuyaDevice({
-        id: 'device_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Device 1',
-        schema: [],
-        status: [],
-      });
+    describe('device retrieval', () => {
+      test('finds device by ID', () => {
+        const device1 = new TuyaDevice({
+          id: 'device_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Device 1',
+          schema: [],
+          status: [],
+        });
 
-      const device2 = new TuyaDevice({
-        id: 'device_002',
-        product_id: 'prod_002',
-        category: 'kg',
-        name: 'Device 2',
-        schema: [],
-        status: [],
-      });
+        manager.devices.push(device1);
 
-      manager.devices = [device1, device2];
+        const found = manager.getDevice('device_001');
+        expect(found).toBe(device1);
+      });
 
-      const found = manager.getDevice('device_002');
-      expect(found?.id).toBe('device_002');
-      expect(found?.category).toBe('kg');
-    });
-  });
+      test('returns undefined for non-existent device', () => {
+        manager.devices = [];
+        const found = manager.getDevice('non_existent');
 
-  describe('device array management', () => {
-    test('can add devices to array', () => {
-      const device = new TuyaDevice({
-        id: 'dev_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Device',
-        schema: [],
-        status: [],
+        expect(found).toBeUndefined();
       });
 
-      manager.devices.push(device);
+      test('finds correct device among multiple', () => {
+        const device1 = new TuyaDevice({
+          id: 'device_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Device 1',
+          schema: [],
+          status: [],
+        });
 
-      expect(manager.devices.length).toBe(1);
-      expect(manager.devices[0]).toBe(device);
-    });
+        const device2 = new TuyaDevice({
+          id: 'device_002',
+          product_id: 'prod_002',
+          category: 'kg',
+          name: 'Device 2',
+          schema: [],
+          status: [],
+        });
 
-    test('can remove devices from array', () => {
-      const device1 = new TuyaDevice({
-        id: 'dev_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Device 1',
-        schema: [],
-        status: [],
-      });
+        manager.devices = [device1, device2];
 
-      const device2 = new TuyaDevice({
-        id: 'dev_002',
-        product_id: 'prod_002',
-        category: 'kg',
-        name: 'Device 2',
-        schema: [],
-        status: [],
+        const found = manager.getDevice('device_002');
+        expect(found?.id).toBe('device_002');
+        expect(found?.category).toBe('kg');
       });
+    });
+
+    describe('device array management', () => {
+      test('can add devices to array', () => {
+        const device = new TuyaDevice({
+          id: 'dev_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Device',
+          schema: [],
+          status: [],
+        });
 
-      manager.devices = [device1, device2];
-      manager.devices = manager.devices.filter(d => d.id !== 'dev_001');
+        manager.devices.push(device);
 
-      expect(manager.devices.length).toBe(1);
-      expect(manager.devices[0].id).toBe('dev_002');
-    });
+        expect(manager.devices.length).toBe(1);
+        expect(manager.devices[0]).toBe(device);
+      });
 
-    test('can clear all devices', () => {
-      manager.devices = [
-        new TuyaDevice({
-          id: 'dev_1',
-          product_id: 'prod_1',
+      test('can remove devices from array', () => {
+        const device1 = new TuyaDevice({
+          id: 'dev_001',
+          product_id: 'prod_001',
           category: 'dj',
           name: 'Device 1',
           schema: [],
           status: [],
-        }),
-        new TuyaDevice({
-          id: 'dev_2',
-          product_id: 'prod_2',
+        });
+
+        const device2 = new TuyaDevice({
+          id: 'dev_002',
+          product_id: 'prod_002',
           category: 'kg',
           name: 'Device 2',
           schema: [],
           status: [],
-        }),
-      ];
+        });
 
-      manager.devices = [];
+        manager.devices = [device1, device2];
+        manager.devices = manager.devices.filter(d => d.id !== 'dev_001');
 
-      expect(manager.devices.length).toBe(0);
-    });
-  });
+        expect(manager.devices.length).toBe(1);
+        expect(manager.devices[0].id).toBe('dev_002');
+      });
 
-  describe('owner ID management', () => {
-    test('can add owner IDs', () => {
-      manager.ownerIDs.push('owner_123');
-      manager.ownerIDs.push('owner_456');
+      test('can clear all devices', () => {
+        manager.devices = [
+          new TuyaDevice({
+            id: 'dev_1',
+            product_id: 'prod_1',
+            category: 'dj',
+            name: 'Device 1',
+            schema: [],
+            status: [],
+          }),
+          new TuyaDevice({
+            id: 'dev_2',
+            product_id: 'prod_2',
+            category: 'kg',
+            name: 'Device 2',
+            schema: [],
+            status: [],
+          }),
+        ];
+
+        manager.devices = [];
 
-      expect(manager.ownerIDs.length).toBe(2);
-      expect(manager.ownerIDs).toContain('owner_123');
+        expect(manager.devices.length).toBe(0);
+      });
     });
 
-    test('can clear owner IDs', () => {
-      manager.ownerIDs = ['owner_1', 'owner_2'];
-      manager.ownerIDs = [];
+    describe('owner ID management', () => {
+      test('can add owner IDs', () => {
+        manager.ownerIDs.push('owner_123');
+        manager.ownerIDs.push('owner_456');
 
-      expect(manager.ownerIDs.length).toBe(0);
-    });
+        expect(manager.ownerIDs.length).toBe(2);
+        expect(manager.ownerIDs).toContain('owner_123');
+      });
 
-    test('prevents duplicate owner IDs', () => {
-      manager.ownerIDs = ['owner_123', 'owner_456'].filter(
-        (id, index, self) => self.indexOf(id) === index
-      );
+      test('can clear owner IDs', () => {
+        manager.ownerIDs = ['owner_1', 'owner_2'];
+        manager.ownerIDs = [];
 
-      expect(new Set(manager.ownerIDs).size).toBe(manager.ownerIDs.length);
-    });
-  });
+        expect(manager.ownerIDs.length).toBe(0);
+      });
 
-  describe('event emitter behavior', () => {
-    test('is instance of EventEmitter', () => {
-      expect(manager instanceof EventEmitter).toBe(true);
+      test('prevents duplicate owner IDs', () => {
+        manager.ownerIDs = ['owner_123', 'owner_456'].filter(
+          (id, index, self) => self.indexOf(id) === index
+        );
+
+        expect(new Set(manager.ownerIDs).size).toBe(manager.ownerIDs.length);
+      });
     });
 
-    test('can listen for events', (done) => {
-      manager.on('test_event', (data) => {
-        expect(data).toBe('test_data');
-        done();
+    describe('event emitter behavior', () => {
+      test('is instance of EventEmitter', () => {
+        expect(manager instanceof EventEmitter).toBe(true);
       });
 
-      manager.emit('test_event', 'test_data');
-    });
+      test('can listen for events', (done) => {
+        manager.on('test_event', (data) => {
+          expect(data).toBe('test_data');
+          done();
+        });
 
-    test('can emit DEVICE_ADD events', (done) => {
-      manager.on(TuyaDeviceManager.Events.DEVICE_ADD, (device) => {
-        expect(device.id).toBe('device_001');
-        done();
+        manager.emit('test_event', 'test_data');
       });
 
-      const device = new TuyaDevice({
-        id: 'device_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Device',
-        schema: [],
-        status: [],
+      test('can emit DEVICE_ADD events', (done) => {
+        manager.on(TuyaDeviceManager.Events.DEVICE_ADD, (device) => {
+          expect(device.id).toBe('device_001');
+          done();
+        });
+
+        const device = new TuyaDevice({
+          id: 'device_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Device',
+          schema: [],
+          status: [],
+        });
+
+        manager.emit(TuyaDeviceManager.Events.DEVICE_ADD, device);
       });
 
-      manager.emit(TuyaDeviceManager.Events.DEVICE_ADD, device);
+      test('can emit DEVICE_STATUS_UPDATE events', (done) => {
+        manager.on(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE, (deviceId, status) => {
+          expect(deviceId).toBe('device_001');
+          expect(status).toBeDefined();
+          done();
+        });
+
+        manager.emit(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE, 'device_001', {});
+      });
     });
 
-    test('can emit DEVICE_STATUS_UPDATE events', (done) => {
-      manager.on(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE, (deviceId, status) => {
-        expect(deviceId).toBe('device_001');
-        expect(status).toBeDefined();
-        done();
+    describe('MQTT integration', () => {
+      test('adds message listener on init', () => {
+        const newManager = new TuyaHomeDeviceManager(mockAPI, mockConfig, false);
+        expect(newManager.mq.addMessageListener).toHaveBeenCalled();
       });
 
-      manager.emit(TuyaDeviceManager.Events.DEVICE_STATUS_UPDATE, 'device_001', {});
+      test('MQTT is available through manager', () => {
+        expect(manager.mq).toBeDefined();
+        expect(manager.mq.addMessageListener).toBeDefined();
+      });
     });
-  });
 
-  describe('MQTT integration', () => {
-    test('adds message listener on init', () => {
-      const newManager = new TuyaDeviceManager(mockAPI, false);
-      expect(newManager.mq.addMessageListener).toHaveBeenCalled();
-    });
+    describe('device filtering', () => {
+      test('can filter devices by category', () => {
+        manager.devices = [
+          new TuyaDevice({
+            id: 'light_1',
+            product_id: 'prod_1',
+            category: 'dj',
+            name: 'Light',
+            schema: [],
+            status: [],
+          }),
+          new TuyaDevice({
+            id: 'switch_1',
+            product_id: 'prod_2',
+            category: 'kg',
+            name: 'Switch',
+            schema: [],
+            status: [],
+          }),
+        ];
+
+        const lights = manager.devices.filter(d => d.category === 'dj');
+        expect(lights.length).toBe(1);
+        expect(lights[0].category).toBe('dj');
+      });
 
-    test('MQTT is available through manager', () => {
-      expect(manager.mq).toBeDefined();
-      expect(manager.mq.addMessageListener).toBeDefined();
+      test('can filter virtual devices', () => {
+        const baseDevice = new TuyaDevice({
+          id: 'base_001',
+          product_id: 'prod_001',
+          category: 'dj',
+          name: 'Base',
+          schema: [],
+          status: [],
+        });
+
+        const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_123');
+        manager.devices = [baseDevice, virtualDevice];
+
+        const virtuals = manager.devices.filter(d => d.sub === true);
+        expect(virtuals.length).toBe(1);
+        expect(virtuals[0].parent_id).toBe('base_001');
+      });
     });
-  });
 
-  describe('device filtering', () => {
-    test('can filter devices by category', () => {
-      manager.devices = [
-        new TuyaDevice({
-          id: 'light_1',
+    describe('multiple manager instances', () => {
+      test('maintain separate device lists', () => {
+        const manager1 = new TuyaHomeDeviceManager(mockAPI, mockConfig, false);
+        const manager2 = new TuyaHomeDeviceManager(mockAPI, mockConfig, false);
+
+        const device1 = new TuyaDevice({
+          id: 'dev_manager1',
           product_id: 'prod_1',
           category: 'dj',
-          name: 'Light',
+          name: 'Device 1',
           schema: [],
           status: [],
-        }),
-        new TuyaDevice({
-          id: 'switch_1',
+        });
+
+        const device2 = new TuyaDevice({
+          id: 'dev_manager2',
           product_id: 'prod_2',
           category: 'kg',
-          name: 'Switch',
+          name: 'Device 2',
           schema: [],
           status: [],
-        }),
-      ];
+        });
 
-      const lights = manager.devices.filter(d => d.category === 'dj');
-      expect(lights.length).toBe(1);
-      expect(lights[0].category).toBe('dj');
-    });
+        manager1.devices.push(device1);
+        manager2.devices.push(device2);
 
-    test('can filter virtual devices', () => {
-      const baseDevice = new TuyaDevice({
-        id: 'base_001',
-        product_id: 'prod_001',
-        category: 'dj',
-        name: 'Base',
-        schema: [],
-        status: [],
+        expect(manager1.devices.length).toBe(1);
+        expect(manager2.devices.length).toBe(1);
+        expect(manager1.devices[0].id).not.toBe(manager2.devices[0].id);
       });
-
-      const virtualDevice = manager.createVirtualDevice(baseDevice, 'virt_123');
-      manager.devices = [baseDevice, virtualDevice];
-
-      const virtuals = manager.devices.filter(d => d.sub === true);
-      expect(virtuals.length).toBe(1);
-      expect(virtuals[0].parent_id).toBe('base_001');
     });
-  });
 
-  describe('multiple manager instances', () => {
-    test('maintain separate device lists', () => {
-      const manager1 = new TuyaDeviceManager(mockAPI, false);
-      const manager2 = new TuyaDeviceManager(mockAPI, false);
+    describe('device type handling', () => {
+      test('handles light devices', () => {
+        const light = new TuyaDevice({
+          id: 'light_001',
+          product_id: 'dj_prod',
+          category: 'dj',
+          name: 'Smart Light',
+          schema: [],
+          status: [],
+        });
 
-      const device1 = new TuyaDevice({
-        id: 'dev_manager1',
-        product_id: 'prod_1',
-        category: 'dj',
-        name: 'Device 1',
-        schema: [],
-        status: [],
-      });
+        manager.devices.push(light);
 
-      const device2 = new TuyaDevice({
-        id: 'dev_manager2',
-        product_id: 'prod_2',
-        category: 'kg',
-        name: 'Device 2',
-        schema: [],
-        status: [],
+        const found = manager.getDevice('light_001');
+        expect(found?.category).toBe('dj');
       });
 
-      manager1.devices.push(device1);
-      manager2.devices.push(device2);
+      test('handles switch devices', () => {
+        const sw = new TuyaDevice({
+          id: 'switch_001',
+          product_id: 'kg_prod',
+          category: 'kg',
+          name: 'Smart Switch',
+          schema: [],
+          status: [],
+        });
 
-      expect(manager1.devices.length).toBe(1);
-      expect(manager2.devices.length).toBe(1);
-      expect(manager1.devices[0].id).not.toBe(manager2.devices[0].id);
-    });
-  });
+        manager.devices.push(sw);
 
-  describe('device type handling', () => {
-    test('handles light devices', () => {
-      const light = new TuyaDevice({
-        id: 'light_001',
-        product_id: 'dj_prod',
-        category: 'dj',
-        name: 'Smart Light',
-        schema: [],
-        status: [],
+        const found = manager.getDevice('switch_001');
+        expect(found?.category).toBe('kg');
       });
 
-      manager.devices.push(light);
+      test('handles thermostat devices', () => {
+        const thermostat = new TuyaDevice({
+          id: 'thermo_001',
+          product_id: 'wk_prod',
+          category: 'wk',
+          name: 'Thermostat',
+          schema: [],
+          status: [],
+        });
 
-      const found = manager.getDevice('light_001');
-      expect(found?.category).toBe('dj');
-    });
+        manager.devices.push(thermostat);
 
-    test('handles switch devices', () => {
-      const sw = new TuyaDevice({
-        id: 'switch_001',
-        product_id: 'kg_prod',
-        category: 'kg',
-        name: 'Smart Switch',
-        schema: [],
-        status: [],
+        const found = manager.getDevice('thermo_001');
+        expect(found?.category).toBe('wk');
       });
+    });
 
-      manager.devices.push(sw);
+    describe('async operations', () => {
+      test('updateDevices returns array', async () => {
+        const result = await manager.updateDevices([]);
+        expect(Array.isArray(result)).toBe(true);
+      });
 
-      const found = manager.getDevice('switch_001');
-      expect(found?.category).toBe('kg');
+      test('updateDevice can be called', async () => {
+        // Mock implementation since actual HTTP calls are not set up
+        const result = await manager.updateDevice('device_001');
+        expect(typeof result === 'object' || result === null).toBe(true);
+      });
     });
 
-    test('handles thermostat devices', () => {
-      const thermostat = new TuyaDevice({
-        id: 'thermo_001',
-        product_id: 'wk_prod',
-        category: 'wk',
-        name: 'Thermostat',
-        schema: [],
-        status: [],
+    describe('infrared device methods', () => {
+      test('getInfraredRemotes calls API with correct endpoint', async () => {
+        const result = await manager.getInfraredRemotes('ir_001');
+        expect(result).toBeDefined();
       });
 
-      manager.devices.push(thermostat);
+      test('getInfraredKeys calls API with correct endpoint', async () => {
+        const result = await manager.getInfraredKeys('ir_001', 'remote_001');
+        expect(result).toBeDefined();
+      });
 
-      const found = manager.getDevice('thermo_001');
-      expect(found?.category).toBe('wk');
-    });
-  });
+      test('getInfraredACStatus calls API with correct endpoint', async () => {
+        const result = await manager.getInfraredACStatus('ir_001', 'remote_001');
+        expect(result).toBeDefined();
+      });
 
-  describe('async operations', () => {
-    test('updateDevices returns array', async () => {
-      const result = await manager.updateDevices([]);
-      expect(Array.isArray(result)).toBe(true);
+      test('getInfraredDIYKeys calls API with correct endpoint', async () => {
+        const result = await manager.getInfraredDIYKeys('ir_001', 'remote_001');
+        expect(result).toBeDefined();
+      });
     });
 
-    test('updateDevice can be called', async () => {
-      // Mock implementation since actual HTTP calls are not set up
-      const result = await manager.updateDevice('device_001');
-      expect(typeof result === 'object' || result === null).toBe(true);
-    });
-  });
+    describe('infrared remote resolution', () => {
+      test('resolveInfraredRemotes returns empty array when no IR devices', async () => {
+        const parentDevice = new TuyaDevice({
+          id: 'parent_001',
+          name: 'Hub',
+          category: 'wifizigbee',
+          product_id: 'hub_prod',
+          schema: [],
+          status: [],
+        });
 
-  describe('infrared device methods', () => {
-    test('getInfraredRemotes calls API with correct endpoint', async () => {
-      const result = await manager.getInfraredRemotes('ir_001');
-      expect(result).toBeDefined();
-    });
+        const result = await manager.resolveInfraredRemotes(parentDevice, [parentDevice]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(0);
+      });
 
-    test('getInfraredKeys calls API with correct endpoint', async () => {
-      const result = await manager.getInfraredKeys('ir_001', 'remote_001');
-      expect(result).toBeDefined();
-    });
+      test('resolveInfraredRemotes finds IR devices with matching location', async () => {
+        const parentDevice = new TuyaDevice({
+          id: 'parent_001',
+          name: 'Hub',
+          category: 'wnykq',
+          product_id: 'hub_prod',
+          schema: [],
+          status: [],
+          lat: '40.7128',
+          lon: '-74.0060',
+        });
 
-    test('getInfraredACStatus calls API with correct endpoint', async () => {
-      const result = await manager.getInfraredACStatus('ir_001', 'remote_001');
-      expect(result).toBeDefined();
-    });
+        const irDevice = new TuyaDevice({
+          id: 'ir_001',
+          name: 'IR Remote',
+          category: 'infrared_ac',
+          product_id: 'ir_prod',
+          schema: [],
+          status: [],
+          sub: true,
+          lat: '40.7128',
+          lon: '-74.0060',
+        });
 
-    test('getInfraredDIYKeys calls API with correct endpoint', async () => {
-      const result = await manager.getInfraredDIYKeys('ir_001', 'remote_001');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('infrared remote resolution', () => {
-    test('resolveInfraredRemotes returns empty array when no IR devices', () => {
-      const parentDevice = new TuyaDevice({
-        id: 'parent_001',
-        name: 'Hub',
-        category: 'wifizigbee',
-        product_id: 'hub_prod',
-        schema: [],
-        status: [],
-      });
-
-      const result = manager.resolveInfraredRemotes(parentDevice, [parentDevice]);
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBe(0);
-    });
+        const result = await manager.resolveInfraredRemotes(parentDevice, [parentDevice, irDevice]);
+        expect(result.length).toBeGreaterThan(0);
+      });
 
-    test('resolveInfraredRemotes finds IR devices with matching location', () => {
-      const parentDevice = new TuyaDevice({
-        id: 'parent_001',
-        name: 'Hub',
-        category: 'wifizigbee',
-        product_id: 'hub_prod',
-        schema: [],
-        status: [],
-        lat: '40.7128',
-        lon: '-74.0060',
-      });
-
-      const irDevice = new TuyaDevice({
-        id: 'ir_001',
-        name: 'IR Remote',
-        category: 'infrared_ac',
-        product_id: 'ir_prod',
-        schema: [],
-        status: [],
-        sub: true,
-        lat: '40.7128',
-        lon: '-74.0060',
-      });
-
-      const result = manager.resolveInfraredRemotes(parentDevice, [parentDevice, irDevice]);
-      expect(result.length).toBeGreaterThan(0);
-    });
+      test('resolveInfraredRemotes finds IR devices with matching update_time', async () => {
+        const timestamp = 1234567890;
+        const parentDevice = new TuyaDevice({
+          id: 'parent_001',
+          name: 'Hub',
+          category: 'wnykq',
+          product_id: 'hub_prod',
+          schema: [],
+          status: [],
+          update_time: timestamp,
+        });
 
-    test('resolveInfraredRemotes finds IR devices with matching update_time', () => {
-      const timestamp = 1234567890;
-      const parentDevice = new TuyaDevice({
-        id: 'parent_001',
-        name: 'Hub',
-        category: 'wifizigbee',
-        product_id: 'hub_prod',
-        schema: [],
-        status: [],
-        update_time: timestamp,
-      });
-
-      const irDevice = new TuyaDevice({
-        id: 'ir_001',
-        name: 'IR Remote',
-        category: 'infrared_light',
-        product_id: 'ir_prod',
-        schema: [],
-        status: [],
-        sub: true,
-        update_time: timestamp,
-      });
-
-      const result = manager.resolveInfraredRemotes(parentDevice, [parentDevice, irDevice]);
-      expect(result.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('infrared device fixing', () => {
-    test('fixInfraredDevice sets org_category_id', () => {
-      const device = new TuyaDevice({
-        id: 'ir_ac_001',
-        name: 'IR AC',
-        category: 'infrared_ac',
-        product_id: 'prsgoryjfdtb42r4',
-        schema: [],
-        status: [],
-        remote_keys: {
-          category_id: 5,
-          org_category_id: 5,
-          brand_id: 0,
-          remote_index: 0,
-          single_air: false,
-          duplicate_power: false,
-          key_list: [],
-          key_range: [],
-        },
-      });
-
-      manager.fixInfraredDevice(device);
-      expect(device.remote_keys?.org_category_id).toBe(5);
-    });
-  });
-
-  describe('HAP category resolution', () => {
-    test('resolveHAPCategoryID returns correct category for fan product', () => {
-      const device = new TuyaDevice({
-        id: 'ir_fan_001',
-        name: 'IR Fan',
-        category: 'infrared_fan',
-        product_id: 'prsgoryjfdtb42r4',
-        schema: [],
-        status: [],
-        remote_keys: {
-          category_id: 5,
-          org_category_id: 5,
-          brand_id: 0,
-          remote_index: 0,
-          single_air: false,
-          duplicate_power: false,
-          key_list: [],
-          key_range: [],
-        },
-      });
-
-      const result = manager.resolveHAPCategoryID(device);
-      expect(result).toBe(8); // Fan category
-    });
+        const irDevice = new TuyaDevice({
+          id: 'ir_001',
+          name: 'IR Remote',
+          category: 'infrared_light',
+          product_id: 'ir_prod',
+          schema: [],
+          status: [],
+          sub: true,
+          update_time: timestamp,
+        });
 
-    test('resolveHAPCategoryID returns DIY for DIY product', () => {
-      const device = new TuyaDevice({
-        id: 'ir_diy_001',
-        name: 'IR DIY',
-        category: 'infrared_diy',
-        product_id: 'k6ozylayfgnskuq6',
-        schema: [],
-        status: [],
-        remote_keys: {
-          category_id: 5,
-          org_category_id: 5,
-          brand_id: 0,
-          remote_index: 0,
-          single_air: false,
-          duplicate_power: false,
-          key_list: [],
-          key_range: [],
-        },
-      });
-
-      const result = manager.resolveHAPCategoryID(device);
-      expect(result).toBe(999); // DIY category
+        const result = await manager.resolveInfraredRemotes(parentDevice, [parentDevice, irDevice]);
+        expect(result.length).toBeGreaterThan(0);
+      });
     });
 
-    test('resolveHAPCategoryID falls back to device category', () => {
-      const device = new TuyaDevice({
-        id: 'ir_other_001',
-        name: 'IR Other',
-        category: 'infrared_other',
-        product_id: 'other_prod',
-        schema: [],
-        status: [],
-        remote_keys: {
-          category_id: 7,
-          org_category_id: 7,
-          brand_id: 0,
-          remote_index: 0,
-          single_air: false,
-          duplicate_power: false,
-          key_list: [],
-          key_range: [],
-        },
-      });
-
-      const result = manager.resolveHAPCategoryID(device);
-      expect(result).toBe(7);
+    describe('infrared device fixing', () => {
+      test('fixInfraredDevice sets org_category_id', () => {
+        const device = new TuyaDevice({
+          id: 'ir_ac_001',
+          name: 'IR AC',
+          category: 'infrared_ac',
+          product_id: 'prsgoryjfdtb42r4',
+          schema: [],
+          status: [],
+          remote_keys: {
+            category_id: 5,
+            org_category_id: 5,
+            brand_id: 0,
+            remote_index: 0,
+            single_air: false,
+            duplicate_power: false,
+            key_list: [],
+            key_range: [],
+          },
+        });
+
+        manager.fixInfraredDevice(device);
+        expect(device.remote_keys?.org_category_id).toBe(5);
+      });
     });
 
-    test('resolveHAPCategoryID defaults to DIY for device without remote_keys', () => {
-      const device = new TuyaDevice({
-        id: 'ir_001',
-        name: 'IR Device',
-        category: 'infrared_ac',
-        product_id: 'ir_prod',
-        schema: [],
-        status: [],
+    describe('HAP category resolution', () => {
+      test('resolveHAPCategoryID returns correct category for fan product', () => {
+        const device = new TuyaDevice({
+          id: 'ir_fan_001',
+          name: 'IR Fan',
+          category: 'infrared_fan',
+          product_id: 'prsgoryjfdtb42r4',
+          schema: [],
+          status: [],
+          remote_keys: {
+            category_id: 5,
+            org_category_id: 5,
+            brand_id: 0,
+            remote_index: 0,
+            single_air: false,
+            duplicate_power: false,
+            key_list: [],
+            key_range: [],
+          },
+        });
+
+        const result = manager.resolveHAPCategoryID(device);
+        expect(result).toBe(8); // Fan category
       });
 
-      const result = manager.resolveHAPCategoryID(device);
-      expect(result).toBe(999);
-    });
-  });
+      test('resolveHAPCategoryID returns DIY for DIY product', () => {
+        const device = new TuyaDevice({
+          id: 'ir_diy_001',
+          name: 'IR DIY',
+          category: 'infrared_diy',
+          product_id: 'k6ozylayfgnskuq6',
+          schema: [],
+          status: [],
+          remote_keys: {
+            category_id: 5,
+            org_category_id: 5,
+            brand_id: 0,
+            remote_index: 0,
+            single_air: false,
+            duplicate_power: false,
+            key_list: [],
+            key_range: [],
+          },
+        });
 
-  describe('updateInfraredRemotes', () => {
-    test('updateInfraredRemotes skips non-IR devices', async () => {
-      const devices = [
-        new TuyaDevice({
-          id: 'light_001',
-          name: 'Light',
-          category: 'dj',
-          product_id: 'light_prod',
+        const result = manager.resolveHAPCategoryID(device);
+        expect(result).toBe(999); // DIY category
+      });
+
+      test('resolveHAPCategoryID falls back to device category', () => {
+        const device = new TuyaDevice({
+          id: 'ir_other_001',
+          name: 'IR Other',
+          category: 'infrared_other',
+          product_id: 'other_prod',
           schema: [],
           status: [],
-        }),
-      ];
+          remote_keys: {
+            category_id: 7,
+            org_category_id: 7,
+            brand_id: 0,
+            remote_index: 0,
+            single_air: false,
+            duplicate_power: false,
+            key_list: [],
+            key_range: [],
+          },
+        });
 
-      await manager.updateInfraredRemotes(devices);
-      // Should not throw
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('dump method', () => {
-    test('dump logs object properties without error', () => {
-      const testObj = { key1: 'value1', key2: 123 };
-      expect(() => {
-        manager.dump(testObj);
-      }).not.toThrow();
+        const result = manager.resolveHAPCategoryID(device);
+        expect(result).toBe(7);
+      });
+
+      test('resolveHAPCategoryID defaults to DIY for device without remote_keys', () => {
+        const device = new TuyaDevice({
+          id: 'ir_001',
+          name: 'IR Device',
+          category: 'infrared_ac',
+          product_id: 'ir_prod',
+          schema: [],
+          status: [],
+        });
+
+        const result = manager.resolveHAPCategoryID(device);
+        expect(result).toBe(999);
+      });
     });
 
-    test('dump handles nested objects', () => {
-      const testObj = { outer: { inner: 'value' } };
-      expect(() => {
-        manager.dump(testObj);
-      }).not.toThrow();
+    describe('updateInfraredRemotes', () => {
+      test('updateInfraredRemotes skips non-IR devices', async () => {
+        const devices = [
+          new TuyaDevice({
+            id: 'light_001',
+            name: 'Light',
+            category: 'dj',
+            product_id: 'light_prod',
+            schema: [],
+            status: [],
+          }),
+        ];
+
+        await manager.updateInfraredRemotes(devices);
+        // Should not throw
+        expect(true).toBe(true);
+      });
     });
-  });
-});
+
+  }
+);