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

package/test/util.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, test } from '@jest/globals';
+import {
+  sanitizeName,
+  remap,
+  limit,
+  deepEqual,
+  debounce,
+  toHapProperty,
+} from '../src/shared/util/util';
+import { TuyaDeviceSchemaProperty } from '../src/cloud/device/TuyaDevice';
+
+describe('sanitizeName', () => {
+  test('removes underscores and collapses to spaces', () => {
+    expect(sanitizeName('switch_1')).toBe('switch 1');
+  });
+
+  test('preserves ASCII alphanumeric and apostrophes', () => {
+    expect(sanitizeName("John's Lamp")).toBe("John's Lamp");
+  });
+
+  test('preserves accented and non-Latin letters (Unicode letters)', () => {
+    expect(sanitizeName('Café')).toBe('Café');
+    expect(sanitizeName('Тест123')).toBe('Тест123');
+  });
+
+  test('preserves CJK characters', () => {
+    expect(sanitizeName('中文测试')).toBe('中文测试');
+  });
+
+  test('returns undefined if sanitized name is empty or invalid', () => {
+    expect(sanitizeName('@@@')).toBeUndefined();
+    expect(sanitizeName('  !!!  ')).toBeUndefined();
+  });
+
+  test('returns undefined for null or empty string', () => {
+    expect(sanitizeName('')).toBeUndefined();
+    expect(sanitizeName(undefined)).toBeUndefined();
+  });
+
+  test('handles mixed content correctly', () => {
+    expect(sanitizeName('device_123_name')).toBe('device 123 name');
+    expect(sanitizeName('My-Device-Name')).toBe('My Device Name');
+  });
+
+  test('collapses multiple consecutive spaces', () => {
+    expect(sanitizeName('name   with    spaces')).toBe('name with spaces');
+  });
+
+  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();
+  });
+
+  test('handles single character names', () => {
+    expect(sanitizeName('A')).toBeUndefined(); // Single char fails the regex
+    expect(sanitizeName('AB')).toBe('AB');
+  });
+});
+
+describe('remap', () => {
+  test('remaps value from one range to another', () => {
+    // Remap 5 from [0, 10] to [0, 100]
+    const result = remap(5, 0, 10, 0, 100);
+    expect(result).toBe(50);
+  });
+
+  test('remaps 0 correctly', () => {
+    const result = remap(0, 0, 10, 0, 100);
+    expect(result).toBe(0);
+  });
+
+  test('remaps maximum value correctly', () => {
+    const result = remap(10, 0, 10, 0, 100);
+    expect(result).toBe(100);
+  });
+
+  test('remaps to negative range', () => {
+    const result = remap(5, 0, 10, -100, 0);
+    expect(result).toBe(-50);
+  });
+
+  test('remaps float values', () => {
+    const result = remap(2.5, 0, 5, 0, 100);
+    expect(result).toBe(50);
+  });
+
+  test('handles identical source and destination ranges', () => {
+    const result = remap(5, 0, 10, 0, 10);
+    expect(result).toBe(5);
+  });
+});
+
+describe('limit', () => {
+  test('limits value within range', () => {
+    expect(limit(50, 0, 100)).toBe(50);
+  });
+
+  test('clamps value below minimum', () => {
+    expect(limit(-10, 0, 100)).toBe(0);
+  });
+
+  test('clamps value above maximum', () => {
+    expect(limit(150, 0, 100)).toBe(100);
+  });
+
+  test('handles exact boundaries', () => {
+    expect(limit(0, 0, 100)).toBe(0);
+    expect(limit(100, 0, 100)).toBe(100);
+  });
+
+  test('handles negative ranges', () => {
+    expect(limit(-50, -100, 0)).toBe(-50);
+    expect(limit(-150, -100, 0)).toBe(-100);
+    expect(limit(50, -100, 0)).toBe(0);
+  });
+
+  test('handles float values', () => {
+    expect(limit(50.5, 0, 100)).toBe(50.5);
+    expect(limit(100.5, 0, 100)).toBe(100);
+  });
+});
+
+describe('deepEqual', () => {
+  test('returns true for equal primitives', () => {
+    expect(deepEqual(5, 5)).toBe(true);
+    expect(deepEqual('test', 'test')).toBe(true);
+    expect(deepEqual(true, true)).toBe(true);
+  });
+
+  test('returns false for different primitives', () => {
+    expect(deepEqual(5, 10)).toBe(false);
+    expect(deepEqual('test', 'other')).toBe(false);
+  });
+
+  test('returns true for equal objects', () => {
+    const obj1 = { a: 1, b: 2 };
+    const obj2 = { a: 1, b: 2 };
+    expect(deepEqual(obj1, obj2)).toBe(true);
+  });
+
+  test('returns false for different objects', () => {
+    const obj1 = { a: 1, b: 2 };
+    const obj2 = { a: 1, b: 3 };
+    expect(deepEqual(obj1, obj2)).toBe(false);
+  });
+
+  test('returns true for equal arrays', () => {
+    expect(deepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+  });
+
+  test('returns false for different arrays', () => {
+    expect(deepEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+  });
+
+  test('returns true for deeply nested equal structures', () => {
+    const obj1 = { a: { b: { c: 1 } } };
+    const obj2 = { a: { b: { c: 1 } } };
+    expect(deepEqual(obj1, obj2)).toBe(true);
+  });
+
+  test('handles null and undefined', () => {
+    expect(deepEqual(null, null)).toBe(true);
+    expect(deepEqual(undefined, undefined)).toBe(true);
+    expect(deepEqual(null, undefined)).toBe(false);
+  });
+});
+
+describe('debounce', () => {
+  test('debounces function execution', (done) => {
+    let callCount = 0;
+    const fn = jest.fn(() => {
+      callCount++;
+    });
+    const debounced = debounce(fn, 100);
+
+    debounced();
+    debounced();
+    debounced();
+
+    expect(fn).not.toHaveBeenCalled();
+
+    setTimeout(() => {
+      expect(fn).toHaveBeenCalledTimes(1);
+      expect(callCount).toBe(1);
+      done();
+    }, 150);
+  });
+
+  test('resets debounce timer on each call', (done) => {
+    let callCount = 0;
+    const fn = jest.fn(() => {
+      callCount++;
+    });
+    const debounced = debounce(fn, 50);
+
+    debounced();
+    setTimeout(() => debounced(), 25);
+    setTimeout(() => debounced(), 50);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    setTimeout(() => {
+      expect(fn).toHaveBeenCalledTimes(1);
+      done();
+    }, 150);
+  });
+
+  test('preserves function return type (though debounced returns void)', () => {
+    const fn = (...args: unknown[]) => {
+      const x = args[0] as number;
+      return x * 2;
+    };
+    const debounced = debounce(fn, 100);
+
+    // Debounced functions return void
+    const result = debounced(5);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe('toHapProperty', () => {
+  test('converts min property', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: 0,
+      max: 100,
+      scale: 0,
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.minValue).toBeDefined();
+    expect(result.minValue).toBe(0);
+  });
+
+  test('converts max property', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: 0,
+      max: 100,
+      scale: 0,
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.maxValue).toBeDefined();
+    expect(result.maxValue).toBe(100);
+  });
+
+  test('converts step property', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: 0,
+      max: 100,
+      scale: 1,
+      step: 10,
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.minStep).toBeDefined();
+    expect(result.minStep).toBe(1); // 10 / 10^1 = 1
+  });
+
+  test('converts range property to validValues', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      range: ['off', 'on', 'auto'],
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.validValues).toBeDefined();
+    expect(result.validValues).toEqual(['off', 'on', 'auto']);
+  });
+
+  test('applies scale factor correctly', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: 0,
+      max: 10000,
+      scale: 2,
+      step: 100,
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.minValue).toBe(0); // 0 / 100 = 0
+    expect(result.maxValue).toBe(100); // 10000 / 100 = 100
+    expect(result.minStep).toBe(1); // 100 / 100 = 1
+  });
+
+  test('clamps values to HAP limits', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: -500,
+      max: 500,
+      scale: 0,
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.minValue).toBeGreaterThanOrEqual(-273.15); // Absolute zero clamping
+  });
+
+  test('preserves other properties', () => {
+    const property: TuyaDeviceSchemaProperty = {
+      min: 0,
+      max: 100,
+      scale: 0,
+      unit: '°C',
+    };
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result.unit).toBe('°C');
+  });
+
+  test('handles empty properties object', () => {
+    const property: TuyaDeviceSchemaProperty = {};
+    const result = toHapProperty(property) as Record<string, any>;
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('object');
+  });
+});

package/test/util.ts

@@ -1,13 +1,14 @@
+import { expect } from '@jest/globals';
 import fs from 'fs';
 import { PLATFORM_NAME } from '../src/settings';
 import { TuyaPlatformConfig } from '../src/config';
-import TuyaDevice, { TuyaDeviceSchema } from '../src/device/TuyaDevice';
-import { TuyaOpenAPIResponse } from '../src/core/TuyaOpenAPI';
+import TuyaDevice, { TuyaDeviceSchema } from '../src/cloud/device/TuyaDevice';
+import { TuyaOpenAPIResponse } from '../src/cloud/api/TuyaOpenAPI';
 
 const file = fs.readFileSync(`${process.env.HOME}/.homebridge-dev/config.json`);
 const { platforms } = JSON.parse(file.toString());
 
-export const config: TuyaPlatformConfig = platforms.find(platform => platform.platform === PLATFORM_NAME);
+export const config: TuyaPlatformConfig = platforms.find((platform: any) => platform.platform === PLATFORM_NAME);
 
 export function expectDevice(device: TuyaDevice) {
   // console.debug(JSON.stringify(device));

package/test/zigbee/ChildPayloadUtility.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from '@jest/globals';
+import { ChildPayloadUtility } from '../../src/local/protocol/ChildPayloadUtility';
+
+describe('ChildPayloadUtility', () => {
+
+  // ── isValidCid ─────────────────────────────────────────────────────────────
+
+  describe('isValidCid', () => {
+    it('accepts a valid lowercase 16-hex-char CID', () => {
+      expect(ChildPayloadUtility.isValidCid('0011223344556601')).toBe(true);
+    });
+
+    it('accepts a valid uppercase 16-hex-char CID', () => {
+      expect(ChildPayloadUtility.isValidCid('AABBCCDDEEFF0011')).toBe(true);
+    });
+
+    it('accepts a mixed-case 16-hex-char CID', () => {
+      expect(ChildPayloadUtility.isValidCid('0011aAbBcCdDeEfF')).toBe(true);
+    });
+
+    it('rejects a CID that is too short', () => {
+      expect(ChildPayloadUtility.isValidCid('001122334455660')).toBe(false);
+    });
+
+    it('rejects a CID that is too long', () => {
+      expect(ChildPayloadUtility.isValidCid('00112233445566011')).toBe(false);
+    });
+
+    it('rejects a CID containing non-hex characters', () => {
+      expect(ChildPayloadUtility.isValidCid('0011223344556GHI')).toBe(false);
+    });
+
+    it('rejects an empty string', () => {
+      expect(ChildPayloadUtility.isValidCid('')).toBe(false);
+    });
+  });
+
+  // ── prepareChildPayload ────────────────────────────────────────────────────
+
+  describe('prepareChildPayload', () => {
+    const cid = '0011223344556601';
+    const dps = { '1': true, '2': 100 };
+
+    it('v3.3: returns { cid, dps } envelope', () => {
+      const result = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.3');
+      expect(result).toEqual({ cid, dps });
+    });
+
+    it('v3.4: returns { protocol:5, data:{ cid, dps } } envelope', () => {
+      const result = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.4');
+      expect(result).toEqual({ protocol: 5, data: { cid, dps } });
+    });
+
+    it('v3.5: returns { protocol:5, data:{ cid, dps } } envelope', () => {
+      const result = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.5');
+      expect(result).toEqual({ protocol: 5, data: { cid, dps } });
+    });
+
+    it('v3.3: preserves empty dps object', () => {
+      const result = ChildPayloadUtility.prepareChildPayload(cid, {}, '3.3');
+      expect(result).toEqual({ cid, dps: {} });
+    });
+
+    it('v3.4: preserves complex dps values', () => {
+      const complexDps = { '1': true, '24': 'colour', '25': '0064010200006464000000' };
+      const result = ChildPayloadUtility.prepareChildPayload(cid, complexDps, '3.4');
+      expect((result as any).data.dps).toEqual(complexDps);
+    });
+
+    it('throws on an invalid CID', () => {
+      expect(() => ChildPayloadUtility.prepareChildPayload('invalid', dps, '3.3'))
+        .toThrow('Invalid Zigbee CID');
+    });
+
+    it('throws on a CID that is too short', () => {
+      expect(() => ChildPayloadUtility.prepareChildPayload('0011223344', dps, '3.3'))
+        .toThrow('Invalid Zigbee CID');
+    });
+  });
+
+  // ── prepareChildQueryPayload ───────────────────────────────────────────────
+
+  describe('prepareChildQueryPayload', () => {
+    const cid = '0011223344556601';
+
+    it('v3.3: returns { cid, dps:{} }', () => {
+      const result = ChildPayloadUtility.prepareChildQueryPayload(cid, '3.3');
+      expect(result).toEqual({ cid, dps: {} });
+    });
+
+    it('v3.4: returns { protocol:5, data:{ cid, dps:{} } }', () => {
+      const result = ChildPayloadUtility.prepareChildQueryPayload(cid, '3.4');
+      expect(result).toEqual({ protocol: 5, data: { cid, dps: {} } });
+    });
+
+    it('v3.5: returns { protocol:5, data:{ cid, dps:{} } }', () => {
+      const result = ChildPayloadUtility.prepareChildQueryPayload(cid, '3.5');
+      expect(result).toEqual({ protocol: 5, data: { cid, dps: {} } });
+    });
+
+    it('throws on an invalid CID', () => {
+      expect(() => ChildPayloadUtility.prepareChildQueryPayload('bad!', '3.3'))
+        .toThrow('Invalid Zigbee CID');
+    });
+  });
+
+  // ── extractChildData ────────────────────────────────────────────────────────
+
+  describe('extractChildData', () => {
+    it('v3.3: extracts cid + dps from { gwId, cid, dps }', () => {
+      const payload = {
+        gwId: 'parent_gw',
+        cid: '0011223344556601',
+        dps: { '1': true },
+      };
+      const result = ChildPayloadUtility.extractChildData(payload);
+      expect(result).toEqual({
+        childId: '0011223344556601',
+        dps: { '1': true },
+      });
+    });
+
+    it('v3.3: extracts when gwId is absent (minimal format)', () => {
+      const payload = { cid: '0011223344556601', dps: { '2': 50 } };
+      const result = ChildPayloadUtility.extractChildData(payload);
+      expect(result).toEqual({ childId: '0011223344556601', dps: { '2': 50 } });
+    });
+
+    it('v3.4: extracts from { protocol:5, data:{ cid, dps } }', () => {
+      const payload = {
+        protocol: 5,
+        data: { cid: '0011223344556601', dps: { '1': false } },
+      };
+      expect(ChildPayloadUtility.extractChildData(payload)).toEqual({
+        childId: '0011223344556601',
+        dps: { '1': false },
+      });
+    });
+
+    it('v3.5: extracts from { protocol:5, data:{ cid, dps } }', () => {
+      const payload = {
+        protocol: 5,
+        data: { cid: 'aabbccddeeff0011', dps: { '24': 'colour' } },
+      };
+      expect(ChildPayloadUtility.extractChildData(payload)).toEqual({
+        childId: 'aabbccddeeff0011',
+        dps: { '24': 'colour' },
+      });
+    });
+
+    it('returns null for a bare { dps } payload (regular device update)', () => {
+      const payload = { devId: 'parent_id', dps: { '1': true } };
+      expect(ChildPayloadUtility.extractChildData(payload)).toBeNull();
+    });
+
+    it('returns null for a non-child v3.4+ update { protocol:5, data:{ devId, dps } }', () => {
+      // No cid field in data
+      const payload = {
+        protocol: 5,
+        data: { devId: 'some_device', dps: { '1': true } },
+      };
+      expect(ChildPayloadUtility.extractChildData(payload)).toBeNull();
+    });
+
+    it('returns null for an empty payload', () => {
+      expect(ChildPayloadUtility.extractChildData({})).toBeNull();
+    });
+
+    it('ignores protocol:4 envelope (not child routing)', () => {
+      const payload = { protocol: 4, data: { cid: '0011223344556601', dps: {} } };
+      expect(ChildPayloadUtility.extractChildData(payload)).toBeNull();
+    });
+  });
+
+  // ── round-trip: prepare then extract ──────────────────────────────────────
+
+  describe('round-trip consistency', () => {
+    const cid = 'aabbccddeeff0011';
+    const dps = { '1': true, '2': 255 };
+
+    it('v3.3 prepare → extract yields same cid and dps', () => {
+      const prepared = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.3');
+      const extracted = ChildPayloadUtility.extractChildData(prepared);
+      expect(extracted).toEqual({ childId: cid, dps });
+    });
+
+    it('v3.4 prepare → extract yields same cid and dps', () => {
+      const prepared = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.4');
+      const extracted = ChildPayloadUtility.extractChildData(prepared);
+      expect(extracted).toEqual({ childId: cid, dps });
+    });
+
+    it('v3.5 prepare → extract yields same cid and dps', () => {
+      const prepared = ChildPayloadUtility.prepareChildPayload(cid, dps, '3.5');
+      const extracted = ChildPayloadUtility.extractChildData(prepared);
+      expect(extracted).toEqual({ childId: cid, dps });
+    });
+  });
+});