homebridge-tuya-plus 3.14.0-dev.3 → 3.14.0-dev.30

package/test/IrrigationSystemAccessory.test.js

@@ -125,8 +125,8 @@ describe('IrrigationSystemAccessory — category', () => {
 });
 
 describe('IrrigationSystemAccessory — service topology', () => {
-    test('builds an IrrigationSystem (primary) + 4 linked valves + battery + contact sensor by default', () => {
-        const { accessory } = makeHarness({ '1': false, '2': false, '3': false, '4': false, '46': 80, '49': 'no_rain' });
+    test('builds an IrrigationSystem (primary) + 4 linked valves + battery by default', () => {
+        const { accessory } = makeHarness({ '1': false, '2': false, '3': false, '4': false, '46': 80 });
 
         const irr = irrigation(accessory);
         expect(irr).toBeDefined();
@@ -138,9 +138,9 @@ describe('IrrigationSystemAccessory — service topology', () => {
         // All four valves are linked to the irrigation system.
         expect(irr.linked).toHaveLength(4);
 
-        // Battery + ContactSensor present; LeakSensor absent.
+        // Battery present; no rain/leak sensor is ever created.
         expect(accessory.getService(Service.Battery)).toBeDefined();
-        expect(accessory.getService(Service.ContactSensor)).toBeDefined();
+        expect(accessory.getService(Service.ContactSensor)).toBeUndefined();
         expect(accessory.getService(Service.LeakSensor)).toBeUndefined();
     });
 
@@ -154,6 +154,19 @@ describe('IrrigationSystemAccessory — service topology', () => {
         });
     });
 
+    test('adds a ServiceLabel (ARABIC_NUMERALS) so the multi-valve zones group under the system', () => {
+        const { accessory } = makeHarness({ '1': false, '2': false, '3': false, '4': false });
+        const label = accessory.getService(Service.ServiceLabel);
+        expect(label).toBeDefined();
+        expect(label.getCharacteristic(Characteristic.ServiceLabelNamespace).value)
+            .toBe(Characteristic.ServiceLabelNamespace.ARABIC_NUMERALS);
+    });
+
+    test('a single-valve system omits the ServiceLabel (no collection to label)', () => {
+        const { accessory } = makeHarness({ '1': false }, { valveCount: 1 });
+        expect(accessory.getService(Service.ServiceLabel)).toBeUndefined();
+    });
+
     test('IrrigationSystem advertises the required characteristics', () => {
         const { accessory } = makeHarness({ '1': false });
         const irr = irrigation(accessory);
@@ -162,17 +175,23 @@ describe('IrrigationSystemAccessory — service topology', () => {
         expect(irr.getCharacteristic(Characteristic.InUse).value).toBe(Characteristic.InUse.NOT_IN_USE);
     });
 
-    test('noBattery / noRainSensor omit those services', () => {
-        const { accessory } = makeHarness({ '1': false }, { noBattery: true, noRainSensor: true });
+    test('noBattery omits the battery service', () => {
+        const { accessory } = makeHarness({ '1': false }, { noBattery: true });
         expect(accessory.getService(Service.Battery)).toBeUndefined();
-        expect(accessory.getService(Service.ContactSensor)).toBeUndefined();
-        expect(accessory.getService(Service.LeakSensor)).toBeUndefined();
     });
 
-    test('rainSensorType "leak" uses a LeakSensor instead of a ContactSensor', () => {
-        const { accessory } = makeHarness({ '49': 'rain' }, { rainSensorType: 'leak' });
-        expect(accessory.getService(Service.LeakSensor)).toBeDefined();
+    test('removes a stale rain sensor service left over from an older version', () => {
+        const { instance, accessory } = makeHarness({ '1': false });
+        // An accessory cached by an older plugin version may still carry the
+        // ContactSensor/LeakSensor; reconciliation must drop it so the sprinkler
+        // stays a clean, single-category tile.
+        accessory.addService(Service.ContactSensor, 'Old Rain');
+        accessory.addService(Service.LeakSensor, 'Old Leak');
+
+        instance._verifyCachedPlatformAccessory();
+
         expect(accessory.getService(Service.ContactSensor)).toBeUndefined();
+        expect(accessory.getService(Service.LeakSensor)).toBeUndefined();
     });
 });
 
@@ -279,6 +298,38 @@ describe('IrrigationSystemAccessory — valve activation & timer', () => {
         jest.advanceTimersByTime(600 * 1000);
         expect(device.update.mock.calls.length).toBe(calls);
     });
+
+    test('valve Active onGet reports the optimistic value, not the lagging device state (no flicker)', () => {
+        // Cloud devices don't advance device.state until the realtime stream
+        // echoes the write back. Emulate that (update is a no-op on state) and
+        // confirm a freshly-pressed valve keeps reading ON instead of briefly
+        // reverting to the pre-press value.
+        const { accessory, device } = makeHarness({ '1': false }, { defaultDuration: 0 });
+        device.update.mockImplementation(() => true);
+        const v = valve(accessory, 1);
+
+        v.getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+
+        expect(device.state['1']).toBe(false); // not echoed yet
+        expect(v.getCharacteristic(Characteristic.Active).triggerGet()).toBe(Characteristic.Active.ACTIVE);
+    });
+
+    test('system Active onGet reports the cached aggregate, not the lagging device state', () => {
+        const { accessory, device } = makeHarness({ '1': false, '2': false }, { defaultDuration: 0 });
+        device.update.mockImplementation(() => true);
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+
+        expect(irrigation(accessory).getCharacteristic(Characteristic.Active).triggerGet())
+            .toBe(Characteristic.Active.ACTIVE);
+    });
+
+    test('Active onGet still throws while disconnected (HomeKit shows "No Response")', () => {
+        const { accessory, device } = makeHarness({ '1': false });
+        device.connected = false;
+        expect(() => valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerGet()).toThrow();
+    });
 });
 
 describe('IrrigationSystemAccessory — write batching (one Tuya command)', () => {
@@ -361,16 +412,13 @@ describe('IrrigationSystemAccessory — device-side change reflection', () => {
         expect(v.getCharacteristic(Characteristic.RemainingDuration).value).toBe(600);
     });
 
-    test('battery + rain telemetry updates the corresponding characteristics', () => {
-        const { accessory, device } = makeHarness({ '46': 80, '49': 'no_rain' });
-        device.emitChange({ '46': 10, '49': 'rain' });
+    test('battery telemetry updates the corresponding characteristics', () => {
+        const { accessory, device } = makeHarness({ '46': 80 });
+        device.emitChange({ '46': 10 });
 
         const battery = accessory.getService(Service.Battery);
         expect(battery.getCharacteristic(Characteristic.BatteryLevel).value).toBe(10);
         expect(battery.getCharacteristic(Characteristic.StatusLowBattery).value).toBe(Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW);
-
-        const contact = accessory.getService(Service.ContactSensor);
-        expect(contact.getCharacteristic(Characteristic.ContactSensorState).value).toBe(Characteristic.ContactSensorState.CONTACT_NOT_DETECTED);
     });
 });
 
@@ -425,22 +473,77 @@ describe('IrrigationSystemAccessory — charging state', () => {
     });
 });
 
-describe('IrrigationSystemAccessory — rain mapping', () => {
-    test('contact sensor: rain → NOT_DETECTED, no_rain → DETECTED', () => {
-        const { instance } = makeHarness();
-        expect(instance._contactState('rain')).toBe(Characteristic.ContactSensorState.CONTACT_NOT_DETECTED);
-        expect(instance._contactState('no_rain')).toBe(Characteristic.ContactSensorState.CONTACT_DETECTED);
-    });
+describe('IrrigationSystemAccessory — data-points addressed by code', () => {
+    // The accessory is transport-agnostic: a data-point may be a numeric id or a
+    // Tuya "code". The LAN+cloud TuyaDevice keeps state dual-keyed and translates
+    // writes, so irrigation has no cloud-specific logic — it just uses the dp
+    // strings it's given. A device reached over the cloud commonly addresses its
+    // zones as switch_1.. and battery as battery_percentage.
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => { jest.clearAllTimers(); jest.useRealTimers(); });
+
+    test('an explicit valve list may use string codes', () => {
+        const { accessory, device } = makeHarness(
+            { zone_a: false, zone_b: false, battery_percentage: 50 },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], dpBattery: 'battery_percentage' }
+        );
+        expect(valve(accessory, 'zone_a')).toBeTruthy();
+        valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ zone_b: true });
+    });
+
+    test('battery can be read from a code data-point', () => {
+        const { accessory } = makeHarness(
+            { zone_a: false, battery_percentage: 99 },
+            { valves: [{ name: 'A', dp: 'zone_a' }], dpBattery: 'battery_percentage' }
+        );
+        expect(accessory.getService(Service.Battery).getCharacteristic(Characteristic.BatteryLevel).value).toBe(99);
+    });
+
+    test('a device-side change keyed by code is reflected in HomeKit', () => {
+        const { accessory, device } = makeHarness(
+            { zone_a: false, zone_b: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], noBattery: true }
+        );
+        device.emitChange({ zone_b: true });
+        expect(valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).value).toBe(Characteristic.Active.ACTIVE);
+    });
+
+    test('turning a zone off still writes false when the device never echoed the "on"', () => {
+        // A device (notably over the cloud) may not optimistically advance `state`;
+        // it only moves when the device confirms. A follow-up "off" must STILL be
+        // sent — otherwise the valve stays open while HomeKit shows it closed (the
+        // exact "can turn on but not off" report).
+        const { accessory, device } = makeHarness(
+            { zone_a: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }], noBattery: true, defaultDuration: 0 }
+        );
+        device.update.mockImplementation(() => true); // writes never touch state
+        const v = valve(accessory, 'zone_a');
+
+        v.getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: true });
 
-    test('rainInverted flips the polarity', () => {
-        const { instance } = makeHarness({}, { rainInverted: true });
-        expect(instance._contactState('rain')).toBe(Characteristic.ContactSensorState.CONTACT_DETECTED);
-        expect(instance._contactState('no_rain')).toBe(Characteristic.ContactSensorState.CONTACT_NOT_DETECTED);
+        v.getCharacteristic(Characteristic.Active).triggerSet(0);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: false });
     });
 
-    test('leak sensor maps rain → detected', () => {
-        const { instance } = makeHarness({}, { rainSensorType: 'leak' });
-        expect(instance._rainDetected('rain')).toBe(true);
-        expect(instance._rainDetected('no_rain')).toBe(false);
+    test('master OFF closes zones the device has not echoed as open', () => {
+        const { accessory, device } = makeHarness(
+            { zone_a: false, zone_b: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], noBattery: true, defaultDuration: 0 }
+        );
+        device.update.mockImplementation(() => true); // writes never touch state
+
+        valve(accessory, 'zone_a').getCharacteristic(Characteristic.Active).triggerSet(1);
+        valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+
+        irrigation(accessory).getCharacteristic(Characteristic.Active).triggerSet(0);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: false, zone_b: false });
     });
 });

package/test/MultiOutletAccessory.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const MultiOutletAccessory = require('../lib/MultiOutletAccessory');
-const { makeInstance } = require('./support/mocks');
+const { makeInstance, HAP } = require('./support/mocks');
 
 function makeOutlet(state = {}) {
     return makeInstance(MultiOutletAccessory, state);
@@ -14,10 +14,13 @@ describe('MultiOutletAccessory.getPower', () => {
         expect(instance.getPower('2')).toBe(false);
     });
 
-    test('throws when device is disconnected', () => {
+    test('throws a comm-failure HapStatusError when device is disconnected', () => {
         const { instance, device } = makeOutlet();
         device.connected = false;
-        expect(() => instance.getPower('1')).toThrow('Not connected');
+        let err;
+        try { instance.getPower('1'); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
     });
 });
 
@@ -83,4 +86,16 @@ describe('MultiOutletAccessory.setPower — debounce batching', () => {
         await p;
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('surfaces a comm-failure error (No Response) when disconnected', () => {
+        // A tap on an unreachable outlet must fail in HomeKit instead of being
+        // silently dropped after the debounce.
+        const { instance, device } = makeOutlet({ '1': false });
+        device.connected = false;
+        let err;
+        try { instance.setPower('1', true); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
+        expect(device.update).not.toHaveBeenCalled();
+    });
 });

package/test/RGBTWLightAccessory.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const RGBTWLightAccessory = require('../lib/RGBTWLightAccessory');
-const { makeInstance, makeMockCharacteristic } = require('./support/mocks');
+const { makeInstance, makeMockCharacteristic, HAP } = require('./support/mocks');
 
 function makeLight(state = {}, context = {}) {
     const result = makeInstance(RGBTWLightAccessory, state, { colorFunction: 'HEXHSB', ...context });
@@ -88,12 +88,12 @@ describe('RGBTWLightAccessory.getColorTemperature', () => {
 // setColorTemperature
 // ---------------------------------------------------------------------------
 describe('RGBTWLightAccessory.setColorTemperature', () => {
-    test('does not throw when device is not connected (issue #34)', () => {
+    test('rejects (No Response) and writes nothing when device is not connected', async () => {
         const { instance, device } = makeLight({ '2': 'white', '4': 255 });
         instance.characteristicHue = makeMockCharacteristic(0);
         instance.characteristicSaturation = makeMockCharacteristic(0);
         device.connected = false;
-        expect(() => instance.setColorTemperature(200)).not.toThrow();
+        await expect(instance.setColorTemperature(200)).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
 

package/test/SimpleFanLightAccessory.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const SimpleFanLightAccessory = require('../lib/SimpleFanLightAccessory');
-const { makeInstance } = require('./support/mocks');
+const { makeInstance, HAP } = require('./support/mocks');
 
 // Mirror the state that _registerCharacteristics would establish (the mock
 // service shares a single characteristic, so wiring the fields manually keeps
@@ -290,10 +290,10 @@ describe('SimpleFanLightAccessory.getColorTemp / setColorTemp', () => {
         expect(device.update).toHaveBeenCalledWith({ '23': 1000 });
     });
 
-    test('setColorTemp does not write when the device is disconnected', () => {
+    test('setColorTemp rejects (No Response) and writes nothing when disconnected', async () => {
         const { instance, device } = makeFanLight({ '23': 500 });
         device.connected = false;
-        expect(() => instance.setColorTemp(370)).not.toThrow();
+        await expect(instance.setColorTemp(370)).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
 });

package/test/SimpleGarageDoorAccessory.test.js

@@ -52,6 +52,8 @@ function makeSimpleGarage(initialContext = {}) {
     instance.stopBeforeCloseMs = 1500;
     instance.partialStopTimer = null;
     instance.pendingCloseTimer = null;
+    instance.partialPending = false;
+    instance.partialGeneration = 0;
     instance.currentDoorState = CDS.CLOSED;
     instance.characteristicCurrentDoorState = {
         value: CDS.CLOSED,
@@ -373,11 +375,13 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
 // Disconnect handling
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory — disconnected', () => {
-    test('Skips writes when the device is disconnected', () => {
+    test('Surfaces a No Response error and writes nothing when disconnected', () => {
         const { instance, device } = makeSimpleGarage();
         device.connected = false;
 
-        instance.setTargetDoorState(TDS.OPEN);
+        // A tap on an unreachable gate must fail in HomeKit instead of being
+        // silently dropped while HomeKit believes the open/close succeeded.
+        expect(() => instance.setTargetDoorState(TDS.OPEN)).toThrow(HAP.HapStatusError);
 
         expect(device.update).not.toHaveBeenCalled();
     });
@@ -407,35 +411,71 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('Fires open, then fires stop after partialOpenMs', () => {
+    test('Stop is anchored to the gate reporting it is moving, not the button press', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        // Gate starts closed, so the open command needs time to reach it and
+        // get the gate moving before a stop can do anything.
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
 
         instance._handlePartialOpen();
 
-        // Open goes out immediately.
+        // Open goes out immediately, but the auto-stop is NOT armed yet.
         expect(device.update).toHaveBeenCalledTimes(1);
         expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
         expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
+        expect(instance.partialStopTimer).toBeNull();
+        expect(instance.partialPending).toBe(true);
+
+        // No amount of waiting fires a stop until the gate reports it's moving —
+        // this is what stops a too-early stop from being a dropped no-op.
+        jest.advanceTimersByTime(10_000);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        // Controller reports it has started opening: now the countdown arms.
+        emitState(device, STATE_OPENING_OR_OPEN);
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
 
-        // Nothing happens until the timer elapses.
         jest.advanceTimersByTime(2000 - 1);
         expect(device.update).toHaveBeenCalledTimes(1);
 
-        // Then a single stop is fired.
+        // The stop fires, and is re-sent a couple of times to survive a dropped
+        // write (the controller occasionally drops a lone command).
         jest.advanceTimersByTime(1);
         expect(device.update).toHaveBeenCalledTimes(2);
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(4, { '103': true });
 
-        // And nothing more after that.
+        // And nothing more after the re-sends.
         jest.advanceTimersByTime(10_000);
-        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenCalledTimes(4);
         expect(instance.partialStopTimer).toBeNull();
     });
 
-    test('Re-entrant press while armed is ignored (idempotent)', () => {
+    test('Arms straight away when the gate already reports open/opening', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
+
+        instance._handlePartialOpen();
+
+        // Open fired and the countdown armed without waiting for a fresh report.
+        expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
+
+        jest.advanceTimersByTime(2000);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+    });
+
+    test('Re-entrant press while in progress is ignored (idempotent)', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN; // arms immediately
 
         instance._handlePartialOpen();
         expect(device.update).toHaveBeenCalledTimes(1);
@@ -452,6 +492,20 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
     });
 
+    test('Re-entrant press while waiting for movement is ignored', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
+
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1); // open
+        expect(instance.partialPending).toBe(true);
+
+        // A second press before the gate reports moving must not fire another open.
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1);
+    });
+
     test('A direct close cancels the partial auto-stop and runs stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;

package/test/TuyaCloudApi.test.js

@@ -0,0 +1,221 @@
+'use strict';
+
+const crypto = require('crypto');
+const TuyaCloudApi = require('../lib/TuyaCloudApi');
+
+const EMPTY_SHA = crypto.createHash('sha256').update('').digest('hex');
+const md5 = s => crypto.createHash('md5').update(s).digest('hex');
+const hmacUpper = (str, key) => crypto.createHmac('sha256', key).update(str, 'utf8').digest('hex').toUpperCase();
+
+const ACCESS_ID = 'aid123';
+const ACCESS_KEY = 'secretKey456';
+
+const makeApi = (extra = {}) => new TuyaCloudApi({accessId: ACCESS_ID, accessKey: ACCESS_KEY, ...extra});
+
+describe('TuyaCloudApi — configuration', () => {
+    test('resolves region to a known endpoint', () => {
+        expect(makeApi({region: 'eu'}).endpoint).toBe('https://openapi.tuyaeu.com');
+        expect(makeApi({region: 'us'}).endpoint).toBe('https://openapi.tuyaus.com');
+        expect(makeApi({region: 'in'}).endpoint).toBe('https://openapi.tuyain.com');
+    });
+
+    test('unknown region falls back to US', () => {
+        expect(makeApi({region: 'nowhere'}).endpoint).toBe('https://openapi.tuyaus.com');
+    });
+
+    test('explicit endpoint wins and trailing slashes are trimmed', () => {
+        expect(makeApi({endpoint: 'https://example.com/'}).endpoint).toBe('https://example.com');
+    });
+
+    test('isConfigured reflects presence of credentials', () => {
+        expect(makeApi().isConfigured()).toBe(true);
+        expect(new TuyaCloudApi({}).isConfigured()).toBe(false);
+    });
+
+    test('keyFor is stable and distinguishes accounts', () => {
+        const a = TuyaCloudApi.keyFor({accessId: 'x', region: 'eu'});
+        const b = TuyaCloudApi.keyFor({accessId: 'x', region: 'eu'});
+        const c = TuyaCloudApi.keyFor({accessId: 'x', region: 'eu', username: 'u'});
+        expect(a).toBe(b);
+        expect(a).not.toBe(c);
+    });
+});
+
+describe('TuyaCloudApi — request signing', () => {
+    test('business signature folds in the access token and sets the header', () => {
+        const api = makeApi({region: 'eu'});
+        api._token = 'TOK';
+        const t = '1700000000000';
+        const nonce = 'nonce-1';
+        const h = api._signedHeaders({method: 'GET', urlPath: '/v1.0/devices/d/status', bodyStr: '', withToken: true, t, nonce});
+
+        const stringToSign = ['GET', EMPTY_SHA, '', '/v1.0/devices/d/status'].join('\n');
+        const expected = hmacUpper(ACCESS_ID + 'TOK' + t + nonce + stringToSign, ACCESS_KEY);
+
+        expect(h.sign).toBe(expected);
+        expect(h.access_token).toBe('TOK');
+        expect(h.client_id).toBe(ACCESS_ID);
+        expect(h.sign_method).toBe('HMAC-SHA256');
+        expect(h.t).toBe(t);
+        expect(h.nonce).toBe(nonce);
+    });
+
+    test('token signature omits the access token entirely', () => {
+        const api = makeApi();
+        api._token = 'SHOULD_NOT_APPEAR';
+        const t = '1700000000000';
+        const nonce = 'nonce-2';
+        const h = api._signedHeaders({method: 'GET', urlPath: '/v1.0/token?grant_type=1', bodyStr: '', withToken: false, t, nonce});
+
+        const stringToSign = ['GET', EMPTY_SHA, '', '/v1.0/token?grant_type=1'].join('\n');
+        const expected = hmacUpper(ACCESS_ID + t + nonce + stringToSign, ACCESS_KEY);
+
+        expect(h.sign).toBe(expected);
+        expect(h.access_token).toBeUndefined();
+    });
+
+    test('a request body changes the Content-SHA256 portion of the signature', () => {
+        const api = makeApi();
+        api._token = 'TOK';
+        const t = '1700000000000';
+        const nonce = 'n';
+        const body = JSON.stringify({commands: [{code: 'switch_1', value: true}]});
+        const h = api._signedHeaders({method: 'POST', urlPath: '/p', bodyStr: body, withToken: true, t, nonce});
+
+        const contentSha = crypto.createHash('sha256').update(body, 'utf8').digest('hex');
+        const stringToSign = ['POST', contentSha, '', '/p'].join('\n');
+        const expected = hmacUpper(ACCESS_ID + 'TOK' + t + nonce + stringToSign, ACCESS_KEY);
+        expect(h.sign).toBe(expected);
+        expect(contentSha).not.toBe(EMPTY_SHA);
+    });
+});
+
+describe('TuyaCloudApi — auth flow selection', () => {
+    test('custom project uses grant_type=1', async () => {
+        const api = makeApi();
+        const calls = [];
+        api._httpsRequest = async (method, path) => {
+            calls.push({method, path});
+            return {success: true, result: {access_token: 'T', uid: 'U', expire_time: 7200}};
+        };
+        const token = await api._ensureToken();
+        expect(token).toBe('T');
+        expect(api.uid).toBe('U');
+        expect(calls[0].path).toBe('/v1.0/token?grant_type=1');
+        expect(calls[0].method).toBe('GET');
+    });
+
+    test('smart-home project posts an MD5 password to authorized-login', async () => {
+        const api = makeApi({username: 'joe@example.com', password: 'pw', countryCode: '48', schema: 'tuyaSmart'});
+        let captured;
+        api._httpsRequest = async (method, path, headers, bodyStr) => {
+            captured = {method, path, bodyStr};
+            return {success: true, result: {access_token: 'T2', uid: 'U2', expire_time: 7200}};
+        };
+        const token = await api._ensureToken();
+        expect(token).toBe('T2');
+        expect(api.uid).toBe('U2');
+        expect(captured.path).toBe('/v1.0/iot-01/associated-users/actions/authorized-login');
+        const body = JSON.parse(captured.bodyStr);
+        expect(body.username).toBe('joe@example.com');
+        expect(body.password).toBe(md5('pw'));
+        expect(body.country_code).toBe('48');
+        expect(body.schema).toBe('tuyaSmart');
+    });
+});
+
+describe('TuyaCloudApi — endpoints', () => {
+    const ready = () => {
+        const api = makeApi();
+        api._token = 'TOK';
+        api._tokenExpiry = Date.now() + 1e6; // skip token fetch
+        return api;
+    };
+
+    test('getStatus returns the result array', async () => {
+        const api = ready();
+        api._httpsRequest = async () => ({success: true, result: [{code: 'switch_1', value: true}]});
+        await expect(api.getStatus('dev')).resolves.toEqual([{code: 'switch_1', value: true}]);
+    });
+
+    test('getShadowProperties returns the properties array (code + dp_id)', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => {
+            path = p;
+            return {success: true, result: {properties: [{code: 'switch_led', dp_id: 20, value: true}]}};
+        };
+        await expect(api.getShadowProperties('dev')).resolves.toEqual([{code: 'switch_led', dp_id: 20, value: true}]);
+        expect(path).toBe('/v2.0/cloud/thing/dev/shadow/properties');
+    });
+
+    test('getShadowProperties returns null (never throws) when the shadow API is unavailable', async () => {
+        const api = ready();
+        api._httpsRequest = async () => ({success: false, code: 1106, msg: 'permission deny'});
+        await expect(api.getShadowProperties('dev')).resolves.toBeNull();
+    });
+
+    test('getDeviceInfo returns the device record (with online status)', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => { path = p; return {success: true, result: {id: 'dev', online: false, name: 'X'}}; };
+        await expect(api.getDeviceInfo('dev')).resolves.toEqual({id: 'dev', online: false, name: 'X'});
+        expect(path).toBe('/v1.0/devices/dev');
+    });
+
+    test('sendCommands posts the commands and reports success', async () => {
+        const api = ready();
+        let captured;
+        api._httpsRequest = async (method, path, headers, bodyStr) => {
+            captured = {method, path, body: JSON.parse(bodyStr)};
+            return {success: true, result: true};
+        };
+        const ok = await api.sendCommands('dev', [{code: 'switch_1', value: true}]);
+        expect(ok).toBe(true);
+        expect(captured.method).toBe('POST');
+        expect(captured.path).toBe('/v1.0/devices/dev/commands');
+        expect(captured.body).toEqual({commands: [{code: 'switch_1', value: true}]});
+    });
+
+    test('sendCommands short-circuits on an empty command list', async () => {
+        const api = ready();
+        api._httpsRequest = jest.fn();
+        await expect(api.sendCommands('dev', [])).resolves.toBe(true);
+        expect(api._httpsRequest).not.toHaveBeenCalled();
+    });
+
+    test('getMqttConfig posts the expected body and returns the broker config', async () => {
+        const api = ready();
+        api.uid = 'UID';
+        let captured;
+        api._httpsRequest = async (method, path, headers, bodyStr) => {
+            captured = {path, body: JSON.parse(bodyStr)};
+            return {success: true, result: {url: 'ssl://m1:8883', source_topic: {device: 't'}}};
+        };
+        const cfg = await api.getMqttConfig('link-1');
+        expect(captured.path).toBe('/v1.0/iot-03/open-hub/access-config');
+        expect(captured.body).toEqual({uid: 'UID', link_id: 'link-1', link_type: 'mqtt', topics: 'device', msg_encrypted_version: '2.0'});
+        expect(cfg.url).toBe('ssl://m1:8883');
+    });
+
+    test('an invalid-token error refreshes the token and retries once', async () => {
+        const api = ready();
+        let business = 0;
+        api._httpsRequest = async (method, path) => {
+            // The retry re-fetches a token; serve that separately.
+            if (path.startsWith('/v1.0/token')) return {success: true, result: {access_token: 'TOK2', expire_time: 7200}};
+            business++;
+            if (business === 1) return {success: false, code: 1010, msg: 'token invalid'};
+            return {success: true, result: 'ok'};
+        };
+        const res = await api.request('GET', '/x');
+        expect(business).toBe(2);
+        expect(res.result).toBe('ok');
+    });
+
+    test('a non-token error rejects', async () => {
+        const api = ready();
+        api._httpsRequest = async () => ({success: false, code: 28841002, msg: 'no permissions'});
+        await expect(api.request('GET', '/x')).rejects.toThrow(/no permissions/);
+    });
+});