homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.51

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,185 @@ 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);
+    });
+});
+
+describe('IrrigationSystemAccessory — native (hardware) countdown', () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => { jest.clearAllTimers(); jest.useRealTimers(); });
+
+    /* --- data-point resolution --- */
+
+    test('derives each zone\'s countdown data-point as its switch dp + 16 by default', () => {
+        const { instance } = makeHarness();
+        expect(instance._getValveConfigs().map(c => c.dpCountdown)).toEqual(['17', '18', '19', '20']);
+    });
+
+    test('a custom zone may map an explicit countdown data-point', () => {
+        const { instance } = makeHarness({}, { valves: [{ name: 'Lawn', dp: 'switch_1', dpCountdown: 'countdown_1' }] });
+        const cfg = instance._getValveConfigs()[0];
+        expect(cfg.dpCountdown).toBe('countdown_1');
+        expect(cfg.countdownConfigured).toBe(true);
+    });
+
+    test('a code-addressed zone gets no default countdown dp (must be set explicitly)', () => {
+        const { instance } = makeHarness({}, { valves: [{ name: 'Lawn', dp: 'switch_1' }] });
+        expect(instance._getValveConfigs()[0].dpCountdown).toBe('');
+    });
+
+    /* --- seconds <-> minutes conversion --- */
+
+    test('converts SetDuration seconds to whole countdown minutes, never 0 for a real run', () => {
+        const { instance } = makeHarness({ '1': false, '17': 10 });
+        expect(instance._durationToCountdownMinutes(0)).toBe(0);        // indefinite stays indefinite
+        expect(instance._durationToCountdownMinutes(30)).toBe(1);       // sub-minute rounds up to 1, not 0
+        expect(instance._durationToCountdownMinutes(600)).toBe(10);
+        expect(instance._durationToCountdownMinutes(5400)).toBe(90);
+        expect(instance._durationToCountdownMinutes(999999)).toBe(120); // capped at the 120-min hardware max
+    });
+
+    /* --- THE pool-flood regression: writing a countdown opens the zone, so it
+     *     must never be written while a zone is off or on connect --- */
+
+    test('on connect, zones sitting at countdown 0 are NEVER written to (must not open them)', () => {
+        const { device } = makeHarness(
+            { '1': false, '2': false, '3': false, '4': false, '17': 0, '18': 0, '19': 0, '20': 0 },
+            { defaultDuration: 600 }
+        );
+        jest.advanceTimersByTime(2000);
+        expect(device.update).not.toHaveBeenCalled();
+    });
+
+    test('editing the Duration while a zone is OFF does not write to the device', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600 });
+        valve(accessory, 1).getCharacteristic(Characteristic.SetDuration).triggerSet(1800);
+        jest.advanceTimersByTime(2000);
+        expect(device.update).not.toHaveBeenCalled();
+        // The new duration is remembered (read back via the getter) for the next switch-on.
+        expect(valve(accessory, 1).getCharacteristic(Characteristic.SetDuration).triggerGet()).toBe(1800);
+    });
+
+    /* --- turning a zone on hands the device its own timer (the offline safety net) --- */
+
+    test('turning a zone on sends the hardware countdown alongside the switch (one command)', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600 });
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        // The countdown rides along so the device closes the valve itself even if
+        // Homebridge/the network drops while it's running.
+        expect(device.update).toHaveBeenCalledWith({ '1': true, '17': 10 });
+    });
+
+    test('master ON hands every zone its hardware countdown in one command', () => {
+        const { accessory, device } = makeHarness(
+            { '1': false, '2': false, '3': false, '4': false, '17': 0, '18': 0, '19': 0, '20': 0 },
+            { defaultDuration: 600 }
+        );
+        irrigation(accessory).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '1': true, '2': true, '3': true, '4': true, '17': 10, '18': 10, '19': 10, '20': 10 });
+    });
+
+    test('an indefinite duration turns the zone on with an unbounded (0) countdown', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 0 });
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '1': true, '17': 0 });
+    });
+
+    test('a sub-minute duration turns the zone on with a 1-min countdown, never 0', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 30 });
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ '1': true, '17': 1 });
+    });
+
+    test('changing the Duration while a zone is RUNNING re-bases the hardware countdown', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600 });
+        const v = valve(accessory, 1);
+        v.getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        device.update.mockClear();
+        v.getCharacteristic(Characteristic.SetDuration).triggerSet(1200);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ '17': 20 });
+    });
+
+    test('the software timer still closes the zone after the duration, even with a hardware countdown set', () => {
+        // Belt-and-suspenders: if the hardware countdown is unreliable (e.g. the
+        // device clears it mid-run), Homebridge itself still switches the zone off
+        // once the duration elapses — independent of the hardware countdown.
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 60 });
+        const v = valve(accessory, 1);
+        v.getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ '1': true, '17': 1 }); // on + 1-min hardware countdown
+        device.update.mockClear();
+
+        jest.advanceTimersByTime(60 * 1000);   // the HomeKit duration elapses
+        expect(v.getCharacteristic(Characteristic.Active).value).toBe(0);
+        jest.advanceTimersByTime(500);         // flush the off-write
+        expect(device.update).toHaveBeenCalledWith({ '1': false });
+    });
+
+    /* --- zones turned on at the device (physical button / Tuya app) --- */
+
+    test('a zone switched on at the device with no countdown is given one so it still auto-closes', () => {
+        const { device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600 });
+        device.update.mockClear();
+        device.emitChange({ '1': true });               // external on; device countdown still 0
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ '17': 10 });
+    });
+
+    test('a zone switched on at the device with a valid countdown is left as the device set it', () => {
+        const { device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600 });
+        device.update.mockClear();
+        device.emitChange({ '1': true, '17': 5 });      // external on with its own 5-min run
+        jest.advanceTimersByTime(500);
+        expect(device.update).not.toHaveBeenCalled();
+    });
 
-        const contact = accessory.getService(Service.ContactSensor);
-        expect(contact.getCharacteristic(Characteristic.ContactSensorState).value).toBe(Characteristic.ContactSensorState.CONTACT_NOT_DETECTED);
+    test('an externally-started zone is left alone when its HomeKit duration is indefinite', () => {
+        const { device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 0 });
+        device.update.mockClear();
+        device.emitChange({ '1': true });
+        jest.advanceTimersByTime(500);
+        expect(device.update).not.toHaveBeenCalled();
+    });
+
+    test('a zone already running at startup with no countdown is given one (offline-safe)', () => {
+        const { device } = makeHarness({ '1': true, '17': 0 }, { defaultDuration: 600 });
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledWith({ '17': 10 });
+    });
+
+    /* --- opt-out & unsupported devices --- */
+
+    test('nativeCountdown:false never touches the countdown data-point', () => {
+        const { accessory, device } = makeHarness({ '1': false, '17': 0 }, { defaultDuration: 600, nativeCountdown: false });
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '1': true });
+    });
+
+    test('a device that reports no countdown data-point is unaffected (software timer only)', () => {
+        const { accessory, device } = makeHarness({ '1': false }, { defaultDuration: 600 });
+        valve(accessory, 1).getCharacteristic(Characteristic.Active).triggerSet(1);
+        jest.advanceTimersByTime(500);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '1': true });
     });
 });
 
@@ -425,71 +645,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();
     });
 });