Mark entity unavailable if data can't be fetched (home-assistant#156928)

Author: alengwenus

homeassistant/components/lcn/binary_sensor.py

@@ -73,14 +73,17 @@ def __init__(self, config: ConfigType, config_entry: LcnConfigEntry) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_binary_sensors(
-            SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_binary_sensors(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusBinSensors):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.bin_sensor_port.value)
         self.async_write_ha_state()

homeassistant/components/lcn/climate.py

@@ -171,20 +171,22 @@ async def async_set_temperature(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await asyncio.gather(
-            self.device_connection.request_status_variable(
-                self.variable, SCAN_INTERVAL.seconds
-            ),
-            self.device_connection.request_status_variable(
-                self.setpoint, SCAN_INTERVAL.seconds
-            ),
+        self._attr_available = any(
+            await asyncio.gather(
+                self.device_connection.request_status_variable(
+                    self.variable, SCAN_INTERVAL.seconds
+                ),
+                self.device_connection.request_status_variable(
+                    self.setpoint, SCAN_INTERVAL.seconds
+                ),
+            )
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set temperature value when LCN input object is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusVar):
             return
-
+        self._attr_available = True
         if input_obj.get_var() == self.variable:
             self._attr_current_temperature = float(
                 input_obj.get_value().to_var_unit(self.unit)

homeassistant/components/lcn/cover.py

@@ -133,13 +133,15 @@ async def async_stop_cover(self, **kwargs: Any) -> None:
     async def async_update(self) -> None:
         """Update the state of the entity."""
         if not self.device_connection.is_group:
-            await asyncio.gather(
-                self.device_connection.request_status_output(
-                    pypck.lcn_defs.OutputPort["OUTPUTUP"], SCAN_INTERVAL.seconds
-                ),
-                self.device_connection.request_status_output(
-                    pypck.lcn_defs.OutputPort["OUTPUTDOWN"], SCAN_INTERVAL.seconds
-                ),
+            self._attr_available = any(
+                await asyncio.gather(
+                    self.device_connection.request_status_output(
+                        pypck.lcn_defs.OutputPort["OUTPUTUP"], SCAN_INTERVAL.seconds
+                    ),
+                    self.device_connection.request_status_output(
+                        pypck.lcn_defs.OutputPort["OUTPUTDOWN"], SCAN_INTERVAL.seconds
+                    ),
+                )
             )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -149,7 +151,7 @@ def input_received(self, input_obj: InputType) -> None:
             or input_obj.get_output_id() not in self.output_ids
         ):
             return
-
+        self._attr_available = True
         if input_obj.get_percent() > 0:  # motor is on
             if input_obj.get_output_id() == self.output_ids[0]:
                 self._attr_is_opening = True
@@ -272,11 +274,12 @@ async def async_update(self) -> None:
                     self.motor, self.positioning_mode, SCAN_INTERVAL.seconds
                 )
             )
-        await asyncio.gather(*coros)
+        self._attr_available = any(await asyncio.gather(*coros))
 
     def input_received(self, input_obj: InputType) -> None:
         """Set cover states when LCN input object (command) is received."""
         if isinstance(input_obj, pypck.inputs.ModStatusRelays):
+            self._attr_available = True
             self._attr_is_opening = input_obj.is_opening(self.motor.value)
             self._attr_is_closing = input_obj.is_closing(self.motor.value)
 
@@ -293,6 +296,7 @@ def input_received(self, input_obj: InputType) -> None:
             )
             and input_obj.motor == self.motor.value
         ):
+            self._attr_available = True
             self._attr_current_cover_position = int(input_obj.position)
             if self._attr_current_cover_position in [0, 100]:
                 self._attr_is_opening = False

homeassistant/components/lcn/light.py

@@ -149,8 +149,11 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_output(
-            self.output, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_output(
+                self.output, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -200,12 +203,15 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set light state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.output.value)
         self.async_write_ha_state()

homeassistant/components/lcn/quality_scale.yaml

@@ -25,7 +25,7 @@ rules:
     status: exempt
     comment: Integration has no configuration parameters
   docs-installation-parameters: done
-  entity-unavailable: todo
+  entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done

homeassistant/components/lcn/sensor.py

@@ -133,8 +133,11 @@ def __init__(self, config: ConfigType, config_entry: LcnConfigEntry) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_variable(
-            self.variable, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_variable(
+                self.variable, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -144,7 +147,7 @@ def input_received(self, input_obj: InputType) -> None:
             or input_obj.get_var() != self.variable
         ):
             return
-
+        self._attr_available = True
         is_regulator = self.variable.name in SETPOINTS
         self._attr_native_value = input_obj.get_value().to_var_unit(
             self.unit, is_regulator
@@ -171,15 +174,18 @@ def __init__(self, config: ConfigType, config_entry: LcnConfigEntry) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_led_and_logic_ops(
-            SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_led_and_logic_ops(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusLedsAndLogicOps):
             return
-
+        self._attr_available = True
         if self.source in pypck.lcn_defs.LedPort:
             self._attr_native_value = input_obj.get_led_state(
                 self.source.value

homeassistant/components/lcn/switch.py

@@ -95,8 +95,11 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_output(
-            self.output, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_output(
+                self.output, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -106,7 +109,7 @@ def input_received(self, input_obj: InputType) -> None:
             or input_obj.get_output_id() != self.output.value
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_percent() > 0
         self.async_write_ha_state()
 
@@ -142,13 +145,16 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.output.value)
         self.async_write_ha_state()
 
@@ -183,8 +189,11 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_variable(
-            self.setpoint_variable, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_variable(
+                self.setpoint_variable, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -194,7 +203,7 @@ def input_received(self, input_obj: InputType) -> None:
             or input_obj.get_var() != self.setpoint_variable
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_value().is_locked_regulator()
         self.async_write_ha_state()
 
@@ -236,7 +245,12 @@ async def async_turn_off(self, **kwargs: Any) -> None:
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_locked_keys(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_locked_keys(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
@@ -245,6 +259,6 @@ def input_received(self, input_obj: InputType) -> None:
             or self.key not in pypck.lcn_defs.Key
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.table_id, self.key_id)
         self.async_write_ha_state()

tests/components/lcn/test_binary_sensor.py

@@ -2,18 +2,20 @@
 
 from unittest.mock import patch
 
+from freezegun.api import FrozenDateTimeFactory
 from pypck.inputs import ModStatusBinSensors
 from pypck.lcn_addr import LcnAddr
 from syrupy.assertion import SnapshotAssertion
 
+from homeassistant.components.lcn.binary_sensor import SCAN_INTERVAL
 from homeassistant.components.lcn.helpers import get_device_connection
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from .conftest import MockConfigEntry, init_integration
+from .conftest import MockConfigEntry, MockDeviceConnection, init_integration
 
-from tests.common import snapshot_platform
+from tests.common import async_fire_time_changed, snapshot_platform
 
 BINARY_SENSOR_SENSOR1 = "binary_sensor.testmodule_binary_sensor1"
 
@@ -61,6 +63,43 @@ async def test_pushed_binsensor_status_change(
     assert state.state == STATE_ON
 
 
+async def test_availability(
+    hass: HomeAssistant, freezer: FrozenDateTimeFactory, entry: MockConfigEntry
+) -> None:
+    """Test the availability of binary_sensor entity."""
+    await init_integration(hass, entry)
+
+    state = hass.states.get(BINARY_SENSOR_SENSOR1)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE
+
+    # no response from device -> unavailable
+    with patch.object(
+        MockDeviceConnection, "request_status_binary_sensors", return_value=None
+    ):
+        freezer.tick(SCAN_INTERVAL)
+        async_fire_time_changed(hass)
+        await hass.async_block_till_done(wait_background_tasks=True)
+
+    state = hass.states.get(BINARY_SENSOR_SENSOR1)
+    assert state is not None
+    assert state.state == STATE_UNAVAILABLE
+
+    # response from device -> available
+    with patch.object(
+        MockDeviceConnection,
+        "request_status_binary_sensors",
+        return_value=ModStatusBinSensors(LcnAddr(0, 7, False), [False] * 8),
+    ):
+        freezer.tick(SCAN_INTERVAL)
+        async_fire_time_changed(hass)
+        await hass.async_block_till_done(wait_background_tasks=True)
+
+    state = hass.states.get(BINARY_SENSOR_SENSOR1)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE
+
+
 async def test_unload_config_entry(hass: HomeAssistant, entry: MockConfigEntry) -> None:
     """Test the binary sensor is removed when the config entry is unloaded."""
     await init_integration(hass, entry)