homebridge-tuya-plus 3.14.0-dev.17 → 3.14.0-dev.19

package/test/BaseAccessory.test.js

@@ -181,10 +181,10 @@ describe('setStateAsync', () => {
         expect(device.update).not.toHaveBeenCalled();
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
-        expect(() => instance.setStateAsync('1', true)).not.toThrow();
+        await expect(instance.setStateAsync('1', true)).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
 });
@@ -204,12 +204,29 @@ describe('setMultiStateAsync', () => {
         expect(device.update).not.toHaveBeenCalled();
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('resolves when the device accepts the writes', async () => {
+        const { instance } = make({ '1': false });
+        await expect(instance.setMultiStateAsync({ '1': true })).resolves.toBeUndefined();
+    });
+
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
-        expect(() => instance.setMultiStateAsync({ '1': true, '2': 50 })).not.toThrow();
+        await expect(instance.setMultiStateAsync({ '1': true, '2': 50 })).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('rejects when the device write is not accepted (returns false)', async () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockReturnValue(false);
+        await expect(instance.setMultiStateAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
+
+    test('awaits an async device write result (cloud) and rejects on failure', async () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockResolvedValue(false);
+        await expect(instance.setMultiStateAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
 });
 
 describe('setMultiStateLegacyAsync', () => {
@@ -220,12 +237,34 @@ describe('setMultiStateLegacyAsync', () => {
         expect(device.update).toHaveBeenCalledWith({ '1': true, '3': '2' });
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make();
         device.connected = false;
-        expect(() => instance.setMultiStateLegacyAsync({ '1': true })).not.toThrow();
+        await expect(instance.setMultiStateLegacyAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('rejects when the device write is not accepted (returns false)', async () => {
+        const { instance, device } = make();
+        device.update.mockReturnValue(false);
+        await expect(instance.setMultiStateLegacyAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
+});
+
+describe('background write helpers (never throw/reject)', () => {
+    test('setStateInBackground swallows a disconnected-device failure', async () => {
+        const { instance, device } = make({ '1': false });
+        device.connected = false;
+        expect(() => instance.setStateInBackground('1', true)).not.toThrow();
+        // Give the rejected inner promise a tick to settle; it must be caught.
+        await Promise.resolve();
+    });
+
+    test('setMultiStateLegacyInBackground still dispatches the write when connected', () => {
+        const { instance, device } = make();
+        instance.setMultiStateLegacyInBackground({ '1': true });
+        expect(device.update).toHaveBeenCalledWith({ '1': true });
+    });
 });
 
 describe('getDividedStateAsync', () => {
@@ -243,14 +282,48 @@ describe('getDividedStateAsync', () => {
     });
 });
 
+describe('getState (callback)', () => {
+    test('returns the DP value via the callback when connected', done => {
+        const { instance } = make({ '1': true });
+        instance.getState('1', (err, value) => {
+            expect(err).toBeNull();
+            expect(value).toBe(true);
+            done();
+        });
+    });
+
+    test('invokes the callback with a comm-failure error when not connected', () => {
+        const { instance, device } = make({ '1': true });
+        device.connected = false;
+        const cb = jest.fn();
+        instance.getState('1', cb);
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
+    });
+});
+
 describe('setMultiState (legacy callback)', () => {
-    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+    test('invokes the callback without error on a successful write', () => {
+        const { instance } = make({ '1': false });
+        const cb = jest.fn();
+        instance.setMultiState({ '1': true }, cb);
+        expect(cb).toHaveBeenCalledWith(null);
+    });
+
+    test('invokes the callback with a comm-failure error when not connected', () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
         const cb = jest.fn();
         instance.setMultiState({ '1': true }, cb);
         expect(device.update).not.toHaveBeenCalled();
-        expect(cb).toHaveBeenCalledWith();
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
+    });
+
+    test('invokes the callback with a comm-failure error when the write is not accepted', () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockReturnValue(false);
+        const cb = jest.fn();
+        instance.setMultiState({ '1': true }, cb);
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
     });
 
     test('tolerates a missing callback when not connected', () => {
@@ -261,13 +334,13 @@ describe('setMultiState (legacy callback)', () => {
 });
 
 describe('setMultiStateLegacy (legacy callback)', () => {
-    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+    test('invokes the callback with a comm-failure error when not connected', () => {
         const { instance, device } = make();
         device.connected = false;
         const cb = jest.fn();
         instance.setMultiStateLegacy({ '1': true }, cb);
         expect(device.update).not.toHaveBeenCalled();
-        expect(cb).toHaveBeenCalledWith();
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
     });
 });
 

package/test/MultiOutletAccessory.test.js

@@ -86,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

@@ -373,11 +373,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();
     });

package/test/TuyaCloudDevice.test.js

@@ -56,10 +56,31 @@ describe('TuyaCloudDevice', () => {
         const api = makeApi();
         const dev = makeDevice(api);
         expect(dev.connected).toBe(false);
-        expect(() => dev.update({switch_1: true})).not.toThrow();
+        expect(dev.update({switch_1: true})).toBe(false);
         expect(api.sendCommands).not.toHaveBeenCalled();
     });
 
+    test('update resolves to the cloud command result so failures are awaitable', async () => {
+        const api = makeApi();
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        api.sendCommands.mockResolvedValueOnce(true);
+        await expect(dev.update({switch_1: true})).resolves.toBe(true);
+
+        api.sendCommands.mockResolvedValueOnce(false);
+        await expect(dev.update({switch_1: true})).resolves.toBe(false);
+    });
+
+    test('update resolves to false (never rejects) when the cloud request throws', async () => {
+        const api = makeApi();
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        api.sendCommands.mockRejectedValueOnce(new Error('network down'));
+        await expect(dev.update({switch_1: true})).resolves.toBe(false);
+    });
+
     test('applyStatus emits only the changed data-points', async () => {
         const api = makeApi();
         const dev = makeDevice(api);

package/test/getCategory.test.js

@@ -23,6 +23,7 @@ const CLASS_DEF = {
     garagedoor: require('../lib/GarageDoorAccessory'),
     simplegaragedoor: require('../lib/SimpleGarageDoorAccessory'),
     simpledimmer: require('../lib/SimpleDimmerAccessory'),
+    wleddimmer: require('../lib/WledDimmerAccessory'),
     simpledimmer2: require('../lib/SimpleDimmer2Accessory'),
     simpleblinds: require('../lib/SimpleBlindsAccessory'),
     simpleheater: require('../lib/SimpleHeaterAccessory'),

package/wiki/Supported-Device-Types.md

@@ -15,7 +15,8 @@ If you are looking for verified configurations for your specific device, please
 |Barely Smart Power Strip|`Outlet`|Smart power strips that don't allow individual control of the outlets|
 |Air Conditioner|`AirConditioner`<sup>[6](#air-conditioners)</sup>|Cooling and heating devices <small>([instructions](#air-conditioners))</small>|
 |Heat Convector|`Convector`<sup>[7](#heat-convectors)</sup>|Heating panels <small>([instructions](#heat-convectors))</small>|
-|WLED Dimmer|`WledDimmer` (or legacy `SimpleDimmer`)<sup>[8](#simple-dimmers)</sup>|Dimmer switches with power control, with optional WLED sync <small>([instructions](#simple-dimmers))</small>|
+|Simple Dimmer|`SimpleDimmer`<sup>[8](#simple-dimmers)</sup>|Dimmer switches with power control <small>([instructions](#simple-dimmers))</small>|
+|WLED Dimmer|`WledDimmer`<sup>[8](#simple-dimmers)</sup>|Dimmer switches with power control, plus optional WLED brightness sync and preset-effect switches <small>([instructions](#simple-dimmers))</small>|
 |Simple Heater|`SimpleHeater`<sup>[9](#simple-heaters)</sup>|Heating solutions with only temperature control <small>([instructions](#simple-heaters))</small>|
 |Garage Door|`GarageDoor`<sup>[10](#garage-doors)</sup>|Smart garage doors or garage door openers <small>([instructions](#garage-doors))</small>|
 |Simple Garage Door|`SimpleGarageDoor`<sup>[10](#simple-garage-doors)</sup>|Sliding gate openers and garage door controllers with open/stop/close action DPs and a simple three-value status DP <small>([instructions](#simple-garage-doors))</small>|
@@ -345,14 +346,15 @@ If your signature doesn't have a variation of _low_ or _high_, `SimpleHeater` wo
 ```
 
 ### Simple Dimmers / WLED Dimmers
-These are switches that allow turning on and off, and dimming. Use type `WledDimmer` (legacy `SimpleDimmer` alias is also supported for backward compatibility).
+These are switches that allow turning on and off, and dimming. Two distinct types are available:
 
-When using with a WLED controller (e.g. a Tuya-based relay/dimmer feeding power to a WLED strip), you can use advanced sync options:
+- `SimpleDimmer` — a plain dimmer with power and brightness control.
+- `WledDimmer` — a dimmer that can additionally drive a [WLED](https://kno.wled.ge/) controller (e.g. a Tuya-based relay/dimmer feeding power to a WLED strip). With none of the WLED options below configured, it behaves exactly like a `SimpleDimmer`.
 
-- `syncBrightnessToWled`: set to WLED device IP (e.g. "192.168.1.50" or "192.168.1.50:80") to sync HomeKit brightness changes directly to WLED over HTTP, keeping the Tuya dimmer at 100%.
-- `presetEffects`: array of effect configs to expose as switches in HomeKit (each turns on a WLED fx preset, optionally with staticColor).
+The following options apply to `WledDimmer` only (they are ignored by `SimpleDimmer`):
 
-See the accessory source for full details on WLED integration.
+- `syncBrightnessToWled`: set to the WLED device IP (e.g. "192.168.1.50" or "192.168.1.50:80") to sync HomeKit brightness changes directly to WLED over HTTP, keeping the Tuya dimmer at 100%.
+- `presetEffects`: array of effect configs to expose as switches in HomeKit (each turns on a WLED fx preset, optionally with staticColor).
 
 ```json5
 {