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

package/test/light.test.ts

@@ -0,0 +1,250 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import Logger, { initLogger } from '../src/shared/util/Logger';
+import { configureLight } from '../src/shared/accessory/characteristic/Light';
+import { TuyaDeviceSchemaType } from '../src/cloud/device/TuyaDevice';
+
+// Mock Logger
+const mockLogger: Logger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+} as unknown as Logger;
+
+describe('Light Characteristic', () => {
+    let accessoryMock = {
+        getService: jest.fn(),
+        addService: jest.fn(),
+        removeService: jest.fn(),
+        log: mockLogger,
+        deviceManager: {
+            getDevice: jest.fn(),
+            enableAdaptiveLighting: jest.fn(),
+        },
+        Characteristic: {
+            On: jest.fn(),
+            Brightness: jest.fn(),
+            ColorTemperature: jest.fn(),
+            Hue: jest.fn(),
+            Saturation: jest.fn(),
+        },
+        Service: {
+            Lightbulb: jest.fn(),
+            Switch: jest.fn(),
+        },
+    } as unknown as any;
+    let serviceMock = {
+        getCharacteristic: jest.fn().mockReturnValue({
+            onGet: jest.fn().mockReturnThis(),
+            onSet: jest.fn().mockReturnThis(),
+            setProps: jest.fn(),
+        }),
+    } as unknown as any;
+
+    beforeEach(() => {
+        jest.resetModules();
+        initLogger(mockLogger);
+    });
+
+    describe('ensureHSVProperty', () => {
+        let spyLogDebug = jest.spyOn(mockLogger, 'debug').mockImplementation(() => {});
+
+        beforeEach(() => {
+            jest.resetModules();
+            spyLogDebug.mockClear();
+        });
+
+        test('color schema with defined property', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = {
+                code: 'color',
+                type: TuyaDeviceSchemaType.Json,
+                property: {
+                    h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                    s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                    v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                },
+            } as any;
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogDebug).toHaveBeenCalledWith('hsvProperty: %O', colorSchema.property);
+        });
+
+        test('color schema without defined property but mode includes colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: TuyaDeviceSchemaType.Json } as any; // No property
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogDebug).toHaveBeenCalledWith('hsvProperty: %O', {
+                h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+            });
+            expect(colorSchema.property).toEqual({
+                h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+            });
+        });
+
+        test('color schema without defined property and mode does not include colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: TuyaDeviceSchemaType.Json } as any; // No property
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogDebug).toHaveBeenCalledWith('hsvProperty: %O', {});
+            expect(colorSchema.property).toBeUndefined();
+        });
+
+        test('color schema with non JSON type but with defined property includes colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = {
+                code: 'color',
+                type: 'unsupported',
+                property: {
+                    h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                    s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                    v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                },
+            } as any;
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogDebug).toHaveBeenCalledWith('hsvProperty: %O', colorSchema.property);
+        });
+    });
+
+    describe('getLightType', () => {
+        let spyLogInfo = jest.spyOn(mockLogger, 'info').mockImplementation(() => {});
+
+        beforeEach(() => {
+            jest.resetModules();
+            spyLogInfo.mockClear();
+        });
+
+        test('Unknown light type when no schemas are provided', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            configureLight(accessoryMock, serviceMock, onSchema, undefined, tempSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'Unknown');
+        });
+
+        test('Normal light type when only on schema is provided', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'Normal');
+        });
+
+        test('CW light type when on and temp schemas are provided', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'CW');
+        });
+
+        test('RGB light type when on and color schemas are provided', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const colorSchema = {
+                code: 'color',
+                type: TuyaDeviceSchemaType.Json,
+                property: {
+                    h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                    s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                    v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                },
+            } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, undefined, undefined, colorSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'RGB');
+        });
+
+        test('RGBC light type when on, color, and mode schemas are provided with mode including colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = {
+                code: 'color',
+                type: TuyaDeviceSchemaType.Json,
+                property: {
+                    h: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 360, scale: 0 },
+                    s: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                    v: { type: TuyaDeviceSchemaType.Integer, min: 0, max: 1000, scale: 0 },
+                },
+            } as any;
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, undefined, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'RGBC');
+        });
+
+        test('RGBCW light type', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: TuyaDeviceSchemaType.Json, property: { h: {}, s: {}, v: {} } } as any;
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'RGBCW');
+        });
+
+        test('RGBCW light type with JSON color schema without property but mode includes colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: TuyaDeviceSchemaType.Json } as any; // No property
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'RGBCW');
+        });
+
+        test('RGBCW light type with JSON color schema without property and mode does not include colour', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: TuyaDeviceSchemaType.Json } as any; // No property
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'CW');
+        });
+
+        test('RGBCW light type with non JSON color schema', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: 'unsupported' } as any; // Unsupported type
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'CW');
+        });
+
+        test('RGBCW light type with non JSON with property color schema', () => {
+            const onSchema = { code: 'on', type: TuyaDeviceSchemaType.Boolean } as any;
+            const brightSchema = { code: 'bright', type: TuyaDeviceSchemaType.Integer } as any;
+            const tempSchema = { code: 'temp', type: TuyaDeviceSchemaType.Integer } as any;
+            const colorSchema = { code: 'color', type: 'unsupported', property: { h: {}, s: {}, v: {} } } as any; // Unsupported type but has property
+            const modeSchema = { code: 'mode', type: TuyaDeviceSchemaType.Enum, property: { range: ['colour', 'white'] } } as any;
+
+            configureLight(accessoryMock, serviceMock, onSchema, brightSchema, tempSchema, colorSchema, modeSchema);
+            expect(spyLogInfo).toHaveBeenCalledWith('Light type: %s', 'RGBCW');
+        });
+
+    });
+});

package/test/localDevice.test.ts

@@ -3,37 +3,7 @@
 import { describe, expect, test, beforeEach, afterEach, jest } from '@jest/globals';
 import EventEmitter from 'events';
 import LocalDevice, { LocalDeviceContext } from '../src/local/LocalDevice';
-
-// 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 prefix: string, public debugMode: boolean) {}
-    debug(message?: any, ...args: any[]) {
-      if (this.debugMode) {
-        this.log.info((this.prefix ? `[${this.prefix}] ` : '') + message, ...args);
-      } else {
-        this.log.debug((this.prefix ? `[${this.prefix}] ` : '') + message, ...args);
-      }
-    }
-    info(message?: any, ...args: any[]) {
-      this.log.info((this.prefix ? `[${this.prefix}] ` : '') + message, ...args);
-    }
-    warn(message?: any, ...args: any[]) {
-      this.log.warn((this.prefix ? `[${this.prefix}] ` : '') + message, ...args);
-    }
-    error(message?: any, ...args: any[]) {
-      this.log.error((this.prefix ? `[${this.prefix}] ` : '') + message, ...args);
-    }
-  },
-}));
+import { initLogger } from '../src/shared/util/Logger';
 
 // Mock Protocol
 const mockProtocol = {
@@ -71,6 +41,7 @@ describe('LocalDevice', () => {
       error: jest.fn(),
       debug: jest.fn(),
     };
+    initLogger(mockLogger);
 
     context = {
       id: 'device_001',
@@ -89,7 +60,7 @@ describe('LocalDevice', () => {
     mockSocket.destroy = jest.fn();
     mockSocket.removeAllListeners = jest.fn();
 
-    device = new LocalDevice(context, mockLogger);
+    device = new LocalDevice(context);
   });
 
   afterEach(() => {
@@ -107,7 +78,7 @@ describe('LocalDevice', () => {
 
     test('sets default port if not provided', () => {
       const contextNoPort = { ...context, port: undefined };
-      const dev = new LocalDevice(contextNoPort, mockLogger);
+      const dev = new LocalDevice(contextNoPort);
 
       expect(dev).toBeDefined();
       expect(dev.connected).toBe(false);
@@ -115,14 +86,14 @@ describe('LocalDevice', () => {
 
     test('sets default pingGap if not provided', () => {
       const contextNoPingGap = { ...context, pingGap: undefined };
-      const dev = new LocalDevice(contextNoPingGap, mockLogger);
+      const dev = new LocalDevice(contextNoPingGap);
 
       expect(dev).toBeDefined();
     });
 
     test('sets default connectTimeout if not provided', () => {
       const contextNoTimeout = { ...context, connectTimeout: undefined };
-      const dev = new LocalDevice(contextNoTimeout, mockLogger);
+      const dev = new LocalDevice(contextNoTimeout);
 
       expect(dev).toBeDefined();
     });
@@ -299,21 +270,21 @@ describe('LocalDevice', () => {
   describe('protocol handling', () => {
     test('creates protocol for version 3.5', () => {
       const ctxV35 = { ...context, version: '3.5' };
-      const devV35 = new LocalDevice(ctxV35, mockLogger);
+      const devV35 = new LocalDevice(ctxV35);
 
       expect(devV35['protocol']).toBeDefined();
     });
 
     test('creates protocol for version 3.1', () => {
       const ctxV31 = { ...context, version: '3.1' };
-      const devV31 = new LocalDevice(ctxV31, mockLogger);
+      const devV31 = new LocalDevice(ctxV31);
 
       expect(devV31['protocol']).toBeDefined();
     });
 
     test('creates protocol for version 3.4', () => {
       const ctxV34 = { ...context, version: '3.4' };
-      const devV34 = new LocalDevice(ctxV34, mockLogger);
+      const devV34 = new LocalDevice(ctxV34);
 
       expect(devV34['protocol']).toBeDefined();
     });
@@ -349,7 +320,7 @@ describe('LocalDevice', () => {
 
     test('creates device logger with context', () => {
       const ctxNoName = { ...context, name: undefined };
-      const devNoName = new LocalDevice(ctxNoName, mockLogger);
+      const devNoName = new LocalDevice(ctxNoName);
 
       expect(devNoName.log).toBeDefined();
     });
@@ -358,21 +329,21 @@ describe('LocalDevice', () => {
   describe('connection configuration', () => {
     test('uses custom port if provided', () => {
       const ctxCustomPort = { ...context, port: 8888 };
-      const devCustomPort = new LocalDevice(ctxCustomPort, mockLogger);
+      const devCustomPort = new LocalDevice(ctxCustomPort);
 
       expect(devCustomPort['context'].port).toBe(8888);
     });
 
     test('uses custom pingGap if provided', () => {
       const ctxCustomPing = { ...context, pingGap: 15 };
-      const devCustomPing = new LocalDevice(ctxCustomPing, mockLogger);
+      const devCustomPing = new LocalDevice(ctxCustomPing);
 
       expect(devCustomPing['context'].pingGap).toBe(15);
     });
 
     test('uses custom connectTimeout if provided', () => {
       const ctxCustomTimeout = { ...context, connectTimeout: 60 };
-      const devCustomTimeout = new LocalDevice(ctxCustomTimeout, mockLogger);
+      const devCustomTimeout = new LocalDevice(ctxCustomTimeout);
 
       expect(devCustomTimeout['context'].connectTimeout).toBe(60);
     });
@@ -381,7 +352,7 @@ describe('LocalDevice', () => {
   describe('device types', () => {
     test('handles light device', () => {
       const lightContext = { ...context, id: 'light_001', name: 'Smart Light' };
-      const light = new LocalDevice(lightContext, mockLogger);
+      const light = new LocalDevice(lightContext);
 
       expect(light['context'].id).toBe('light_001');
       expect(light['context'].name).toBe('Smart Light');
@@ -389,14 +360,14 @@ describe('LocalDevice', () => {
 
     test('handles switch device', () => {
       const switchContext = { ...context, id: 'switch_001', name: 'Smart Switch' };
-      const switchDev = new LocalDevice(switchContext, mockLogger);
+      const switchDev = new LocalDevice(switchContext);
 
       expect(switchDev['context'].id).toBe('switch_001');
     });
 
     test('handles outlet device', () => {
       const outletContext = { ...context, id: 'outlet_001', name: 'Smart Outlet' };
-      const outlet = new LocalDevice(outletContext, mockLogger);
+      const outlet = new LocalDevice(outletContext);
 
       expect(outlet['context'].id).toBe('outlet_001');
     });
@@ -429,8 +400,8 @@ describe('LocalDevice', () => {
         connectTimeout: 30,
       };
 
-      deviceV34 = new LocalDevice(contextV34, mockLogger);
-      deviceV35 = new LocalDevice(contextV35, mockLogger);
+      deviceV34 = new LocalDevice(contextV34);
+      deviceV35 = new LocalDevice(contextV35);
     });
 
     afterEach(() => {
@@ -463,7 +434,7 @@ describe('LocalDevice', () => {
       const localNonce = Buffer.from('0123456789abcdef');
       const remoteNonce = Buffer.from('fedcba9876543210');
       const invalidHmac = Buffer.alloc(32); // all zeros - definitely wrong
-      const step2Payload = Buffer.concat([remoteNonce, invalidHmac]);
+      const step2Payload = Buffer.concat([remoteNonce as Uint8Array, invalidHmac as Uint8Array]);
 
       deviceV34['tmpLocalKey'] = localNonce;
       deviceV34['socket'] = mockSocket;
@@ -543,8 +514,8 @@ describe('LocalDevice', () => {
         port: 6668,
       };
 
-      deviceV34 = new LocalDevice(contextV34, mockLogger);
-      deviceV35 = new LocalDevice(contextV35, mockLogger);
+      deviceV34 = new LocalDevice(contextV34);
+      deviceV35 = new LocalDevice(contextV35);
     });
 
     afterEach(() => {