Add entity registry update handling to CalendarEventBinarySensor for timer cancellation; implement tests for disabled state behavior

Author: andrew-codechimp

custom_components/calendar_event/binary_sensor.py

@@ -9,6 +9,7 @@
 from homeassistant.const import EVENT_STATE_CHANGED
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.event import async_track_entity_registry_updated_event
 
 from .const import (
     ATTR_DESCRIPTION,
@@ -98,8 +99,30 @@ async def async_added_to_hass(self) -> None:
             self._hass.bus.async_listen(EVENT_STATE_CHANGED, self._state_changed)
         )
 
+        # Track entity registry updates to detect when entity is disabled/enabled
+        self.async_on_remove(
+            async_track_entity_registry_updated_event(
+                self._hass, self.entity_id, self._entity_registry_updated
+            )
+        )
+
         await self._update_state()
 
+    @callback
+    def _entity_registry_updated(self, event: Event) -> None:
+        """Handle entity registry update."""
+        # Cancel any pending timers if the entity is disabled
+        if not self.enabled:
+            self._cancel_call_later()
+
+    async def async_entity_registry_updated(self) -> None:
+        """Handle entity registry update."""
+        await super().async_entity_registry_updated()
+
+        # Cancel any pending timers if the entity is disabled
+        if not self.enabled:
+            self._cancel_call_later()
+
     def _cancel_call_later(self) -> None:
         """Cancel any pending call_later."""
         if self._call_later_handle is not None:
@@ -115,11 +138,21 @@ async def async_will_remove_from_hass(self) -> None:
     async def _state_changed(self, event: Event) -> None:
         """Handle calendar entity state changes."""
         if event.data.get("entity_id") == self._calendar_entity_id:
-            await self._update_state()
+            # Only update state if the entity is enabled
+            if self.enabled:
+                await self._update_state()
+            else:
+                # Cancel any pending timers if disabled
+                self._cancel_call_later()
 
     async def _update_state(self) -> None:
         """Update the binary sensor state based on calendar events."""
 
+        # Don't update if the entity is disabled
+        if not self.enabled:
+            self._cancel_call_later()
+            return
+
         calendar_state = self._hass.states.get(self._calendar_entity_id)
 
         if calendar_state is None:

tests/test_timer_cancellation.py

@@ -0,0 +1,145 @@
+"""Test timer cancellation when binary sensor is disabled."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_registry import RegistryEntry
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from custom_components.calendar_event.binary_sensor import CalendarEventBinarySensor
+
+
+@pytest.mark.asyncio
+async def test_timer_cancelled_when_entity_disabled_directly(
+    hass: HomeAssistant,
+) -> None:
+    """Test that pending timers are cancelled when entity is disabled."""
+
+    # Create a mock config entry
+    config_entry = MockConfigEntry(
+        domain="calendar_event",
+        options={
+            "calendar_entity": "calendar.test",
+            "summary": "Test",
+            "name": "Test",
+        },
+    )
+
+    # Create the entity
+    entity = CalendarEventBinarySensor(
+        hass=hass,
+        config_entry=config_entry,
+        name="Test",
+        unique_id="test_id",
+        calendar_entity_id="calendar.test",
+        summary="Test",
+        comparison_method="contains",
+    )
+
+    # Create a mock handle for the timer
+    mock_handle = MagicMock()
+    entity._call_later_handle = mock_handle
+
+    # Mock registry entry as disabled
+    mock_registry_entry = MagicMock(spec=RegistryEntry)
+    mock_registry_entry.disabled_by = "user"
+
+    with patch.object(entity, "registry_entry", mock_registry_entry):
+        # Simulate the entity registry update callback
+        mock_event = MagicMock()
+        entity._entity_registry_updated(mock_event)
+
+        # Verify the timer was cancelled
+        mock_handle.cancel.assert_called_once()
+        assert entity._call_later_handle is None
+
+
+@pytest.mark.asyncio
+async def test_timer_not_scheduled_when_disabled(hass: HomeAssistant) -> None:
+    """Test that no timers are scheduled when entity is disabled."""
+
+    # Create a mock config entry
+    config_entry = MockConfigEntry(
+        domain="calendar_event",
+        options={
+            "calendar_entity": "calendar.test",
+            "summary": "Test",
+            "name": "Test",
+        },
+    )
+
+    # Create the entity
+    entity = CalendarEventBinarySensor(
+        hass=hass,
+        config_entry=config_entry,
+        name="Test",
+        unique_id="test_id",
+        calendar_entity_id="calendar.test",
+        summary="Test",
+        comparison_method="contains",
+    )
+
+    # Mock registry entry as disabled
+    mock_registry_entry = MagicMock(spec=RegistryEntry)
+    mock_registry_entry.disabled_by = "user"
+
+    with (
+        patch.object(entity, "registry_entry", mock_registry_entry),
+        patch.object(hass.loop, "call_later") as mock_call_later,
+    ):
+        # Try to update state when disabled
+        await entity._update_state()
+
+        # Verify no timer was scheduled
+        mock_call_later.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_timer_cancelled_in_state_changed_when_disabled(
+    hass: HomeAssistant,
+) -> None:
+    """Test that timers are cancelled in state changed callback when disabled."""
+
+    # Create a mock config entry
+    config_entry = MockConfigEntry(
+        domain="calendar_event",
+        options={
+            "calendar_entity": "calendar.test",
+            "summary": "Test",
+            "name": "Test",
+        },
+    )
+
+    # Create the entity
+    entity = CalendarEventBinarySensor(
+        hass=hass,
+        config_entry=config_entry,
+        name="Test",
+        unique_id="test_id",
+        calendar_entity_id="calendar.test",
+        summary="Test",
+        comparison_method="contains",
+    )
+
+    # Create a mock handle for the timer
+    mock_handle = MagicMock()
+    entity._call_later_handle = mock_handle
+
+    # Mock registry entry as disabled
+    mock_registry_entry = MagicMock(spec=RegistryEntry)
+    mock_registry_entry.disabled_by = "user"
+
+    with patch.object(entity, "registry_entry", mock_registry_entry):
+        # Create a mock event for the calendar entity state change
+        mock_event = MagicMock()
+        mock_event.data = {"entity_id": "calendar.test"}
+
+        # Call the state changed callback
+        await entity._state_changed(mock_event)
+
+        # Verify the timer was cancelled
+        mock_handle.cancel.assert_called_once()
+        assert entity._call_later_handle is None