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

package/test/zigbee/LocalDevice.zigbee.test.ts

@@ -0,0 +1,274 @@
+/// <reference types="node" />
+import { describe, expect, it, beforeEach, jest } from '@jest/globals';
+import EventEmitter from 'events';
+import LocalDevice, { LocalDeviceContext } from '../../src/local/LocalDevice';
+
+// ── Logger mock ───────────────────────────────────────────────────────────────
+
+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) {}
+    debug() {}; info() {}; warn() {}; error() {};
+  },
+}));
+
+// ── Protocol mock ──────────────────────────────────────────────────────────────
+
+jest.mock('../../src/local/protocol/ProtocolFactory', () => ({
+  ProtocolFactory: {
+    createProtocol: jest.fn(() => ({
+      isFrameComplete: jest.fn(() => false),
+      extractFrame: jest.fn(() => null),
+      encodeFrame: jest.fn(() => Buffer.alloc(0)),
+      decodeFrame: jest.fn(() => null),
+    })),
+  },
+}));
+
+// ── net mock ───────────────────────────────────────────────────────────────────
+
+jest.mock('net', () => ({
+  createConnection: jest.fn(() => {
+    const s = new EventEmitter() as any;
+    s.setKeepAlive = jest.fn();
+    s.setNoDelay = jest.fn();
+    s.write = jest.fn();
+    s.destroy = jest.fn();
+    s.removeAllListeners = jest.fn(() => { s.removeAllListeners(); });
+    // Don't actually call removeAllListeners on EventEmitter to avoid recursion
+    s.removeAllListeners = jest.fn();
+    return s;
+  }),
+}));
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function makeLogger() {
+  return { log: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() } as any;
+}
+
+function makeParent(overrides: Partial<LocalDeviceContext> = {}): LocalDevice {
+  const ctx: LocalDeviceContext = {
+    id: 'gateway_001',
+    key: Buffer.from('0123456789abcdef'),
+    ip: '192.168.1.100',
+    version: '3.3',
+    name: 'Test Gateway',
+    ...overrides,
+  };
+  return new LocalDevice(ctx, makeLogger());
+}
+
+function makeChild(parent: LocalDevice, cid: string): LocalDevice {
+  const ctx: LocalDeviceContext = {
+    id: 'child_001',
+    key: Buffer.from('0123456789abcdef'),
+    ip: '192.168.1.100',
+    version: '3.3',
+    name: 'Test Child',
+  };
+  const child = new LocalDevice(ctx, makeLogger());
+  child.parentDevice = parent;
+  child.childId = cid;
+  parent.children.set(cid, child);
+  return child;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+
+describe('LocalDevice – Zigbee parent/child', () => {
+
+  describe('children Map', () => {
+    it('starts as an empty Map', () => {
+      const parent = makeParent();
+      expect(parent.children.size).toBe(0);
+    });
+
+    it('can register a child', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      expect(parent.children.has('0011223344556601')).toBe(true);
+      expect(child.parentDevice).toBe(parent);
+      expect(child.childId).toBe('0011223344556601');
+    });
+
+    it('can register multiple children with different CIDs', () => {
+      const parent = makeParent();
+      makeChild(parent, '0011223344556601');
+      makeChild(parent, '0011223344556602');
+      expect(parent.children.size).toBe(2);
+    });
+  });
+
+  describe('update() routing', () => {
+    it('calls updateChild on parent when this is a child', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      const spy = jest.spyOn(parent, 'updateChild');
+
+      child.update({ '1': true });
+
+      expect(spy).toHaveBeenCalledWith('0011223344556601', { '1': true });
+    });
+
+    it('does NOT call updateChild on parent for a standalone device', () => {
+      const standalone = makeParent();
+      const spy = jest.spyOn(standalone, 'updateChild');
+
+      standalone.update({ '1': true }); // no-op (no socket), but should not delegate
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updateChild()', () => {
+    it('logs a warning and returns for an invalid CID', () => {
+      const parent = makeParent();
+      const warnSpy = jest.spyOn(parent.log, 'warn');
+
+      parent.updateChild('bad-cid', { '1': true });
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('invalid CID'));
+    });
+
+    it('logs a warning for unsupported protocol versions', () => {
+      const parent = makeParent({ version: '3.1' });
+      const warnSpy = jest.spyOn(parent.log, 'warn');
+
+      parent.updateChild('0011223344556601', { '1': true });
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('not supported for Zigbee'));
+    });
+
+    it('does not throw for a valid v3.3 gateway (even without socket)', () => {
+      const parent = makeParent({ version: '3.3' });
+      expect(() => parent.updateChild('0011223344556601', { '1': true })).not.toThrow();
+    });
+
+    it('does not throw for a valid v3.4 gateway', () => {
+      const parent = makeParent({ version: '3.4' });
+      expect(() => parent.updateChild('0011223344556601', { '1': true })).not.toThrow();
+    });
+
+    it('does not throw for a valid v3.5 gateway', () => {
+      const parent = makeParent({ version: '3.5' });
+      expect(() => parent.updateChild('0011223344556601', { '1': true })).not.toThrow();
+    });
+  });
+
+  describe('queryStateChild()', () => {
+    it('logs a warning for an invalid CID', () => {
+      const parent = makeParent();
+      const warnSpy = jest.spyOn(parent.log, 'warn');
+
+      parent.queryStateChild('bad');
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('invalid CID'));
+    });
+
+    it('does not throw for a valid CID on v3.3 gateway', () => {
+      const parent = makeParent({ version: '3.3' });
+      expect(() => parent.queryStateChild('0011223344556601')).not.toThrow();
+    });
+  });
+
+  describe('_change() routing (child state update from gateway)', () => {
+    it('emits change on the correct child when CID matches', done => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+
+      child.on('change', (changes: Record<string, unknown>) => {
+        expect(changes['1']).toBe(true);
+        done();
+      });
+
+      // Simulate parent routing child state update
+      child._change({ '1': true });
+    });
+
+    it('updates child.state accumulator', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+
+      child._change({ '1': true, '2': 80 });
+
+      expect(child.state).toMatchObject({ '1': true, '2': 80 });
+    });
+
+    it('emits change only for values that actually changed', done => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      child.state = { '1': true }; // pre-set state
+
+      child.on('change', (changes: Record<string, unknown>) => {
+        // Only '2' changed
+        expect(Object.keys(changes)).toEqual(['2']);
+        done();
+      });
+
+      child._change({ '1': true, '2': 50 }); // '1' unchanged, '2' new
+    });
+
+    it('does not emit change when no values differ', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      child.state = { '1': true };
+
+      const spy = jest.fn();
+      child.on('change', spy);
+
+      child._change({ '1': true }); // same value
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('disconnect() child propagation', () => {
+    it('emits disconnect on each registered child', done => {
+      const parent = makeParent();
+      const child1 = makeChild(parent, '0011223344556601');
+      const child2 = makeChild(parent, '0011223344556602');
+
+      child1.connected = true;
+      child2.connected = true;
+
+      let count = 0;
+      const onDisconnect = () => {
+        count++;
+        if (count === 2) done();
+      };
+
+      child1.on('disconnect', onDisconnect);
+      child2.on('disconnect', onDisconnect);
+
+      parent.disconnect();
+    });
+
+    it('sets connected=false on children', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      child.connected = true;
+
+      parent.disconnect();
+
+      expect(child.connected).toBe(false);
+    });
+
+    it('does not emit disconnect for children already disconnected', () => {
+      const parent = makeParent();
+      const child = makeChild(parent, '0011223344556601');
+      child.connected = false; // already disconnected
+
+      const spy = jest.fn();
+      child.on('disconnect', spy);
+
+      parent.disconnect();
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+});

package/test/zigbee/LocalDeviceManager.cloud-discovery.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it, beforeEach, afterEach, jest } from '@jest/globals';
+import LocalDeviceManager from '../../src/local/LocalDeviceManager';
+import { LocalConfig } from '../../src/local/config';
+import Logger from '../../src/shared/util/Logger';
+
+function makeMockLog(): Logger {
+  return {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+  } as unknown as Logger;
+}
+
+describe('LocalDeviceManager – Cloud-based child discovery', () => {
+  let log: Logger;
+  let manager: LocalDeviceManager;
+
+  const GATEWAY_ID = 'cloud_gw_001';
+  const DEVICE_KEY = '0123456789abcdef';
+  const DEVICE_IP = '192.168.1.200';
+
+  beforeEach(() => {
+    log = makeMockLog();
+  });
+
+  afterEach(() => {
+    if (manager) {
+      manager.stopLocalDevices();
+    }
+    jest.clearAllMocks();
+  });
+
+  it('method exists and can be called without error', async () => {
+    const config: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Cloud Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          isZigbeeGateway: true,
+        },
+      ],
+    };
+
+    manager = new LocalDeviceManager(config, log);
+
+    const cloudDevices = [
+      { id: GATEWAY_ID },
+      { id: 'child_cloud_001', gateway_id: GATEWAY_ID },
+    ];
+
+    // Should not throw
+    expect(() => {
+      manager.discoverChildrenFromCloud(cloudDevices);
+    }).not.toThrow();
+  });
+
+  it('logs debug for missing gateway config', async () => {
+    const config: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [],
+    };
+
+    manager = new LocalDeviceManager(config, log);
+
+    const cloudDevices = [
+      { id: 'unknown_gw', gateway_id: undefined },
+      { id: 'child_001', gateway_id: 'unknown_gw' },
+    ];
+
+    manager.discoverChildrenFromCloud(cloudDevices);
+
+    const debugSpy = log.debug as jest.MockedFunction<typeof log.debug>;
+    expect(debugSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  it('handles empty cloud device list', async () => {
+    const config: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+        },
+      ],
+    };
+
+    manager = new LocalDeviceManager(config, log);
+
+    // Should not throw
+    expect(() => {
+      manager.discoverChildrenFromCloud([]);
+      manager.discoverChildrenFromCloud(undefined);
+      manager.discoverChildrenFromCloud(null as any);
+    }).not.toThrow();
+  });
+
+  it('respects isZigbeeGateway: false', async () => {
+    const config: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Non-Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          isZigbeeGateway: false,
+        },
+      ],
+    };
+
+    manager = new LocalDeviceManager(config, log);
+
+    const cloudDevices = [
+      { id: GATEWAY_ID },
+      { id: 'child_001', gateway_id: GATEWAY_ID },
+    ];
+
+    manager.discoverChildrenFromCloud(cloudDevices);
+
+    // Should not log auto-discovery (device is not a gateway)
+    const infoSpy = log.info as jest.MockedFunction<typeof log.info>;
+    const callsWithAutoDiscovery = infoSpy.mock.calls.filter(c =>
+      String(c[0]).includes('auto-discovery'),
+    );
+    expect(callsWithAutoDiscovery.length).toBe(0);
+  });
+
+  it('triggers Zigbee relationship re-detection', async () => {
+    const config: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          isZigbeeGateway: true,
+        },
+      ],
+    };
+
+    manager = new LocalDeviceManager(config, log);
+
+    const cloudDevices = [
+      { id: GATEWAY_ID },
+      { id: 'child_001', gateway_id: GATEWAY_ID },
+    ];
+
+    // After discovery, the config should have more devices (auto-discovered children added)
+    manager.discoverChildrenFromCloud(cloudDevices);
+
+    // The manager's internal gateway relationships should be re-detected
+    // (We can't easily verify this without breaking encapsulation, but the method should complete without error)
+    expect(manager).toBeDefined();
+  });
+});

package/test/zigbee/LocalDeviceManager.zigbee.reconnect.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it, beforeEach, afterEach, jest } from '@jest/globals';
+import LocalDeviceManager from '../../src/local/LocalDeviceManager';
+import { LocalConfig, LocalDeviceConfig } from '../../src/local/config';
+import TuyaDeviceManager from '../../src/cloud/device/TuyaDeviceManager';
+import Logger from '../../src/shared/util/Logger';
+
+function makeMockLog(): Logger {
+  return {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+  } as unknown as Logger;
+}
+
+describe('LocalDeviceManager – Zigbee gateway reconnection', () => {
+  let log: Logger;
+  let manager: LocalDeviceManager;
+
+  const GATEWAY_ID = 'gw_reconnect_001';
+  const CHILD_ID = 'child_reconnect_001';
+  const CHILD_CID = '00aabbccddee1234';
+  const DEVICE_KEY = '0123456789abcdef';
+  const DEVICE_IP = '192.168.1.200';
+
+  function zigbeeReconnectConfig(): LocalConfig {
+    return {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Reconnect Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          protocolVersion: '3.3',
+          isZigbeeGateway: true,
+        },
+        {
+          tuyaDeviceId: CHILD_ID,
+          name: 'Reconnect Child',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          protocolVersion: '3.3',
+          parentDeviceId: GATEWAY_ID,
+          zigbeeChildId: CHILD_CID,
+        },
+      ],
+    };
+  }
+
+  beforeEach(() => {
+    log = makeMockLog();
+    manager = new LocalDeviceManager(zigbeeReconnectConfig(), log);
+  });
+
+  afterEach(() => {
+    manager.stopLocalDevices();
+    jest.clearAllMocks();
+  });
+
+  it('detects gateway relationships during init', async () => {
+    await manager.initLocalDevices();
+
+    const gatewayRels = (manager as any).gatewayRelationships as Map<string, any>;
+    expect(gatewayRels.has(GATEWAY_ID)).toBe(true);
+
+    const rel = gatewayRels.get(GATEWAY_ID);
+    expect(rel.children.length).toBe(1);
+    expect(rel.children[0].cid).toBe(CHILD_CID);
+    expect(rel.children[0].deviceId).toBe(CHILD_ID);
+  });
+
+  it('handles per-child DP mapping override if provided', async () => {
+    const configWithOverride: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          dpMapping: { 'switch_1': 1, 'bright_value': 2 },
+        },
+        {
+          tuyaDeviceId: CHILD_ID,
+          name: 'Child',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          parentDeviceId: GATEWAY_ID,
+          zigbeeChildId: CHILD_CID,
+          childDpMapping: { 'switch_1': 10, 'bright_value': 11 }, // Different DPs
+        },
+      ],
+    };
+
+    const mgr = new LocalDeviceManager(configWithOverride, log);
+    // Should initialize without error even with per-child DP overrides
+    await mgr.initLocalDevices();
+
+    // Verify that gateway relationships include the child
+    const gatewayRels = (mgr as any).gatewayRelationships as Map<string, any>;
+    const childRel = gatewayRels.get(GATEWAY_ID);
+    expect(childRel?.children.length).toBe(1);
+    expect(childRel.children[0].deviceId).toBe(CHILD_ID);
+    expect(childRel.children[0].cid).toBe(CHILD_CID);
+
+    mgr.stopLocalDevices();
+  });
+
+  it('handles per-child category override if provided', async () => {
+    const configWithCategoryOverride: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Gateway Hub',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          category: 'kit', // Hub/gateway category
+        },
+        {
+          tuyaDeviceId: CHILD_ID,
+          name: 'Child Light',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          parentDeviceId: GATEWAY_ID,
+          zigbeeChildId: CHILD_CID,
+          childCategory: 'dj', // Override: this child is a light
+        },
+      ],
+    };
+
+    const mgr = new LocalDeviceManager(configWithCategoryOverride, log);
+    await mgr.initLocalDevices();
+
+    const gwDevice = mgr.getDevice(GATEWAY_ID);
+    const childDevice = mgr.getDevice(CHILD_ID);
+
+    expect(gwDevice?.category).toBe('kit');
+    // childDevice won't have category set until parent connects (lazy registration)
+
+    mgr.stopLocalDevices();
+  });
+
+  it('logs gateway relationships and recognizes multi-child setup', async () => {
+    const multiChildConfig: LocalConfig = {
+      autoDiscoverDevices: false,
+      devices: [
+        {
+          tuyaDeviceId: GATEWAY_ID,
+          name: 'Multi-Child Gateway',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          isZigbeeGateway: true,
+        },
+        {
+          tuyaDeviceId: 'child_a',
+          name: 'Child A',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          parentDeviceId: GATEWAY_ID,
+          zigbeeChildId: '0011223344556601',
+        },
+        {
+          tuyaDeviceId: 'child_b',
+          name: 'Child B',
+          ip: DEVICE_IP,
+          tuyaKey: DEVICE_KEY,
+          parentDeviceId: GATEWAY_ID,
+          zigbeeChildId: '0011223344556602',
+        },
+      ],
+    };
+
+    const mgr = new LocalDeviceManager(multiChildConfig, log);
+    await mgr.initLocalDevices();
+
+    const infoSpy = log.info as jest.MockedFunction<typeof log.info>;
+    const infoCalls = infoSpy.mock.calls.map(c => String(c[0]));
+    const gatewayLine = infoCalls.find(s => s.includes('Zigbee gateway detected'));
+
+    expect(gatewayLine).toBeDefined();
+    expect(gatewayLine).toContain(GATEWAY_ID);
+    expect(gatewayLine).toContain('2 sub-device');
+
+    mgr.stopLocalDevices();
+  });
+
+  it('manages gateway connections separately from local connections', async () => {
+    await manager.initLocalDevices();
+
+    const localConnections = (manager as any).localConnections as Map<string, any>;
+    const gatewayConnections = (manager as any).gatewayConnections as Map<string, any>;
+
+    // Initially, no connections are open (no TCP connect called)
+    expect(localConnections.size).toBe(0);
+    expect(gatewayConnections.size).toBe(0);
+  });
+});