Fix bhyve service calls on valve entities

The switch→valve conversion registered services like enable_rain_delay,
disable_rain_delay, set_manual_preset_runtime and start_program in the
valve platform but never ported the corresponding methods onto
BHyveZoneValve, so calling them with a valve entity errored out with
"Service not implemented". The service handler also only looked up
entities in the valve domain, breaking start_program on program
switches.

- Move websocket payload construction for rain delay and manual preset
  runtime onto BHyveClient, where the wire protocol belongs.
- Give BHyveZoneValve thin service wrappers that delegate to the client.
- Route the valve service handler through both VALVE_DOMAIN and
  SWITCH_DOMAIN so program switches can handle start_program, and
  surface unsupported (entity, service) pairs instead of aborting the
  whole loop.
- Collapse BHyveRainDelaySwitch turn on/off onto the shared client
  methods.

Author: sebr

custom_components/bhyve/pybhyve/client.py

@@ -276,3 +276,23 @@ async def send_message(self, payload: Any) -> None:
         """Send a message via the websocket."""
         if self._websocket is not None:
             await self._websocket.send(payload)
+
+    async def set_rain_delay(self, device_id: str, hours: int) -> None:
+        """Set rain delay hours for a device. Use hours=0 to disable."""
+        payload = {
+            "event": "rain_delay",
+            "device_id": device_id,
+            "delay": hours,
+        }
+        _LOGGER.info("Setting rain delay: %s", payload)
+        await self.send_message(payload)
+
+    async def set_manual_preset_runtime(self, device_id: str, minutes: int) -> None:
+        """Set the default watering runtime for a device."""
+        payload = {
+            "event": "set_manual_preset_runtime",
+            "device_id": device_id,
+            "seconds": minutes * 60,
+        }
+        _LOGGER.info("Setting manual preset runtime: %s", payload)
+        await self.send_message(payload)

custom_components/bhyve/switch.py

@@ -505,32 +505,8 @@ def extra_state_attributes(self) -> dict[str, Any]:
 
     async def async_turn_on(self, **_kwargs: Any) -> None:
         """Turn the switch on."""
-        await self._enable_rain_delay()
+        await self.coordinator.client.set_rain_delay(self._device_id, 24)
 
     async def async_turn_off(self, **_kwargs: Any) -> None:
         """Turn the switch off."""
-        await self._disable_rain_delay()
-
-    async def _enable_rain_delay(self, hours: int = 24) -> None:
-        """Enable rain delay."""
-        await self._set_rain_delay(hours)
-
-    async def _disable_rain_delay(self) -> None:
-        """Disable rain delay."""
-        await self._set_rain_delay(0)
-
-    async def _set_rain_delay(self, hours: int) -> None:
-        """Set rain delay hours."""
-        try:
-            payload = {
-                "event": "rain_delay",
-                "device_id": self._device_id,
-                "delay": hours,
-            }
-            _LOGGER.info("Setting rain delay: %s", payload)
-            await self.coordinator.client.send_message(payload)
-            # Coordinator updates via WebSocket event
-
-        except BHyveError as err:
-            _LOGGER.warning("Failed to send to BHyve websocket message %s", err)
-            raise
+        await self.coordinator.client.set_rain_delay(self._device_id, 0)

custom_components/bhyve/valve.py

@@ -9,6 +9,7 @@
 from typing import TYPE_CHECKING, Any
 
 import voluptuous as vol
+from homeassistant.components.switch.const import DOMAIN as SWITCH_DOMAIN
 from homeassistant.components.valve import (
     ValveDeviceClass,
     ValveEntity,
@@ -207,20 +208,29 @@ async def async_service_handler(service: Any) -> None:
         params = {
             key: value for key, value in service.data.items() if key != ATTR_ENTITY_ID
         }
-        entity_ids = service.data.get(ATTR_ENTITY_ID)
-        component = hass.data.get(VALVE_DOMAIN)
-        if entity_ids and component is not None:
-            target_vales = [component.get_entity(entity) for entity in entity_ids]
-        else:
-            return
-
+        entity_ids = service.data.get(ATTR_ENTITY_ID) or []
         method_name = method["method"]
         _LOGGER.debug("Service handler: %s %s", method_name, params)
 
-        for entity in target_vales:
+        valve_component = hass.data.get(VALVE_DOMAIN)
+        switch_component = hass.data.get(SWITCH_DOMAIN)
+
+        for entity_id in entity_ids:
+            entity = None
+            if valve_component is not None:
+                entity = valve_component.get_entity(entity_id)
+            if entity is None and switch_component is not None:
+                entity = switch_component.get_entity(entity_id)
+            if entity is None:
+                _LOGGER.error("Entity not found: %s", entity_id)
+                continue
             if not hasattr(entity, method_name):
-                _LOGGER.error("Service not implemented: %s", method_name)
-                return
+                _LOGGER.error(
+                    "Service %s is not supported by entity %s",
+                    method_name,
+                    entity_id,
+                )
+                continue
             await getattr(entity, method_name)(**params)
 
     for service, details in SERVICE_TO_METHOD.items():
@@ -525,6 +535,20 @@ async def stop_watering(self) -> None:
         self._attr_is_closed = True
         await self._send_station_message(station_payload)
 
+    async def enable_rain_delay(self, hours: int = 24) -> None:
+        """Enable rain delay for the device."""
+        await self.coordinator.client.set_rain_delay(self._device_id, hours)
+
+    async def disable_rain_delay(self) -> None:
+        """Disable rain delay for the device."""
+        await self.coordinator.client.set_rain_delay(self._device_id, 0)
+
+    async def set_manual_preset_runtime(self, minutes: int) -> None:
+        """Set the default watering runtime for the device."""
+        await self.coordinator.client.set_manual_preset_runtime(
+            self._device_id, minutes
+        )
+
     async def async_open_valve(self) -> None:
         """Open the valve."""
         run_time = self._manual_preset_runtime / 60

tests/test_switch.py

@@ -40,6 +40,8 @@ def create_mock_coordinator(devices: dict, programs: dict) -> MagicMock:
     coordinator.client.send_message = AsyncMock()
     coordinator.client.update_program = AsyncMock()
     coordinator.client.update_device = AsyncMock()
+    coordinator.client.set_rain_delay = AsyncMock()
+    coordinator.client.set_manual_preset_runtime = AsyncMock()
     return coordinator
 
 
@@ -811,12 +813,10 @@ async def test_rain_delay_switch_turn_on(
         # Turn on the switch
         await switch.async_turn_on()
 
-        # Verify send_message was called with delay=24
-        mock_coordinator.client.send_message.assert_called_once()
-        payload = mock_coordinator.client.send_message.call_args[0][0]
-        assert payload["event"] == "rain_delay"
-        assert payload["device_id"] == TEST_DEVICE_ID
-        assert payload["delay"] == 24  # Default 24 hours
+        # Verify set_rain_delay was called with the default 24 hours
+        mock_coordinator.client.set_rain_delay.assert_called_once_with(
+            TEST_DEVICE_ID, 24
+        )
 
     async def test_rain_delay_switch_turn_off(
         self,
@@ -846,12 +846,8 @@ async def test_rain_delay_switch_turn_off(
         # Turn off the switch
         await switch.async_turn_off()
 
-        # Verify send_message was called with delay=0
-        coordinator.client.send_message.assert_called_once()
-        payload = coordinator.client.send_message.call_args[0][0]
-        assert payload["event"] == "rain_delay"
-        assert payload["device_id"] == TEST_DEVICE_ID
-        assert payload["delay"] == 0
+        # Verify set_rain_delay was called with 0 hours to disable
+        coordinator.client.set_rain_delay.assert_called_once_with(TEST_DEVICE_ID, 0)
 
     async def test_rain_delay_switch_websocket_event(
         self,

tests/test_valve.py

@@ -26,6 +26,8 @@ def create_mock_coordinator(devices: dict, programs: dict | None = None) -> Magi
     coordinator.client.send_message = AsyncMock()
     coordinator.client.get_landscape = AsyncMock()
     coordinator.client.update_landscape = AsyncMock()
+    coordinator.client.set_rain_delay = AsyncMock()
+    coordinator.client.set_manual_preset_runtime = AsyncMock()
     return coordinator
 
 
@@ -352,3 +354,93 @@ async def test_valve_with_landscape_data(
     attrs = valve.extra_state_attributes
     assert attrs.get("landscape_image") == "https://example.com/landscape.jpg"
     assert attrs.get("sprinkler_type") == "spray"
+
+
+async def test_valve_enable_rain_delay(
+    mock_sprinkler_device: BHyveDevice,
+    mock_zone_data: BHyveZone,
+) -> None:
+    """Test enabling rain delay via the valve service method."""
+    coordinator = create_mock_coordinator(
+        {
+            "test-device-123": {
+                "device": mock_sprinkler_device,
+                "history": [],
+                "landscapes": {},
+            }
+        }
+    )
+
+    valve = BHyveZoneValve(
+        coordinator=coordinator,
+        device=mock_sprinkler_device,
+        zone=mock_zone_data,
+        zone_name="Front Yard",
+        device_programs=[],
+    )
+
+    await valve.enable_rain_delay(hours=5)
+
+    coordinator.client.set_rain_delay.assert_called_once_with(
+        mock_sprinkler_device["id"], 5
+    )
+
+
+async def test_valve_disable_rain_delay(
+    mock_sprinkler_device: BHyveDevice,
+    mock_zone_data: BHyveZone,
+) -> None:
+    """Test disabling rain delay via the valve service method."""
+    coordinator = create_mock_coordinator(
+        {
+            "test-device-123": {
+                "device": mock_sprinkler_device,
+                "history": [],
+                "landscapes": {},
+            }
+        }
+    )
+
+    valve = BHyveZoneValve(
+        coordinator=coordinator,
+        device=mock_sprinkler_device,
+        zone=mock_zone_data,
+        zone_name="Front Yard",
+        device_programs=[],
+    )
+
+    await valve.disable_rain_delay()
+
+    coordinator.client.set_rain_delay.assert_called_once_with(
+        mock_sprinkler_device["id"], 0
+    )
+
+
+async def test_valve_set_manual_preset_runtime(
+    mock_sprinkler_device: BHyveDevice,
+    mock_zone_data: BHyveZone,
+) -> None:
+    """Test setting manual preset runtime via the valve service method."""
+    coordinator = create_mock_coordinator(
+        {
+            "test-device-123": {
+                "device": mock_sprinkler_device,
+                "history": [],
+                "landscapes": {},
+            }
+        }
+    )
+
+    valve = BHyveZoneValve(
+        coordinator=coordinator,
+        device=mock_sprinkler_device,
+        zone=mock_zone_data,
+        zone_name="Front Yard",
+        device_programs=[],
+    )
+
+    await valve.set_manual_preset_runtime(minutes=8)
+
+    coordinator.client.set_manual_preset_runtime.assert_called_once_with(
+        mock_sprinkler_device["id"], 8
+    )