homebridge-tuya-plus 3.14.0-dev.4 → 3.14.0-dev.41

package/test/BaseAccessory.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const BaseAccessory = require('../lib/BaseAccessory');
-const { makeInstance } = require('./support/mocks');
+const { makeInstance, HAP } = require('./support/mocks');
 
 // Minimal concrete subclass — BaseAccessory itself doesn't define _registerCharacteristics
 class TestAccessory extends BaseAccessory {
@@ -158,10 +158,13 @@ describe('getStateAsync', () => {
         expect(instance.getStateAsync(['1', '2'])).toEqual({ '1': true, '2': 50 });
     });
 
-    test('throws when device is not connected', () => {
+    test('throws a comm-failure HapStatusError when device is not connected', () => {
         const { instance, device } = make();
         device.connected = false;
-        expect(() => instance.getStateAsync('1')).toThrow('Not connected');
+        let err;
+        try { instance.getStateAsync('1'); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
     });
 });
 
@@ -178,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();
     });
 });
@@ -201,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', () => {
@@ -217,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', () => {
@@ -231,20 +273,57 @@ describe('getDividedStateAsync', () => {
         expect(instance.getDividedStateAsync('5', 10)).toBeCloseTo(220);
     });
 
-    test('throws when state value is not finite', () => {
+    test('throws a comm-failure HapStatusError when state value is not finite', () => {
         const { instance } = make({ '5': 'bad' });
-        expect(() => instance.getDividedStateAsync('5', 10)).toThrow();
+        let err;
+        try { instance.getDividedStateAsync('5', 10); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
+    });
+});
+
+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', () => {
@@ -255,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/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,71 +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);
-    });
-
-    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);
-    });
-
-    test('leak sensor maps rain → detected', () => {
-        const { instance } = makeHarness({}, { rainSensorType: 'leak' });
-        expect(instance._rainDetected('rain')).toBe(true);
-        expect(instance._rainDetected('no_rain')).toBe(false);
-    });
-});
-
-describe('IrrigationSystemAccessory — cloud mode (data-points keyed by code)', () => {
-    // Mirrors a real Tuya "sfkzq" watering controller reached over the cloud:
-    // valves are switch_1..4, battery is battery_percentage, and there is no
-    // rain sensor.
-    const cloudState = () => ({ switch_1: false, switch_2: false, switch_3: false, switch_4: false, battery_percentage: 99 });
-    const cloudCtx = { cloud: true, noRainSensor: true };
-
+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('default valves use Tuya codes switch_1..switch_4 (not numeric ids)', () => {
-        const { accessory } = makeHarness(cloudState(), cloudCtx);
-        ['switch_1', 'switch_2', 'switch_3', 'switch_4'].forEach(code => {
-            expect(valve(accessory, code)).toBeTruthy();
-        });
-        expect(valve(accessory, '1')).toBeFalsy();
+    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('turning a zone on writes the code/value to the device', () => {
-        const { accessory, device } = makeHarness(cloudState(), cloudCtx);
-        valve(accessory, 'switch_1').getCharacteristic(Characteristic.Active).triggerSet(1);
-        jest.advanceTimersByTime(500);
-        expect(device.update).toHaveBeenCalledWith({ switch_1: 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('battery is read from the battery_percentage code', () => {
-        const { accessory } = makeHarness(cloudState(), cloudCtx);
-        const battery = accessory.getService(Service.Battery);
-        expect(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('a realtime change keyed by code is reflected in HomeKit', () => {
-        const { accessory, device } = makeHarness(cloudState(), cloudCtx);
-        device.emitChange({ switch_2: true });
-        expect(valve(accessory, 'switch_2').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 });
+
+        v.getCharacteristic(Characteristic.Active).triggerSet(0);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: false });
     });
 
-    test('an explicit valve list may use custom codes', () => {
+    test('master OFF closes zones the device has not echoed as open', () => {
         const { accessory, device } = makeHarness(
-            { zone_a: false, zone_b: false, battery_percentage: 50 },
-            { cloud: true, noRainSensor: true, valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }] }
+            { zone_a: false, zone_b: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], noBattery: true, defaultDuration: 0 }
         );
-        expect(valve(accessory, 'zone_a')).toBeTruthy();
+        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);
-        expect(device.update).toHaveBeenCalledWith({ zone_b: true });
+
+        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();
     });
 });