Enhance CalendarEventBinarySensor to manage scheduled updates and cancel pending calls on entity disable; update tests for new functionality

andrew-codechimp · andrew-codechimp · commit bf71cdb5db21 · 2025-08-07T16:18:52.000Z
diff --git a/custom_components/calendar_event/binary_sensor.py b/custom_components/calendar_event/binary_sensor.py
@@ -87,6 +87,7 @@ def __init__(
 
         self._attr_is_on = False
         self._attr_extra_state_attributes = {}
+        self._call_later_handle = None
 
     async def async_added_to_hass(self) -> None:
         """Handle added to Hass."""
@@ -99,6 +100,17 @@ async def async_added_to_hass(self) -> None:
 
         await self._update_state()
 
+    def _cancel_call_later(self) -> None:
+        """Cancel any pending call_later."""
+        if self._call_later_handle is not None:
+            self._call_later_handle.cancel()
+            self._call_later_handle = None
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle entity removal."""
+        self._cancel_call_later()
+        await super().async_will_remove_from_hass()
+
     @callback
     async def _state_changed(self, event: Event) -> None:
         """Handle calendar entity state changes."""
@@ -138,10 +150,13 @@ async def _update_state(self) -> None:
 
         self.async_write_ha_state()
 
-        if calendar_state.state == "on":
+        self._cancel_call_later()
+
+        # Schedule next update only if calendar is on and entity is enabled
+        if calendar_state.state == "on" and self.enabled:
             now = datetime.now()
             seconds_until_next_minute = 60 - now.second
-            self._hass.loop.call_later(
+            self._call_later_handle = self._hass.loop.call_later(
                 seconds_until_next_minute,
                 lambda: self._hass.async_create_task(self._update_state()),
             )
diff --git a/requirements.txt b/requirements.txt
@@ -1,4 +1,4 @@
 colorlog==6.9.0
-homeassistant==2025.7.0
+homeassistant==2025.8.0
 pip>=21.0,<25.3
 ruff==0.11.13
diff --git a/tests/test_binary_sensor.py b/tests/test_binary_sensor.py
@@ -1,6 +1,6 @@
 """The test for the calendar_event binary sensor platform."""
 
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 from homeassistant.core import HomeAssistant
@@ -193,19 +193,24 @@ async def test_binary_sensor_calendar_unavailable(
         title="Test Unavailable",
     )
 
-    await setup_integration(hass, config_entry)
+    with patch(
+        "custom_components.calendar_event.binary_sensor.CalendarEventBinarySensor._get_event_matching_summary"
+    ) as mock_get_events:
+        mock_get_events.return_value = None
 
-    binary_sensor_entity_id = "binary_sensor.test_unavailable"
+        await setup_integration(hass, config_entry)
 
-    # Set calendar to unavailable (remove it from the state registry)
-    hass.states.async_remove(mock_calendar_entity.entity_id)
-    await hass.async_block_till_done()
+        binary_sensor_entity_id = "binary_sensor.test_unavailable"
+
+        # Set calendar to unavailable (remove it from the state registry)
+        hass.states.async_remove(mock_calendar_entity.entity_id)
+        await hass.async_block_till_done()
 
-    # Check binary sensor state
-    binary_sensor_state = hass.states.get(binary_sensor_entity_id)
-    assert binary_sensor_state is not None
-    assert binary_sensor_state.state == "off"
-    assert binary_sensor_state.attributes.get(ATTR_DESCRIPTION) == ""
+        # Check binary sensor state
+        binary_sensor_state = hass.states.get(binary_sensor_entity_id)
+        assert binary_sensor_state is not None
+        assert binary_sensor_state.state == "off"
+        assert binary_sensor_state.attributes.get(ATTR_DESCRIPTION) == ""
 
 
 async def test_binary_sensor_state_change_listener(
@@ -371,3 +376,195 @@ def test_matches_criteria_logic(
 
     result = sensor._matches_criteria(event_summary)
     assert result == expected_match
+
+
+async def test_binary_sensor_disabled_no_call_later(
+    hass: HomeAssistant,
+    mock_calendar_entity: er.RegistryEntry,
+) -> None:
+    """Test that disabled binary sensor does not schedule periodic updates."""
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={},
+        options={
+            "name": "Test Disabled",
+            CONF_CALENDAR_ENTITY_ID: mock_calendar_entity.entity_id,
+            CONF_SUMMARY: "meeting",
+            CONF_COMPARISON_METHOD: "contains",
+        },
+        title="Test Disabled",
+    )
+
+    with patch(
+        "custom_components.calendar_event.binary_sensor.CalendarEventBinarySensor._get_event_matching_summary"
+    ) as mock_get_events:
+        mock_get_events.return_value = {
+            "summary": "Team Meeting",
+            "description": "Test event description",
+        }
+
+        # Mock the call_later method to track if it's called
+        with patch.object(hass.loop, "call_later") as mock_call_later:
+            await setup_integration(hass, config_entry)
+
+            binary_sensor_entity_id = "binary_sensor.test_disabled"
+
+            # Get the binary sensor entity from the entity registry and disable it
+            entity_registry = er.async_get(hass)
+            entity_entry = entity_registry.async_get(binary_sensor_entity_id)
+            assert entity_entry is not None
+
+            # Disable the entity
+            entity_registry.async_update_entity(
+                entity_entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER
+            )
+            await hass.async_block_till_done()
+
+            # Reset the mock to clear any previous calls
+            mock_call_later.reset_mock()
+
+            # Set calendar to active state to trigger potential call_later
+            hass.states.async_set(
+                mock_calendar_entity.entity_id,
+                "on",
+                {"message": "Team Meeting", "description": "Test description"},
+            )
+            await hass.async_block_till_done()
+
+            # Verify that call_later was NOT called for the disabled entity
+            mock_call_later.assert_not_called()
+
+
+async def test_binary_sensor_enabled_schedules_call_later(
+    hass: HomeAssistant,
+    mock_calendar_entity: er.RegistryEntry,
+) -> None:
+    """Test that enabled binary sensor schedules periodic updates when calendar is on."""
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={},
+        options={
+            "name": "Test Enabled",
+            CONF_CALENDAR_ENTITY_ID: mock_calendar_entity.entity_id,
+            CONF_SUMMARY: "meeting",
+            CONF_COMPARISON_METHOD: "contains",
+        },
+        title="Test Enabled",
+    )
+
+    with patch(
+        "custom_components.calendar_event.binary_sensor.CalendarEventBinarySensor._get_event_matching_summary"
+    ) as mock_get_events:
+        mock_get_events.return_value = {
+            "summary": "Team Meeting",
+            "description": "Test event description",
+        }
+
+        # Mock the call_later method to track if it's called
+        with patch.object(hass.loop, "call_later") as mock_call_later:
+            await setup_integration(hass, config_entry)
+
+            binary_sensor_entity_id = "binary_sensor.test_enabled"
+
+            # Verify the entity is enabled by default
+            entity_registry = er.async_get(hass)
+            entity_entry = entity_registry.async_get(binary_sensor_entity_id)
+            assert entity_entry is not None
+            assert not entity_entry.disabled
+
+            # Reset the mock to clear any previous calls
+            mock_call_later.reset_mock()
+
+            # Set calendar to active state to trigger call_later
+            hass.states.async_set(
+                mock_calendar_entity.entity_id,
+                "on",
+                {"message": "Team Meeting", "description": "Test description"},
+            )
+            await hass.async_block_till_done()
+
+            # Verify that call_later WAS called for the enabled entity
+            mock_call_later.assert_called_once()
+
+            # Verify the call_later was scheduled with correct parameters
+            call_args = mock_call_later.call_args
+            assert len(call_args[0]) == 2  # delay and callback
+            delay = call_args[0][0]
+            assert isinstance(delay, (int, float))
+            assert 0 < delay <= 60  # Should be between 0 and 60 seconds
+
+
+async def test_binary_sensor_cancels_call_later_when_disabled(
+    hass: HomeAssistant,
+    mock_calendar_entity: er.RegistryEntry,
+) -> None:
+    """Test that binary sensor cancels call_later when entity is disabled during runtime."""
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={},
+        options={
+            "name": "Test Cancel",
+            CONF_CALENDAR_ENTITY_ID: mock_calendar_entity.entity_id,
+            CONF_SUMMARY: "meeting",
+            CONF_COMPARISON_METHOD: "contains",
+        },
+        title="Test Cancel",
+    )
+
+    with patch(
+        "custom_components.calendar_event.binary_sensor.CalendarEventBinarySensor._get_event_matching_summary"
+    ) as mock_get_events:
+        mock_get_events.return_value = {
+            "summary": "Team Meeting",
+            "description": "Test event description",
+        }
+
+        await setup_integration(hass, config_entry)
+
+        binary_sensor_entity_id = "binary_sensor.test_cancel"
+
+        # Get the entity registry
+        entity_registry = er.async_get(hass)
+        entity_entry = entity_registry.async_get(binary_sensor_entity_id)
+        assert entity_entry is not None
+
+        # Create a mock handle to track cancellation
+        mock_handle = MagicMock()
+
+        with patch.object(
+            hass.loop, "call_later", return_value=mock_handle
+        ) as mock_call_later:
+            # Set calendar to active state to trigger call_later
+            hass.states.async_set(
+                mock_calendar_entity.entity_id,
+                "on",
+                {"message": "Team Meeting", "description": "Test description"},
+            )
+            await hass.async_block_till_done()
+
+            # Verify call_later was called and handle was stored
+            mock_call_later.assert_called_once()
+
+            # Reset mock to clear call
+            mock_call_later.reset_mock()
+
+            # Now disable the entity
+            entity_registry.async_update_entity(
+                entity_entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER
+            )
+            await hass.async_block_till_done()
+
+            # Trigger another calendar state change
+            hass.states.async_set(
+                mock_calendar_entity.entity_id,
+                "on",
+                {"message": "Another Meeting", "description": "Test description 2"},
+            )
+            await hass.async_block_till_done()
+
+            # Verify the previous handle was cancelled and no new call_later was scheduled
+            mock_handle.cancel.assert_called_once()
+            mock_call_later.assert_not_called()
