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

package/test/tuyaDiscovery.test.ts

@@ -2,24 +2,17 @@
 import { describe, expect, test, beforeEach, jest } from '@jest/globals';
 import EventEmitter from 'events';
 import TuyaDiscovery, { DiscoveryResult } from '../src/local/TuyaDiscovery';
+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 debug: boolean) {}
-    info() {}
-    warn() {}
-    error() {}
-  },
-}));
+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 dgram
 let mockServers: Record<number, EventEmitter> = {};
@@ -38,17 +31,12 @@ jest.mock('dgram', () => ({
 
 describe('TuyaDiscovery', () => {
   let discovery: TuyaDiscovery;
-  let mockLogger: any;
 
   beforeEach(() => {
-    mockLogger = {
-      log: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-    };
-
-    discovery = new TuyaDiscovery(mockLogger, false);
+    jest.clearAllMocks();
+    initLogger(mockLog);
+
+    discovery = new TuyaDiscovery(false);
   });
 
   describe('initialization', () => {
@@ -62,12 +50,12 @@ describe('TuyaDiscovery', () => {
     });
 
     test('initializes with debug disabled', () => {
-      const disc = new TuyaDiscovery(mockLogger, false);
+      const disc = new TuyaDiscovery(false);
       expect(disc).toBeDefined();
     });
 
     test('initializes with debug enabled', () => {
-      const disc = new TuyaDiscovery(mockLogger, true);
+      const disc = new TuyaDiscovery(true);
       expect(disc).toBeDefined();
     });
 
@@ -361,20 +349,20 @@ describe('TuyaDiscovery', () => {
 
   describe('logging and debugging', () => {
     test('creates logger with debug disabled', () => {
-      const disc = new TuyaDiscovery(mockLogger, false);
+      const disc = new TuyaDiscovery(false);
       expect(disc.log).toBeDefined();
     });
 
     test('creates logger with debug enabled', () => {
-      const disc = new TuyaDiscovery(mockLogger, true);
+      const disc = new TuyaDiscovery(true);
       expect(disc.log).toBeDefined();
     });
   });
 
   describe('multiple discovery instances', () => {
     test('multiple instances maintain separate state', () => {
-      const disc1 = new TuyaDiscovery(mockLogger, false);
-      const disc2 = new TuyaDiscovery(mockLogger, false);
+      const disc1 = new TuyaDiscovery(false);
+      const disc2 = new TuyaDiscovery(false);
 
       disc1['discovered'].set('device_1', '192.168.1.100');
       disc2['discovered'].set('device_2', '192.168.1.101');
@@ -386,8 +374,8 @@ describe('TuyaDiscovery', () => {
     });
 
     test('multiple instances have separate servers', () => {
-      const disc1 = new TuyaDiscovery(mockLogger, false);
-      const disc2 = new TuyaDiscovery(mockLogger, false);
+      const disc1 = new TuyaDiscovery(false);
+      const disc2 = new TuyaDiscovery(false);
 
       disc1.start();
       disc2.start();

package/test/tuyaHomeDeviceManager.test.ts

@@ -1,24 +1,18 @@
 /* eslint-disable no-console */
 import { describe, expect, test, beforeEach, jest } from '@jest/globals';
 import TuyaHomeDeviceManager from '../src/cloud/device/TuyaHomeDeviceManager';
-import TuyaDevice from '../src/cloud/device/TuyaDevice';
+import { TuyaPlatformHomeConfig, TuyaPluginMode } from '../src/config';
+import { ExLogger, initLogger } from '../src/shared/util/Logger';
 
 // Mock Logger
-jest.mock('../src/shared/util/Logger', () => ({
-  __esModule: true,
-  default: class Logger {
-    info() {}
-    warn() {}
-    error() {}
-    debug() {}
-  },
-  PrefixLogger: class PrefixLogger {
-    constructor(public log: any, public name: string, public debug: boolean) {}
-    info() {}
-    warn() {}
-    error() {}
-  },
-}));
+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', () => {
@@ -33,8 +27,11 @@ jest.mock('../src/cloud/api/TuyaOpenMQ', () => {
 describe('TuyaHomeDeviceManager', () => {
   let manager: TuyaHomeDeviceManager;
   let mockAPI: any;
+  let mockConfig: any;
 
   beforeEach(() => {
+    jest.clearAllMocks();
+    initLogger(mockLog);
     mockAPI = {
       log: { log: console.log } as any,
       post: jest.fn(),
@@ -42,7 +39,25 @@ describe('TuyaHomeDeviceManager', () => {
       tokenInfo: { uid: 'test_uid' },
     };
 
-    manager = new TuyaHomeDeviceManager(mockAPI, false);
+    mockConfig = {
+      platform: 'TuyaPlatform',
+      name: 'Tuya',
+      mode: 'cloud',
+      cloud: {
+        projectType: '2',
+        accessId: 'test_id',
+        accessKey: 'test_key',
+        countryCode: 1,
+        username: 'user@example.com',
+        password: 'password',
+        appSchema: 'tuyaSmart',
+        generateWeatherAccessory: false,
+        weatherAPI: '',
+        forceIPv4: false,
+      },
+    };
+
+    manager = new TuyaHomeDeviceManager(mockAPI, mockConfig.cloud, false);
   });
 
   describe('initialization', () => {
@@ -57,7 +72,7 @@ describe('TuyaHomeDeviceManager', () => {
     });
 
     test('supports debug mode', () => {
-      const debugManager = new TuyaHomeDeviceManager(mockAPI, true);
+      const debugManager = new TuyaHomeDeviceManager(mockAPI, mockConfig.cloud, true);
       expect(debugManager.debug).toBe(true);
     });
 
@@ -537,4 +552,80 @@ describe('TuyaHomeDeviceManager', () => {
       }
     });
   });
+
+  describe('get device config', () => {
+    test('resolves device config precedence: device, then product, then global', () => {
+      const config = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+        cloud: {
+          projectType: '2',
+          accessId: 'id',
+          accessKey: 'key',
+          countryCode: 1,
+          username: 'user@example.com',
+          password: 'secret',
+          appSchema: 'tuyaSmart',
+          generateWeatherAccessory: false,
+          weatherAPI: '',
+          deviceOverrides: [
+            { id: 'global', category: 'global-cat', configFor: TuyaPluginMode.cloud },
+            { id: 'prod-1', category: 'product-cat', configFor: TuyaPluginMode.cloud },
+            { id: 'device-1', category: 'device-cat', configFor: TuyaPluginMode.cloud },
+          ],
+        } as TuyaPlatformHomeConfig,
+      };
+  
+      const deviceManager = new TuyaHomeDeviceManager(mockAPI, config.cloud, false);
+  
+      const exact = deviceManager.getDeviceConfig({ id: 'device-1', uuid: 'uuid-1', product_id: 'prod-1' } as any);
+      const byProduct = deviceManager.getDeviceConfig({ id: 'device-2', uuid: 'uuid-2', product_id: 'prod-1' } as any);
+      const fallback = deviceManager.getDeviceConfig({ id: 'device-3', uuid: 'uuid-3', product_id: 'prod-3' } as any);
+  
+      expect(exact?.category).toBe('device-cat');
+      expect(byProduct?.category).toBe('product-cat');
+      expect(fallback?.category).toBe('global-cat');
+    });
+  });
+
+  describe('get device config', () => {
+    test('finds schema config case-insensitively', () => {
+      const config = {
+        platform: 'TuyaPlatform',
+        name: 'Tuya',
+        mode: 'cloud',
+        cloud: {
+          projectType: '2',
+          accessId: 'id',
+          accessKey: 'key',
+          countryCode: 1,
+          username: 'user@example.com',
+          password: 'secret',
+          appSchema: 'tuyaSmart',
+          generateWeatherAccessory: false,
+          weatherAPI: '',
+          deviceOverrides: [
+            {
+              id: 'device-1',
+              schema: [
+                { code: 'switch_1', newCode: 'new_switch_1', hidden: true },
+              ],
+              configFor: TuyaPluginMode.cloud
+            },
+          ],
+        } as TuyaPlatformHomeConfig,
+      };
+
+      const device = { id: 'device-1', uuid: 'device-1', product_id: 'prod-1' } as any;
+
+      const deviceManager = new TuyaHomeDeviceManager(mockAPI, config.cloud, false);
+      const result = deviceManager!.getDeviceSchemaConfig(device, 'SWITCH_1');
+
+      expect(result).toBeDefined();
+      expect(result?.code).toBe('switch_1');
+      expect((result as any).newCode).toBe('new_switch_1');
+      expect(result?.hidden).toBe(true);
+    });
+  });
 });

package/test/tuyaOpenAPI.test.ts

@@ -1,24 +1,22 @@
 /* eslint-disable no-console */
 import { describe, expect, test, beforeEach, jest } from '@jest/globals';
 import TuyaOpenAPI, { TuyaOpenAPIResponse } from '../src/cloud/api/TuyaOpenAPI';
+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() {}
-  },
-  PrefixLogger: class PrefixLogger {
-    constructor(public log: any, public name: string, public debug: boolean) {}
-  },
-}));
+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 https module
 jest.mock('https', () => ({
   request: jest.fn(),
+  Agent: jest.fn(),
 }));
 
 // Mock util
@@ -32,18 +30,12 @@ describe('TuyaOpenAPI', () => {
   let mockLogger: any;
 
   beforeEach(() => {
-    mockLogger = {
-      log: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-    };
+    initLogger(mockLog);
 
     api = new TuyaOpenAPI(
       TuyaOpenAPI.Endpoints.AMERICA,
       'test_access_id',
       'test_access_key',
-      mockLogger,
       'en',
       false
     );
@@ -88,7 +80,8 @@ describe('TuyaOpenAPI', () => {
     });
 
     test('creates logger with API name', () => {
-      expect(api.log).toBeDefined();
+      expect(api['log']).toBeDefined();
+      expect((api['log'] as any)['prefix']).toEqual('TuyaOpenAPI');
     });
   });
 
@@ -150,8 +143,7 @@ describe('TuyaOpenAPI', () => {
       const testApi = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'my_access_id',
-        'my_access_key',
-        mockLogger
+        'my_access_key'
       );
       expect(testApi.accessId).toBe('my_access_id');
     });
@@ -160,8 +152,7 @@ describe('TuyaOpenAPI', () => {
       const testApi = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'my_access_id',
-        'my_access_key',
-        mockLogger
+        'my_access_key'
       );
       expect(testApi.accessKey).toBe('my_access_key');
     });
@@ -170,14 +161,12 @@ describe('TuyaOpenAPI', () => {
       const api1 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'id1',
-        'key1',
-        mockLogger
+        'key1'
       );
       const api2 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'id2',
-        'key2',
-        mockLogger
+        'key2'
       );
 
       expect(api1.accessId).not.toBe(api2.accessId);
@@ -261,8 +250,7 @@ describe('TuyaOpenAPI', () => {
       const apiEU = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.EUROPE,
         'id',
-        'key',
-        mockLogger
+        'key'
       );
       expect(apiEU.endpoint).toBe(TuyaOpenAPI.Endpoints.EUROPE);
     });
@@ -272,8 +260,7 @@ describe('TuyaOpenAPI', () => {
         TuyaOpenAPI.Endpoints.CHINA,
         'id',
         'key',
-        mockLogger,
-        'zh'
+        'zh',
       );
       expect(apiZH.lang).toBe('zh');
     });
@@ -282,8 +269,7 @@ describe('TuyaOpenAPI', () => {
       const apiDefault = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'id',
-        'key',
-        mockLogger
+        'key'
       );
       expect(apiDefault.lang).toBe('en');
     });
@@ -293,9 +279,8 @@ describe('TuyaOpenAPI', () => {
         TuyaOpenAPI.Endpoints.AMERICA,
         'id',
         'key',
-        mockLogger,
         'en',
-        true
+        true,
       );
       expect(apiDebug.debug).toBe(true);
     });
@@ -306,14 +291,12 @@ describe('TuyaOpenAPI', () => {
       const api1 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'id1',
-        'key1',
-        mockLogger
+        'key1'
       );
       const api2 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.EUROPE,
         'id2',
-        'key2',
-        mockLogger
+        'key2'
       );
 
       api1.assetIDArr.push('asset_1');
@@ -328,14 +311,12 @@ describe('TuyaOpenAPI', () => {
       const api1 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.AMERICA,
         'id1',
-        'key1',
-        mockLogger
+        'key1'
       );
       const api2 = new TuyaOpenAPI(
         TuyaOpenAPI.Endpoints.EUROPE,
         'id2',
-        'key2',
-        mockLogger
+        'key2'
       );
 
       api1.deviceArr = [{ id: 'dev1' }];

package/test/tuyaOpenMQ.test.ts

@@ -7,24 +7,14 @@ jest.mock('mqtt', () => ({
 }));
 
 // Mock Logger
-jest.mock('../src/shared/util/Logger', () => ({
-  __esModule: true,
-  default: class Logger {
-    log = jest.fn();
-    info = jest.fn();
-    warn = jest.fn();
-    error = jest.fn();
-    debug = jest.fn();
-  },
-  PrefixLogger: class PrefixLogger {
-    log = jest.fn();
-    info = jest.fn();
-    warn = jest.fn();
-    error = jest.fn();
-    debug = jest.fn();
-    constructor(public logger: any, public name: string, public isDebug: boolean) {}
-  },
-}));
+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 util  
 jest.mock('../src/shared/util/util', () => ({
@@ -38,6 +28,7 @@ jest.mock('../src/cloud/device/TuyaDevice', () => ({
 
 import TuyaOpenMQ from '../src/cloud/api/TuyaOpenMQ';
 import mqtt from 'mqtt';
+import { ExLogger, initLogger } from '../src/shared/util/Logger';
 
 describe('TuyaOpenMQ', () => {
   let mq: TuyaOpenMQ;
@@ -46,6 +37,7 @@ describe('TuyaOpenMQ', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    initLogger(mockLog);
 
     // Create mock MQTT client
     mockClient = {
@@ -64,7 +56,7 @@ describe('TuyaOpenMQ', () => {
       post: jest.fn(),
     } as any;
 
-    mq = new TuyaOpenMQ(mockAPI, undefined, false);
+    mq = new TuyaOpenMQ(mockAPI, false);
   });
 
   describe('initialization', () => {
@@ -274,18 +266,18 @@ describe('TuyaOpenMQ', () => {
     });
 
     test('debug flag can be true', () => {
-      const debugMQ = new TuyaOpenMQ(mockAPI, undefined, true);
+      const debugMQ = new TuyaOpenMQ(mockAPI, true);
       expect(debugMQ.debug).toBe(true);
     });
 
     test('debug flag can be false', () => {
-      const noDebugMQ = new TuyaOpenMQ(mockAPI, undefined, false);
+      const noDebugMQ = new TuyaOpenMQ(mockAPI, false);
       expect(noDebugMQ.debug).toBe(false);
     });
 
     test('link ID is unique between instances', () => {
-      const mq1 = new TuyaOpenMQ(mockAPI, undefined, false);
-      const mq2 = new TuyaOpenMQ(mockAPI, undefined, false);
+      const mq1 = new TuyaOpenMQ(mockAPI, false);
+      const mq2 = new TuyaOpenMQ(mockAPI, false);
 
       expect(mq1.linkId).toBeDefined();
       expect(mq2.linkId).toBeDefined();

package/test/util.test.ts

@@ -1,30 +1,49 @@
-import { describe, expect, test } from '@jest/globals';
+import { describe, expect, jest, test } from '@jest/globals';
 import {
   sanitizeName,
   remap,
   limit,
   deepEqual,
+  deepClone,
   debounce,
   toHapProperty,
+  createDelegate,
 } from '../src/shared/util/util';
 import { TuyaDeviceSchemaProperty } from '../src/cloud/device/TuyaDevice';
 
+// based on https://github.com/homebridge/HAP-NodeJS/blob/843453605a949f50e2e26aa7ab74364edcd8137d/src/lib/util/checkName.ts#L23
+function isValidName(value: any) {
+  if (
+    typeof value === "string" &&
+    !/^[\p{L}\p{N}][\p{L}\p{N}\p{Zs}\u2019'&!._:;()/,-]*[\p{L}\p{N}]$/u.test(value)
+  ) {
+    return false;
+  } else {
+    return true;
+  }
+}
+
 describe('sanitizeName', () => {
   test('removes underscores and collapses to spaces', () => {
     expect(sanitizeName('switch_1')).toBe('switch 1');
+    expect(isValidName(sanitizeName('switch_1'))).toBe(true);
   });
 
   test('preserves ASCII alphanumeric and apostrophes', () => {
     expect(sanitizeName("John's Lamp")).toBe("John's Lamp");
+    expect(isValidName(sanitizeName("John's Lamp"))).toBe(true);
   });
 
   test('preserves accented and non-Latin letters (Unicode letters)', () => {
     expect(sanitizeName('Café')).toBe('Café');
     expect(sanitizeName('Тест123')).toBe('Тест123');
+    expect(isValidName(sanitizeName('Café'))).toBe(true);
+    expect(isValidName(sanitizeName('Тест123'))).toBe(true);
   });
 
   test('preserves CJK characters', () => {
     expect(sanitizeName('中文测试')).toBe('中文测试');
+    expect(isValidName(sanitizeName('中文测试'))).toBe(true);
   });
 
   test('returns undefined if sanitized name is empty or invalid', () => {
@@ -40,25 +59,29 @@ describe('sanitizeName', () => {
   test('handles mixed content correctly', () => {
     expect(sanitizeName('device_123_name')).toBe('device 123 name');
     expect(sanitizeName('My-Device-Name')).toBe('My Device Name');
+    expect(isValidName(sanitizeName('device_123_name'))).toBe(true);
+    expect(isValidName(sanitizeName('My-Device-Name'))).toBe(true);
   });
 
   test('collapses multiple consecutive spaces', () => {
     expect(sanitizeName('name   with    spaces')).toBe('name with spaces');
+    expect(isValidName(sanitizeName('name   with    spaces'))).toBe(true);
   });
 
   test('trims leading and trailing spaces', () => {
     expect(sanitizeName('  My Device  ')).toBe('My Device');
-  });
-
-  test('rejects names that start or end with non-alphanumeric', () => {
-    expect(sanitizeName('_device')).toBeUndefined();
-    expect(sanitizeName('device_')).toBeUndefined();
-    expect(sanitizeName('_device_')).toBeUndefined();
+    expect(isValidName(sanitizeName('  My Device  '))).toBe(true);
   });
 
   test('handles single character names', () => {
     expect(sanitizeName('A')).toBeUndefined(); // Single char fails the regex
     expect(sanitizeName('AB')).toBe('AB');
+    expect(isValidName(sanitizeName('AB'))).toBe(true);
+  });
+
+  test('name with braces', () => {
+    expect(sanitizeName('AB(C)')).toBe('AB C');
+    expect(isValidName(sanitizeName('AB(C)'))).toBe(true);
   });
 });
 
@@ -170,6 +193,25 @@ describe('deepEqual', () => {
   });
 });
 
+describe('deepClone', () => {
+  test('clones nested objects and arrays', () => {
+    const value = { a: 1, b: { c: [2, 3] } };
+    const cloned = deepClone(value);
+
+    expect(cloned).toEqual(value);
+    expect(cloned).not.toBe(value);
+    expect(cloned.b).not.toBe(value.b);
+    expect(cloned.b.c).not.toBe(value.b.c);
+  });
+
+  test('preserves primitives and null', () => {
+    expect(deepClone('test')).toBe('test');
+    expect(deepClone(42)).toBe(42);
+    expect(deepClone(null)).toBeNull();
+    expect(deepClone(undefined)).toBeUndefined();
+  });
+});
+
 describe('debounce', () => {
   test('debounces function execution', (done) => {
     let callCount = 0;
@@ -316,3 +358,61 @@ describe('toHapProperty', () => {
     expect(typeof result).toBe('object');
   });
 });
+
+class DelegateTargetClass {
+  do(x: number): number;
+  do(x: number, y: number): number;
+  do(x: any, y?: any): any {
+    if (y === undefined) {
+      return `original1:${x}`;
+    }
+    return `original2:${x},${y}`;
+  }
+}
+describe("createDelegate with overloaded methods (different arg count)", () => {
+  test("overrides both overload signatures", () => {
+    const worker = new DelegateTargetClass();
+
+    const delegate = createDelegate(worker, {
+      do: ((original: any) => (...args: any[]) => {
+        return `override:${args.join(",")}`;
+      }) as any,
+    });
+
+    expect(delegate.do(10)).toBe("override:10");
+    expect(delegate.do(10, 20)).toBe("override:10,20");
+  });
+
+  test("overrides only the single-argument overload and delegates the two-argument overload", () => {
+    const worker = new DelegateTargetClass();
+
+    const delegate = createDelegate(worker, {
+      do: ((original: any) => (...args: any[]) => {
+        if (args.length === 1) {
+          return `override1:${args[0]}`;
+        }
+        return original(...args);
+      }) as any,
+    });
+
+    expect(delegate.do(10)).toBe("override1:10");
+    expect(delegate.do(10, 20)).toBe("original2:10,20");
+  });
+
+  test("overrides only the two-argument overload and delegates the single-argument overload", () => {
+    const worker = new DelegateTargetClass();
+
+    const delegate = createDelegate(worker, {
+      do: ((original: any) => (...args: any[]) => {
+        if (args.length === 2) {
+          return `override2:${args[0]},${args[1]}`;
+        }
+        return original(...args);
+      }) as any,
+    });
+
+    expect(delegate.do(10)).toBe("original1:10");
+    expect(delegate.do(10, 20)).toBe("override2:10,20");
+  });
+
+});