Handle more update scenarios (#66)

Author: raman325

custom_components/lock_code_manager/__init__.py

@@ -281,7 +281,8 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
 
 async def async_update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
     """Update listener."""
-    # No need to update if the options match the data
+    # No need to update if there are no options because that only happens at the end
+    # of this function
     if not config_entry.options:
         return
 

custom_components/lock_code_manager/binary_sensor.py

@@ -38,6 +38,7 @@
 from .coordinator import LockUsercodeUpdateCoordinator
 from .entity import BaseLockCodeManagerEntity
 from .exceptions import EntityNotFoundError
+from .providers import BaseLock
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -92,10 +93,21 @@ def __init__(
         )
         self.coordinators = coordinators
         self._entity_id_map: dict[str, str] = {}
-        self._update_usercodes_task: asyncio.Task | None = None
         self._issue_reg: ir.IssueRegistry | None = None
         self._call_later_unsub: Callable | None = None
 
+    def _lock_slot_sensor_state(self, lock: BaseLock) -> str:
+        """Return lock slot sensor entity ID."""
+        if not (
+            entity_id := self.ent_reg.async_get_entity_id(
+                SENSOR_DOMAIN,
+                DOMAIN,
+                f"{self.base_unique_id}|{self.slot_num}|{ATTR_CODE}|{lock.lock.entity_id}",
+            )
+        ) or not (state := self.hass.states.get(entity_id)):
+            raise EntityNotFoundError(lock, self.slot_num, ATTR_CODE)
+        return state.state
+
     async def async_update_usercodes(
         self, states: dict[str, dict[str, str]] | None = None
     ) -> None:
@@ -115,15 +127,7 @@ async def async_update_usercodes(
             )
         )
         for lock in self.locks:
-            lock_slot_sensor_entity_id = self.ent_reg.async_get_entity_id(
-                SENSOR_DOMAIN,
-                DOMAIN,
-                f"{self.base_unique_id}|{self.slot_num}|{ATTR_CODE}|{lock.lock.entity_id}",
-            )
-
-            if not lock_slot_sensor_entity_id:
-                raise EntityNotFoundError(lock_slot_sensor_entity_id)
-
+            lock_slot_sensor_state = self._lock_slot_sensor_state(lock)
             if self.is_on:
                 name_entity_id = self._entity_id_map[CONF_NAME]
                 name_state = self.hass.states.get(name_entity_id)
@@ -138,9 +142,7 @@ async def async_update_usercodes(
                     if not state:
                         raise ValueError(f"State not found for {entity_id}")
 
-                if (
-                    state := self.hass.states.get(lock_slot_sensor_entity_id)
-                ) and state.state == pin_state.state:
+                if lock_slot_sensor_state == pin_state.state:
                     continue
 
                 _LOGGER.info(
@@ -155,9 +157,10 @@ async def async_update_usercodes(
                     int(self.slot_num), pin_state.state, name_state.state
                 )
             else:
-                if (
-                    state := self.hass.states.get(lock_slot_sensor_entity_id)
-                ) and state.state in ("", STATE_UNKNOWN):
+                if lock_slot_sensor_state in (
+                    "",
+                    STATE_UNKNOWN,
+                ):
                     continue
 
                 _LOGGER.info(
@@ -198,7 +201,7 @@ async def _update_state(self, _: datetime | None = None) -> None:
 
         states: dict[str, dict[str, str]] = {}
         for key, entity_id in entity_id_map.items():
-            if key in (EVENT_PIN_USED, CONF_NAME, CONF_PIN):
+            if key in (EVENT_PIN_USED, CONF_NAME):
                 continue
             issue_id = f"{self.config_entry.entry_id}_{self.slot_num}_no_{key}"
             if not (state := self.hass.states.get(entity_id)):
@@ -225,19 +228,33 @@ async def _update_state(self, _: datetime | None = None) -> None:
         self._attr_is_on = bool(
             states
             and all(
-                (key != CONF_NUMBER_OF_USES and state["state"] == STATE_ON)
+                (
+                    key not in (CONF_NUMBER_OF_USES, CONF_PIN)
+                    and state["state"] == STATE_ON
+                )
                 or (
                     key == CONF_NUMBER_OF_USES
                     and state["state"] not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
                     and int(float(state["state"])) > 0
                 )
                 for key, state in states.items()
+                if key != CONF_PIN
             )
         )
 
-        if not (
-            state := self.hass.states.get(self.entity_id)
-        ) or state.state != self.state:
+        # If the state of the binary sensor has changed, or the binary sensor is on and
+        # the desired PIN state has changed, update the usercodes
+        if (
+            not (state := self.hass.states.get(self.entity_id))
+            or state.state != self.state
+            or (
+                self.is_on
+                and any(
+                    self._lock_slot_sensor_state(lock) != states[CONF_PIN]["state"]
+                    for lock in self.locks
+                )
+            )
+        ):
             try:
                 await self.async_update_usercodes(states)
             except EntityNotFoundError:
@@ -248,6 +265,14 @@ async def _update_state(self, _: datetime | None = None) -> None:
                 return
             self.async_write_ha_state()
 
+    async def _config_entry_update_listener(
+        self, hass: HomeAssistant, config_entry: ConfigEntry
+    ) -> None:
+        """Update listener."""
+        if config_entry.options:
+            return
+        await self._update_state()
+
     async def _remove_keys_to_track(self, keys: list[str]) -> None:
         """Remove keys to track."""
         for key in keys:
@@ -266,20 +291,16 @@ async def _add_keys_to_track(self, keys: list[str]) -> None:
             )
         await self._update_state()
 
-    async def _handle_state_changes(self, entity_id: str, _: State, __: State) -> None:
-        """Handle state change."""
-        entity_id_map = self._entity_id_map.copy()
-        if self._calendar_entity_id:
-            entity_id_map[CONF_CALENDAR] = self._calendar_entity_id
-        if any(
-            entity_id == key_entity_id
-            for key, key_entity_id in entity_id_map.items()
-            if key not in (EVENT_PIN_USED, CONF_NAME, CONF_PIN)
-        ):
+    async def _handle_calendar_state_changes(
+        self, entity_id: str, _: State, __: State
+    ) -> None:
+        """Handle calendar state changes."""
+        if entity_id == self._calendar_entity_id:
             await self._update_state()
 
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""
+        await asyncio.sleep(0)
         if self._call_later_unsub:
             self._call_later_unsub()
             self._call_later_unsub = None
@@ -317,5 +338,11 @@ async def async_added_to_hass(self) -> None:
         )
 
         self.async_on_remove(
-            async_track_state_change(self.hass, MATCH_ALL, self._handle_state_changes)
+            async_track_state_change(
+                self.hass, MATCH_ALL, self._handle_calendar_state_changes
+            )
+        )
+
+        self.async_on_remove(
+            self.config_entry.add_update_listener(self._config_entry_update_listener)
         )

custom_components/lock_code_manager/entity.py

@@ -67,7 +67,6 @@ def __init__(
         self.ent_reg = ent_reg
 
         self._uid_cache: dict[str, str] = {}
-        self._entity_id_map: dict[str, str] = {}
         self._unsub_initial_state: CALLBACK_TYPE | None = None
 
         key_parts = key.lower().split("_")

custom_components/lock_code_manager/exceptions.py

@@ -2,8 +2,13 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from homeassistant.exceptions import HomeAssistantError
 
+if TYPE_CHECKING:
+    from .providers import BaseLock
+
 
 class LockCodeManagerError(HomeAssistantError):
     """Base class for lock_code_manager exceptions."""
@@ -12,10 +17,12 @@ class LockCodeManagerError(HomeAssistantError):
 class EntityNotFoundError(LockCodeManagerError):
     """Raise when en entity is not found."""
 
-    def __init__(self, entity_id: str):
+    def __init__(self, lock: BaseLock, slot_num: int, key: str):
         """Initialize the error."""
-        self.entity_id = entity_id
-        super().__init__(f"Entity not found: {entity_id}")
+        self.lock = lock
+        self.key = key
+        self.slot_num = slot_num
+        super().__init__(f"Entity not found for lock {lock} slot {slot_num} key {key}")
 
 
 class LockDisconnected(LockCodeManagerError):

tests/common.py

@@ -36,7 +36,7 @@
             CONF_PIN: "5678",
             CONF_ENABLED: True,
             CONF_NUMBER_OF_USES: 5,
-            CONF_CALENDAR: "calendar.test",
+            CONF_CALENDAR: "calendar.test_1",
         },
     },
 }

tests/conftest.py

@@ -103,15 +103,18 @@ async def async_setup_entry_lock_platform(
         MockPlatform(async_setup_entry=async_setup_entry_lock_platform),
     )
 
-    calendar = hass.data["lock_code_manager_calendar"] = MockCalendarEntity("test")
+    calendars = hass.data["lock_code_manager_calendars"] = [
+        MockCalendarEntity("test_1"),
+        MockCalendarEntity("test_2"),
+    ]
 
     async def async_setup_entry_calendar_platform(
         hass: HomeAssistant,
         config_entry: ConfigEntry,
         async_add_entities: AddEntitiesCallback,
     ) -> None:
         """Set up test calendar platform via config entry."""
-        async_add_entities([calendar])
+        async_add_entities(calendars)
 
     mock_platform(
         hass,

tests/test_binary_sensor.py

@@ -1,23 +1,38 @@
-"""Test sensor platform."""
+"""Test binary sensor platform."""
 
+import copy
 from datetime import timedelta
 import logging
 
 from homeassistant.components.number import (
     ATTR_VALUE,
     DOMAIN as NUMBER_DOMAIN,
-    SERVICE_SET_VALUE,
+    SERVICE_SET_VALUE as NUMBER_SERVICE_SET_VALUE,
 )
 from homeassistant.components.switch import (
     DOMAIN as SWITCH_DOMAIN,
     SERVICE_TURN_OFF,
     SERVICE_TURN_ON,
 )
+from homeassistant.components.text import (
+    DOMAIN as TEXT_DOMAIN,
+    SERVICE_SET_VALUE as TEXT_SERVICE_SET_VALUE,
+)
 from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
 from homeassistant.util import dt as dt_util
 
-from .common import ENABLED_ENTITY, NUMBER_OF_USES_ENTITY, PIN_SYNCED_ENTITY
+from custom_components.lock_code_manager.const import CONF_CALENDAR, CONF_SLOTS
+
+from .common import (
+    BASE_CONFIG,
+    ENABLED_ENTITY,
+    LOCK_1_ENTITY_ID,
+    LOCK_DATA,
+    NUMBER_OF_USES_ENTITY,
+    PIN_ENTITY,
+    PIN_SYNCED_ENTITY,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,7 +43,8 @@ async def test_binary_sensor_entity(
     lock_code_manager_config_entry,
 ):
     """Test sensor entity."""
-    state = hass.states.get("calendar.test")
+    calendar_1, calendar_2 = hass.data["lock_code_manager_calendars"]
+    state = hass.states.get("calendar.test_1")
     assert state
     assert state.state == STATE_OFF
 
@@ -40,25 +56,21 @@ async def test_binary_sensor_entity(
     start = now - timedelta(hours=1)
     end = now + timedelta(hours=1)
 
-    cal_event = hass.data["lock_code_manager_calendar"].create_event(
-        dtstart=start, dtend=end, summary="test"
-    )
+    cal_event = calendar_1.create_event(dtstart=start, dtend=end, summary="test")
     await hass.async_block_till_done()
 
     state = hass.states.get(PIN_SYNCED_ENTITY)
     assert state
     assert state.state == STATE_ON
 
-    hass.data["lock_code_manager_calendar"].delete_event(cal_event.uid)
+    calendar_1.delete_event(cal_event.uid)
     await hass.async_block_till_done()
 
     state = hass.states.get(PIN_SYNCED_ENTITY)
     assert state
     assert state.state == STATE_OFF
 
-    hass.data["lock_code_manager_calendar"].create_event(
-        dtstart=start, dtend=end, summary="test"
-    )
+    calendar_1.create_event(dtstart=start, dtend=end, summary="test")
     await hass.async_block_till_done()
 
     state = hass.states.get(PIN_SYNCED_ENTITY)
@@ -67,7 +79,7 @@ async def test_binary_sensor_entity(
 
     await hass.services.async_call(
         NUMBER_DOMAIN,
-        SERVICE_SET_VALUE,
+        NUMBER_SERVICE_SET_VALUE,
         service_data={ATTR_VALUE: "0"},
         target={ATTR_ENTITY_ID: NUMBER_OF_USES_ENTITY},
         blocking=True,
@@ -80,7 +92,7 @@ async def test_binary_sensor_entity(
 
     await hass.services.async_call(
         NUMBER_DOMAIN,
-        SERVICE_SET_VALUE,
+        NUMBER_SERVICE_SET_VALUE,
         service_data={ATTR_VALUE: "5"},
         target={ATTR_ENTITY_ID: NUMBER_OF_USES_ENTITY},
         blocking=True,
@@ -114,3 +126,28 @@ async def test_binary_sensor_entity(
     state = hass.states.get(PIN_SYNCED_ENTITY)
     assert state
     assert state.state == STATE_ON
+
+    await hass.services.async_call(
+        TEXT_DOMAIN,
+        TEXT_SERVICE_SET_VALUE,
+        service_data={ATTR_VALUE: "0987"},
+        target={ATTR_ENTITY_ID: PIN_ENTITY},
+        blocking=True,
+    )
+    await hass.async_block_till_done()
+
+    assert hass.data[LOCK_DATA][LOCK_1_ENTITY_ID]["service_calls"]["set_usercode"] == [
+        (2, "0987", "test2")
+    ]
+
+    new_config = copy.deepcopy(BASE_CONFIG)
+    new_config[CONF_SLOTS][2][CONF_CALENDAR] = "calendar.test_2"
+
+    hass.config_entries.async_update_entry(
+        lock_code_manager_config_entry, options=new_config
+    )
+    await hass.async_block_till_done()
+
+    state = hass.states.get(PIN_SYNCED_ENTITY)
+    assert state
+    assert state.state == STATE_OFF

tests/test_websocket.py

@@ -34,7 +34,7 @@ async def test_get_slot_calendar_data(
     assert msg["success"]
     assert msg["result"] == {
         CONF_LOCKS: [LOCK_1_ENTITY_ID, LOCK_2_ENTITY_ID],
-        CONF_SLOTS: {"1": None, "2": "calendar.test"},
+        CONF_SLOTS: {"1": None, "2": "calendar.test_1"},
     }
 
     # Try API call with entry title
@@ -49,7 +49,7 @@ async def test_get_slot_calendar_data(
     assert msg["success"]
     assert msg["result"] == {
         CONF_LOCKS: [LOCK_1_ENTITY_ID, LOCK_2_ENTITY_ID],
-        CONF_SLOTS: {"1": None, "2": "calendar.test"},
+        CONF_SLOTS: {"1": None, "2": "calendar.test_1"},
     }
 
     # Try API call with invalid entry ID