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

package/test/platform.test.ts

@@ -1,6 +1,23 @@
 /* eslint-disable no-console */
 import { describe, expect, test, beforeEach, jest } from '@jest/globals';
 import { TuyaPlatform } from '../src/platform';
+import { PlatformAccessory } from 'homebridge';
+import { ExLogger, initLogger } from '../src/shared/util/Logger';
+import { TuyaPluginMode } from '../src/config';
+import LocalDeviceManager from '../src/local/LocalDeviceManager';
+import TuyaHybridDeviceManager from '../src/shared/TuyaHybridDeviceManager';
+import TuyaHomeDeviceManager from '../src/cloud/device/TuyaHomeDeviceManager';
+import TuyaCustomDeviceManager from '../src/cloud/device/TuyaCustomDeviceManager';
+
+// Mock Logger
+const mockLogger: ExLogger = {
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  log: jest.fn(),
+  success: jest.fn(),
+} as unknown as ExLogger;
 
 // Mock Homebridge API
 const mockHAP = {
@@ -11,6 +28,8 @@ const mockHAP = {
   },
 };
 
+const errorStack:any[] = [];
+
 const mockAPI = {
   hap: mockHAP,
   platformAccessory: jest.fn(),
@@ -19,20 +38,15 @@ const mockAPI = {
   on: jest.fn(),
 } as any;
 
-// Mock Logger
-jest.mock('../src/shared/util/Logger', () => ({
-  __esModule: true,
-  default: class Logger {
-    log() {}
-    info() {}
-    warn() {}
-    error() {}
-  },
-  PrefixLogger: class PrefixLogger {
-    constructor(public log: any, public name: string, public debug: boolean) {}
-  },
-}));
-
+jest.mock('jsonschema', () => {
+  return {
+    Validator: (
+      class MockValidator {
+        validate = jest.fn().mockReturnValue({ errors: errorStack });
+      }
+    )
+  };
+});
 // Mock file system
 jest.mock('fs', () => ({
   readFileSync: jest.fn(),
@@ -43,6 +57,10 @@ jest.mock('fs', () => ({
 jest.mock('../src/cloud/api/TuyaOpenAPI', () => {
   return class MockTuyaOpenAPI {
     log = console;
+
+    static getDefaultEndpoint() {
+      return 'mock-endpoint';
+    }
   };
 });
 
@@ -50,34 +68,65 @@ jest.mock('../src/cloud/api/TuyaOpenMQ', () => {
   return class MockTuyaOpenMQ {};
 });
 
-jest.mock('../src/cloud/device/TuyaDeviceManager', () => {
-  return class MockTuyaDeviceManager {};
+jest.mock('../src/cloud/device/TuyaCloudDeviceManager', () => {
+  return class MockTuyaDeviceManager {
+    pullDevices = jest.fn().mockReturnValue([]);
+    updateInfraredRemotes = jest.fn();
+    on = jest.fn();
+    devices = [];
+  };
 });
 
 jest.mock('../src/cloud/device/TuyaCustomDeviceManager', () => {
-  return class MockTuyaCustomDeviceManager {};
+  return class MockTuyaCustomDeviceManager {
+    pullDevices = jest.fn().mockReturnValue([]);
+    updateInfraredRemotes = jest.fn();
+    on = jest.fn();
+    devices = [];
+  };
 });
 
 jest.mock('../src/cloud/device/TuyaHomeDeviceManager', () => {
-  return class MockTuyaHomeDeviceManager {};
+  return class MockTuyaHomeDeviceManager {
+    pullDevices = jest.fn().mockReturnValue([]);
+    updateInfraredRemotes = jest.fn();
+    on = jest.fn();
+    devices = [];
+  };
 });
 
 // Mock Local components
 jest.mock('../src/local/LocalDeviceManager', () => {
-  return class MockLocalDeviceManager {};
+  return class MockLocalDeviceManager {
+    pullDevices = jest.fn().mockReturnValue([]);
+    updateInfraredRemotes = jest.fn();
+    on = jest.fn();
+    devices = [];
+    static isTargetDevice:any = jest.fn(s => true);
+  };
+});
+
+jest.mock('../src/shared/TuyaHybridDeviceManager', () => {
+  return class MockTuyaHybridDeviceManager {
+    pullDevices = jest.fn().mockReturnValue([]);
+    updateInfraredRemotes = jest.fn();
+    on = jest.fn();
+    devices = [];
+  };
 });
 
 // Mock Accessories
-jest.mock('../src/shared/accessories/AccessoryFactory', () => {
+jest.mock('../src/shared/accessory/AccessoryFactory', () => {
   return {
     default: class MockAccessoryFactory {},
   };
 });
 
-jest.mock('../src/shared/util/util', () => ({
-  sanitizeName: (name: string) => name.replace(/[^a-z0-9]/gi, '_'),
-  retry: jest.fn(async (fn: any) => fn()),
-}));
+jest.mock('../src/shared/util/ConfigMigrator', () => {
+  return class ConfigMigrator {
+    migrate(arg:any) { return arg; }
+  }
+});
 
 describe('TuyaPlatform', () => {
   let platform: TuyaPlatform;
@@ -85,18 +134,22 @@ describe('TuyaPlatform', () => {
   let mockLog: any;
 
   beforeEach(() => {
+    jest.clearAllMocks();
+    initLogger(mockLogger);
+
     mockLog = {
       debug: jest.fn(),
       info: jest.fn(),
       warn: jest.fn(),
       error: jest.fn(),
+      success: jest.fn(),
     };
 
     mockConfig = {
       platform: 'TuyaPlatform',
       name: 'Tuya',
       mode: 'cloud',
-      options: {
+      cloud: {
         projectType: '2',
         accessId: 'test_id',
         accessKey: 'test_key',
@@ -109,6 +162,8 @@ describe('TuyaPlatform', () => {
       },
     };
 
+    process.removeAllListeners('uncaughtException');
+    process.removeAllListeners('unhandledRejection');
     platform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
   });
 
@@ -136,8 +191,8 @@ describe('TuyaPlatform', () => {
     });
 
     test('initializes cached accessories array', () => {
-      expect(platform.cachedAccessories).toEqual([]);
-      expect(Array.isArray(platform.cachedAccessories)).toBe(true);
+      expect(platform['platformAccessories']).toEqual(new Map());
+      expect(platform['platformAccessories'] instanceof Map).toBe(true);
     });
 
     test('initializes accessory handlers array', () => {
@@ -155,7 +210,7 @@ describe('TuyaPlatform', () => {
       const localConfig = {
         ...mockConfig,
         mode: 'local',
-        options: undefined,
+        cloud: undefined,
         local: {
           devices: [],
         },
@@ -180,16 +235,16 @@ describe('TuyaPlatform', () => {
   });
 
   describe('configuration validation', () => {
-    test('requires options for cloud mode', () => {
-      const noOptionsConfig = {
+    test('requires cloud for cloud mode', () => {
+      const noCloudConfig = {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'cloud',
-        options: undefined,
+        cloud: undefined,
       };
 
-      const noOptionsPlatform = new TuyaPlatform(mockLog, noOptionsConfig, mockAPI);
-      const isValid = noOptionsPlatform.validate();
+      const noCloudPlatform = new TuyaPlatform(mockLog, noCloudConfig, mockAPI);
+      const isValid = noCloudPlatform.validate();
 
       expect(isValid).toBe(false);
     });
@@ -213,7 +268,7 @@ describe('TuyaPlatform', () => {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'cloud',
-        options: {
+        cloud: {
           projectType: '1',
           endpoint: 'https://openapi.tuyaeu.com',
           accessId: 'id',
@@ -226,7 +281,7 @@ describe('TuyaPlatform', () => {
       };
 
       const cloudPlatform = new TuyaPlatform(mockLog, cloudConfig, mockAPI);
-      expect(cloudPlatform.options.projectType).toBe('1');
+      expect(cloudPlatform.platformConfig!.cloud!.projectType).toBe('1');
     });
 
     test('validates cloud config with projectType 2', () => {
@@ -234,7 +289,7 @@ describe('TuyaPlatform', () => {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'cloud',
-        options: {
+        cloud: {
           projectType: '2',
           accessId: 'id',
           accessKey: 'key',
@@ -248,7 +303,7 @@ describe('TuyaPlatform', () => {
       };
 
       const cloudPlatform = new TuyaPlatform(mockLog, cloudConfig, mockAPI);
-      expect(cloudPlatform.options.projectType).toBe('2');
+      expect(cloudPlatform.platformConfig!.cloud!.projectType).toBe('2');
     });
   });
 
@@ -295,13 +350,13 @@ describe('TuyaPlatform', () => {
     });
 
     test('stores cloud options', () => {
-      expect(platform.options).toBeDefined();
-      expect(platform.options.projectType).toBe('2');
+      expect(platform.platformConfig.cloud).toBeDefined();
+      expect(platform.platformConfig!.cloud!.projectType).toBe('2');
     });
 
     test('accesses credentials from config', () => {
-      expect(platform.options.accessId).toBe('test_id');
-      expect(platform.options.accessKey).toBe('test_key');
+      expect(platform.platformConfig!.cloud!.accessId).toBe('test_id');
+      expect(platform.platformConfig!.cloud!.accessKey).toBe('test_key');
     });
   });
 
@@ -329,38 +384,62 @@ describe('TuyaPlatform', () => {
 
     test('caches accessories', () => {
       const mockAccessory = { UUID: 'uuid-1', displayName: 'Cached Device' };
-      platform.cachedAccessories.push(mockAccessory as any);
+      platform.configureAccessory(mockAccessory as PlatformAccessory);
 
-      expect(platform.cachedAccessories.length).toBe(1);
+      expect(platform['platformAccessories'].size).toBe(1);
     });
 
     test('can restore cached accessories', () => {
       const mockAccessory1 = { UUID: 'uuid-1', displayName: 'Device 1' };
       const mockAccessory2 = { UUID: 'uuid-2', displayName: 'Device 2' };
+      [mockAccessory1, mockAccessory2].forEach(mockAccessory => platform.configureAccessory(mockAccessory as PlatformAccessory));
 
-      platform.cachedAccessories = [mockAccessory1 as any, mockAccessory2 as any];
-
-      expect(platform.cachedAccessories.length).toBe(2);
+      expect(platform['platformAccessories'].size).toBe(2);
     });
   });
 
   describe('device manager initialization', () => {
-    test('can initialize cloud device manager', () => {
+    test('can initialize device manager', () => {
       platform.deviceManager = {} as any;
       expect(platform.deviceManager).toBeDefined();
     });
 
-    test('can initialize local device manager', () => {
-      platform.localDeviceManager = {} as any;
-      expect(platform.localDeviceManager).toBeDefined();
+    test('initialize custom device manager', () => {
+      mockConfig.mode = TuyaPluginMode.cloud;
+      mockConfig.cloud.projectType = '1';
+      const platform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
+      platform.initDevices().then(() => {
+        expect(platform.mode).toBe(mockConfig.mode);
+        expect(platform.deviceManager).toBeInstanceOf(TuyaCustomDeviceManager);
+      });
     });
 
-    test('both managers can coexist in both mode', () => {
-      platform.deviceManager = {} as any;
-      platform.localDeviceManager = {} as any;
+    test('initialize home device manager', () => {
+      mockConfig.mode = TuyaPluginMode.cloud;
+      mockConfig.cloud.projectType = '2';
+      const platform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
+      platform.initDevices().then(() => {
+        expect(platform.mode).toBe(mockConfig.mode);
+        expect(platform.deviceManager).toBeInstanceOf(TuyaHomeDeviceManager);
+      });
+    });
 
-      expect(platform.deviceManager).toBeDefined();
-      expect(platform.localDeviceManager).toBeDefined();
+    test('initialize local device manager', () => {
+      mockConfig.mode = TuyaPluginMode.local;
+      const platform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
+      platform.initDevices().then(() => {
+        expect(platform.mode).toBe(mockConfig.mode);
+        expect(platform.deviceManager).toBeInstanceOf(LocalDeviceManager);
+      });
+    });
+
+    test('initialize both device manager', () => {
+      mockConfig.mode = TuyaPluginMode.both;
+      const platform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
+      platform.initDevices().then(() => {
+        expect(platform.mode).toBe(mockConfig.mode);
+        expect(platform.deviceManager).toBeInstanceOf(TuyaHybridDeviceManager);
+      });
     });
   });
 
@@ -370,7 +449,7 @@ describe('TuyaPlatform', () => {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'both',
-        options: {
+        cloud: {
           projectType: '2',
           accessId: 'id',
           accessKey: 'key',
@@ -388,183 +467,8 @@ describe('TuyaPlatform', () => {
 
       const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
       expect(bothPlatform.mode).toBe('both');
-      expect(bothPlatform.options).toBeDefined();
-      expect(bothPlatform.platformConfig.local).toBeDefined();
-    });
-
-    test('enriches local config with cloud device details', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      // Mock cloud device
-      const mockCloudDevice = {
-        id: 'test-device-123',
-        uuid: 'test-device-123',
-        name: 'Test Device',
-        product_id: 'product-123',
-      } as any;
-
-      // Mock the getDeviceDetails response
-      const mockDeviceDetails = {
-        success: true,
-        result: {
-          id: 'test-device-123',
-          local_key: 'test-local-key-abcdef',
-          ip: '192.168.1.100',
-        },
-      };
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => mockDeviceDetails,
-      } as any;
-
-      // Enrich local config
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      // Verify local config was enriched
-      expect(bothPlatform.platformConfig.local).toBeDefined();
-      if (bothPlatform.platformConfig.local?.devices) {
-        expect(bothPlatform.platformConfig.local.devices.length).toBeGreaterThan(0);
-        
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.tuyaDeviceId).toBe('test-device-123');
-        expect(enrichedDevice.tuyaKey).toBe('test-local-key-abcdef');
-        expect(enrichedDevice.ip).toBe('192.168.1.100');
-      }
-    });
-
-    test('preserves manual local config when enriching', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [
-            {
-              tuyaDeviceId: 'manual-device-456',
-              tuyaKey: 'manual-key-xyz',
-              name: 'Manual Device',
-            },
-          ],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      // Mock cloud device (different from manual one)
-      const mockCloudDevice = {
-        id: 'test-device-123',
-        uuid: 'test-device-123',
-        name: 'Test Device',
-        product_id: 'product-123',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'test-device-123',
-            local_key: 'cloud-key-123',
-            ip: '192.168.1.100',
-          },
-        }),
-      } as any;
-
-      // Enrich local config
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      // Verify local config exists and has devices
-      expect(bothPlatform.platformConfig.local).toBeDefined();
-      if (bothPlatform.platformConfig.local?.devices) {
-        // Verify manual device is still there
-        const manualDevice = bothPlatform.platformConfig.local.devices.find(
-          d => d.tuyaDeviceId === 'manual-device-456'
-        );
-        expect(manualDevice).toBeDefined();
-        expect(manualDevice?.tuyaKey).toBe('manual-key-xyz');
-
-        // Verify new cloud device was added
-        const cloudDevice = bothPlatform.platformConfig.local.devices.find(
-          d => d.tuyaDeviceId === 'test-device-123'
-        );
-        expect(cloudDevice).toBeDefined();
-        expect(cloudDevice?.tuyaKey).toBe('cloud-key-123');
-      }
-    });
-
-    test('skips enrichment if cloud device details unavailable', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'test-device-123',
-        name: 'Test Device',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: false,
-          code: 'NOT_FOUND',
-        }),
-      } as any;
-
-      // Enrich local config
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      // Verify nothing was added (since API failed)
+      expect(bothPlatform.platformConfig.cloud).toBeDefined();
       expect(bothPlatform.platformConfig.local).toBeDefined();
-      if (bothPlatform.platformConfig.local?.devices) {
-        expect(bothPlatform.platformConfig.local.devices.length).toBe(0);
-      }
     });
   });
 
@@ -624,13 +528,135 @@ describe('TuyaPlatform', () => {
     });
   });
 
+  describe('validate', () => {
+    test('local mode without local config', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'local',
+      };
+
+      const spyError = jest.spyOn(mockLog, 'error');
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      const isValid = invalidPlatform.validate();
+
+      expect(isValid).toBe(false);
+      expect(spyError).toHaveBeenCalledWith('mode is "local" but no "local" config block found.');
+    });
+
+    test('both mode without local config', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'both',
+      };
+
+      const spyError = jest.spyOn(mockLog, 'error');
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      const isValid = invalidPlatform.validate();
+
+      expect(isValid).toBe(false);
+      expect(spyError).toHaveBeenCalledWith('mode is "both" but no "local" config block found.');
+    });
+
+    test('cloud mode without cloud config', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+      };
+
+      const spyError = jest.spyOn(mockLog, 'error');
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      const isValid = invalidPlatform.validate();
+
+      expect(isValid).toBe(false);
+      expect(spyError).toHaveBeenCalledWith('Not configured — "cloud" block is required for cloud mode, exit.');
+    });
+
+    test('both mode without cloud config', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'both',
+        local: {}
+      };
+
+      const spyError = jest.spyOn(mockLog, 'error');
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      const isValid = invalidPlatform.validate();
+
+      expect(isValid).toBe(false);
+      expect(spyError).toHaveBeenCalledWith('Not configured — "cloud" block is required for cloud mode, exit.');
+    });
+
+    test('Validator().validate returns error', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+        cloud: { projectType: '1', deviceOverides: [] }
+      };
+
+      const stack = { stack: 'error stack' };
+      errorStack.push(stack);
+
+      const spyError = jest.spyOn(mockLog, 'error');
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      
+      expect(spyError).toHaveBeenCalledWith(stack.stack);
+      errorStack.splice(0, errorStack.length);
+    });
+
+    test('cloud mode with invalid deviceOverrides', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+        cloud: { projectType: '1' }
+      };
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      invalidPlatform.validateDeviceOverrides = jest.fn(() => false);
+      const spyMethod = jest.spyOn(invalidPlatform, 'validateDeviceOverrides');
+      const isValid = invalidPlatform.validate();
+
+      expect(spyMethod).toHaveBeenCalledTimes(1);
+      expect(isValid).toBe(false);
+    });
+
+    test('cloud mode with invalid deviceOverride.schema', () => {
+      const invalidConfig = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+        cloud: { projectType: '1' }
+      };
+
+      const invalidPlatform = new TuyaPlatform(mockLog, invalidConfig, mockAPI);
+      invalidPlatform.validateDeviceOverrides = jest.fn(() => true);
+      invalidPlatform.validateSchema = jest.fn(() => false);
+      const spyMethod1 = jest.spyOn(invalidPlatform, 'validateDeviceOverrides');
+      const spyMethod2 = jest.spyOn(invalidPlatform, 'validateSchema');
+      const isValid = invalidPlatform.validate();
+
+      expect(spyMethod1).toHaveBeenCalledTimes(1);
+      expect(spyMethod2).toHaveBeenCalledTimes(1);
+      expect(isValid).toBe(false);
+    });
+  });
+
   describe('configuration edge cases', () => {
     test('handles missing project type', () => {
       const noProjectTypeConfig = {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'cloud',
-        options: {
+        cloud: {
           accessId: 'id',
           accessKey: 'key',
         },
@@ -657,15 +683,15 @@ describe('TuyaPlatform', () => {
     test('handles weather accessory option', () => {
       const weatherConfig = {
         ...mockConfig,
-        options: {
-          ...mockConfig.options,
+        cloud: {
+          ...mockConfig.cloud,
           generateWeatherAccessory: true,
           weatherAPI: 'openweathermap',
         },
       };
 
       const weatherPlatform = new TuyaPlatform(mockLog, weatherConfig, mockAPI);
-      expect((weatherPlatform.options as any).generateWeatherAccessory).toBe(true);
+      expect((weatherPlatform.platformConfig.cloud as any).generateWeatherAccessory).toBe(true);
     });
   });
 
@@ -684,20 +710,21 @@ describe('TuyaPlatform', () => {
       const platform1 = new TuyaPlatform(mockLog, config1, mockAPI);
       const platform2 = new TuyaPlatform(mockLog, config2, mockAPI);
 
-      platform1.cachedAccessories.push({} as any);
+      platform1.configureAccessory({} as PlatformAccessory);
+
 
-      expect(platform1.cachedAccessories.length).toBe(1);
-      expect(platform2.cachedAccessories.length).toBe(0);
+      expect(platform1['platformAccessories'].size).toBe(1);
+      expect(platform2['platformAccessories'].size).toBe(0);
     });
   });
 
-  describe('API field variations and error handling', () => {
-    test('handles localKey instead of local_key in API response', async () => {
+  describe('device ID consistency and deduplication', () => {
+    test('uses consistent UUID for same device across cloud and local', () => {
       const bothConfig = {
         platform: 'TuyaPlatform',
         name: 'Tuya',
         mode: 'both',
-        options: {
+        cloud: {
           projectType: '2',
           accessId: 'id',
           accessKey: 'key',
@@ -715,595 +742,91 @@ describe('TuyaPlatform', () => {
 
       const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
 
+      // Create mock cloud and local devices with same ID
       const mockCloudDevice = {
-        id: 'test-device-123',
-        uuid: 'test-device-123',
-        name: 'Test Device',
-        product_id: 'product-123',
+        id: 'same-device-id',
+        uuid: 'same-device-id',
+        name: 'Test Device (Cloud)',
       } as any;
 
-      // Response with localKey (camelCase) instead of local_key (snake_case)
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'test-device-123',
-            localKey: 'alternate-format-key',  // camelCase variant
-            ip: '192.168.1.100',
-          },
-        }),
+      const mockLocalDevice = {
+        id: 'same-device-id',
+        uuid: 'same-device-id',
+        name: 'Test Device (Local)',
       } as any;
 
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
+      // Both should map to same UUID
+      const cloudUUID = bothPlatform.api.hap.uuid.generate(mockCloudDevice.id);
+      const localUUID = bothPlatform.api.hap.uuid.generate(mockLocalDevice.id);
 
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.tuyaKey).toBe('alternate-format-key');
-      }
+      expect(cloudUUID).toBe(localUUID);
     });
+  });
 
-    test('handles address field instead of ip in API response', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
+  describe('syncDeviceAndAccessory', () => {
+    test('device config changed', () => {
+      const mockDevice = {
+        id: 'mock-id'
       };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'test-device-456',
-        name: 'Another Device',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'test-device-456',
-            local_key: 'test-key-456',
-            address: '10.0.0.50',  // Uses 'address' instead of 'ip'
-          },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.ip).toBe('10.0.0.50');
-      }
-    });
-
-    test('uses uuid fallback when cloud device id is missing', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        uuid: 'fallback-device-123',
-        name: 'Fallback Device',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            uuid: 'fallback-device-123',
-            local_key: 'fallback-key-123',
-            ip: '192.168.1.101',
+      const mockOldAccessory = {
+        context: { deviceConfigHash: 'hash2' },
+        services: [
+          {
+            UUID: 'service-uuid1',
+            characteristics: [
+              { UUID: 'characteristic-uuid1' },
+              { UUID: 'characteristic-uuid2' },
+              { UUID: 'characteristic-uuid3' },
+            ],
+            removeCharacteristic: jest.fn()
           },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.tuyaDeviceId).toBe('fallback-device-123');
-        expect(enrichedDevice.tuyaKey).toBe('fallback-key-123');
-      }
-    });
-
-    test('propagates cloud category into local config', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'category-device-123',
-        name: 'Category Device',
-        category: 'kg',
-        product_id: 'abc123',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'category-device-123',
-            local_key: 'category-key-123',
-            ip: '192.168.1.102',
-          },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.category).toBe('kg');
-      }
-    });
-
-    test('handles missing local_key gracefully', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'test-device-no-key',
-        name: 'Device Without Local Key',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'test-device-no-key',
-            // No local_key or localKey provided
-            ip: '192.168.1.200',
-          },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      // Device should not be added to local config without local_key
-      if (bothPlatform.platformConfig.local?.devices) {
-        expect(bothPlatform.platformConfig.local.devices.length).toBe(0);
-      }
-    });
-
-    test('handles API timeout with grace', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'test-device-timeout',
-        name: 'Timeout Device',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => {
-          throw new Error('Request timeout');
-        },
-      } as any;
-
-      // Should not throw, but handle gracefully
-      await expect(bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice])).resolves.toBeUndefined();
-      
-      // Local devices should remain empty (timeout treated as error)
-      if (bothPlatform.platformConfig.local?.devices) {
-        expect(bothPlatform.platformConfig.local.devices.length).toBe(0);
-      }
-    });
-  });
-
-  describe('mixed config scenarios', () => {
-    test('updates manual local config with cloud-provided local_key', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [
-            {
-              tuyaDeviceId: 'manual-device-xyz',
-              // User provided device ID but no key
-              name: 'Manual Device No Key',
-            },
-          ],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'manual-device-xyz',
-        name: 'Manual Device No Key',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'manual-device-xyz',
-            local_key: 'cloud-filled-key',
-            ip: '192.168.1.99',
-          },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        expect(enrichedDevice.tuyaDeviceId).toBe('manual-device-xyz');
-        expect(enrichedDevice.tuyaKey).toBe('cloud-filled-key');
-        expect(enrichedDevice.ip).toBe('192.168.1.99');
-        // Original name should be preserved
-        expect(enrichedDevice.name).toBe('Manual Device No Key');
-      }
-    });
-
-    test('does not overwrite existing manual local_key', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [
-            {
-              tuyaDeviceId: 'device-with-manual-key',
-              tuyaKey: 'user-provided-key-123',  // User explicitly set this
-              name: 'Device With Manual Key',
-            },
-          ],
-        },
+          {
+            UUID: 'service-uuid2',
+            characteristics: [
+              { UUID: 'characteristic-uuid1' },
+              { UUID: 'characteristic-uuid3' },
+              { UUID: 'characteristic-uuid4' },
+            ]
+          }
+        ],
+        removeService: jest.fn()
       };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'device-with-manual-key',
-        name: 'Device With Manual Key',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'device-with-manual-key',
-            local_key: 'different-cloud-key',
-            ip: '192.168.1.88',
+      const mockNewAccessory = {
+        services: [
+          {
+            UUID: 'service-uuid1',
+            characteristics: [
+              { UUID: 'characteristic-uuid1' },
+              { UUID: 'characteristic-uuid3' },
+              { UUID: 'characteristic-uuid5' },
+            ]
           },
-        }),
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        // Manual key should be skipped (device has tuyaKey already)
-        expect(enrichedDevice.tuyaKey).toBe('user-provided-key-123');
-      }
-    });
-  });
-
-  describe('multi-device enrichment', () => {
-    test('enriches multiple cloud devices in parallel', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevices = [
-        { id: 'device-1', uuid: 'device-1', name: 'Device 1', product_id: 'prod-1' },
-        { id: 'device-2', uuid: 'device-2', name: 'Device 2', product_id: 'prod-2' },
-        { id: 'device-3', uuid: 'device-3', name: 'Device 3', product_id: 'prod-3' },
-      ] as any;
-
-      const callCount: Record<string, number> = {};
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async (deviceId: string) => {
-          callCount[deviceId] = (callCount[deviceId] || 0) + 1;
-          return {
-            success: true,
-            result: {
-              id: deviceId,
-              local_key: `key-${deviceId}`,
-              ip: `192.168.1.${Math.floor(Math.random() * 254) + 1}`,
-            },
-          };
-        },
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud(mockCloudDevices);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        expect(bothPlatform.platformConfig.local.devices.length).toBe(3);
-        
-        const device1 = bothPlatform.platformConfig.local.devices.find(d => d.tuyaDeviceId === 'device-1');
-        const device2 = bothPlatform.platformConfig.local.devices.find(d => d.tuyaDeviceId === 'device-2');
-        const device3 = bothPlatform.platformConfig.local.devices.find(d => d.tuyaDeviceId === 'device-3');
-        
-        expect(device1?.tuyaKey).toBe('key-device-1');
-        expect(device2?.tuyaKey).toBe('key-device-2');
-        expect(device3?.tuyaKey).toBe('key-device-3');
-      }
-    });
-
-    test('continues enrichment if single device fails', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevices = [
-        { id: 'device-ok-1', uuid: 'device-ok-1', name: 'OK Device 1' },
-        { id: 'device-fail', uuid: 'device-fail', name: 'Failing Device' },
-        { id: 'device-ok-2', uuid: 'device-ok-2', name: 'OK Device 2' },
-      ] as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async (deviceId: string) => {
-          if (deviceId === 'device-fail') {
-            return { success: false, code: 'ERROR' };
+          {
+            UUID: 'service-uuid3',
+            characteristics: [
+              { UUID: 'characteristic-uuid2' },
+              { UUID: 'characteristic-uuid3' },
+              { UUID: 'characteristic-uuid4' },
+            ]
           }
-          return {
-            success: true,
-            result: {
-              id: deviceId,
-              local_key: `key-${deviceId}`,
-              ip: '192.168.1.100',
-            },
-          };
-        },
-      } as any;
-
-      await bothPlatform.enrichLocalConfigFromCloud(mockCloudDevices);
-
-      if (bothPlatform.platformConfig.local?.devices) {
-        // Should have 2 devices (one failed, skipped)
-        expect(bothPlatform.platformConfig.local.devices.length).toBe(2);
-        
-        const hasOk1 = bothPlatform.platformConfig.local.devices.some(d => d.tuyaDeviceId === 'device-ok-1');
-        const hasOk2 = bothPlatform.platformConfig.local.devices.some(d => d.tuyaDeviceId === 'device-ok-2');
-        const hasFailed = bothPlatform.platformConfig.local.devices.some(d => d.tuyaDeviceId === 'device-fail');
-        
-        expect(hasOk1).toBe(true);
-        expect(hasOk2).toBe(true);
-        expect(hasFailed).toBe(false);
-      }
-    });
-  });
-
-  describe('device ID consistency and deduplication', () => {
-    test('uses consistent UUID for same device across cloud and local', () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
-      };
-
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      // Create mock cloud and local devices with same ID
-      const mockCloudDevice = {
-        id: 'same-device-id',
-        uuid: 'same-device-id',
-        name: 'Test Device (Cloud)',
-      } as any;
-
-      const mockLocalDevice = {
-        id: 'same-device-id',
-        uuid: 'same-device-id',
-        name: 'Test Device (Local)',
-      } as any;
-
-      // Both should map to same UUID
-      const cloudUUID = bothPlatform.api.hap.uuid.generate(mockCloudDevice.id);
-      const localUUID = bothPlatform.api.hap.uuid.generate(mockLocalDevice.id);
-
-      expect(cloudUUID).toBe(localUUID);
-    });
-
-    test('enrichment preserves device ID for accessory mapping', async () => {
-      const bothConfig = {
-        platform: 'TuyaPlatform',
-        name: 'Tuya',
-        mode: 'both',
-        options: {
-          projectType: '2',
-          accessId: 'id',
-          accessKey: 'key',
-          countryCode: 1,
-          username: 'user',
-          password: 'pass',
-          appSchema: 'tuyaSmart',
-          generateWeatherAccessory: false,
-          weatherAPI: '',
-        },
-        local: {
-          devices: [],
-        },
+        ]
       };
 
-      const bothPlatform = new TuyaPlatform(mockLog, bothConfig, mockAPI);
-
-      const mockCloudDevice = {
-        id: 'unique-device-id',
-        uuid: 'unique-device-id',
-        name: 'Device',
-        product_id: 'product-123',
-      } as any;
-
-      bothPlatform.deviceManager = {
-        getDeviceDetails: async () => ({
-          success: true,
-          result: {
-            id: 'unique-device-id',
-            local_key: 'test-key',
-            ip: '192.168.1.1',
-          },
-        }),
-      } as any;
+      Object.assign(mockAPI, { updatePlatformAccessories: jest.fn() });
 
-      await bothPlatform.enrichLocalConfigFromCloud([mockCloudDevice]);
+      const mockPlatform = new TuyaPlatform(mockLog, mockConfig, mockAPI);
+      Object.assign(mockPlatform, {
+        deviceManager: { createDeviceConfigHash: jest.fn().mockReturnValue('hash1'), devices: []},
+        addAccessory: jest.fn().mockReturnValue(mockNewAccessory),
+        removeAccessory: jest.fn()
+      });
+      
+      mockPlatform.syncDeviceAndAccessory(mockDevice as any, mockOldAccessory as any);
 
-      if (bothPlatform.platformConfig.local?.devices) {
-        const enrichedDevice = bothPlatform.platformConfig.local.devices[0];
-        // Device ID should be preserved for accessory mapping
-        expect(enrichedDevice.tuyaDeviceId).toBe('unique-device-id');
-      }
+      const mockRemoveService = jest.spyOn(mockOldAccessory, 'removeService');
+      const mockRemoveCharacteristic = jest.spyOn(mockOldAccessory.services[0], 'removeCharacteristic');
+      expect(mockRemoveService).toHaveBeenCalledWith(mockOldAccessory.services[1]);
+      expect(mockRemoveCharacteristic).toHaveBeenCalledWith(mockOldAccessory.services[0].characteristics[1]);
     });
   });
 });