fix: sync manager stuck in LOADING for disabled slots (#1085)

Author: raman325

custom_components/lock_code_manager/sync.py

@@ -238,21 +238,38 @@ def _ensure_entities_ready(self) -> bool:
         """Ensure all dependent entities exist with valid states.
 
         The name entity (CONF_NAME) is optional — STATE_UNKNOWN is its
-        normal state when no name is configured, so we only block on
-        STATE_UNAVAILABLE for it.
+        normal state when no name is configured.
+
+        When the slot is inactive (active entity is OFF), PIN and code
+        sensor entities are allowed to be STATE_UNKNOWN since the sync
+        manager only needs to know the slot is off to proceed (clear or
+        confirm already cleared). This prevents disabled slots from
+        being stuck in LOADING forever.
         """
+        # Collect all states in a single pass
+        states: dict[str, str | None] = {}
         for key in (CONF_PIN, CONF_NAME, ATTR_ACTIVE, ATTR_CODE):
             if key not in self._entity_id_map:
                 return False
             state = self._get_entity_state(key)
             if state is None or state == STATE_UNAVAILABLE:
                 _LOGGER.debug("%s: Waiting for %s state", self._log_prefix, key)
                 return False
-            # Name is optional — STATE_UNKNOWN is valid (no name configured).
-            # All other entities must have a definite state.
-            if key != CONF_NAME and state == STATE_UNKNOWN:
+            states[key] = state
+
+        # Active entity must always have a definite state
+        if states[ATTR_ACTIVE] == STATE_UNKNOWN:
+            _LOGGER.debug("%s: Waiting for %s state", self._log_prefix, ATTR_ACTIVE)
+            return False
+
+        # Name is always optional (STATE_UNKNOWN = no name configured)
+        # PIN and code sensor can be unknown when the slot is inactive
+        slot_inactive = states[ATTR_ACTIVE] == STATE_OFF
+        for key in (CONF_PIN, ATTR_CODE):
+            if states[key] == STATE_UNKNOWN and not slot_inactive:
                 _LOGGER.debug("%s: Waiting for %s state", self._log_prefix, key)
                 return False
+
         return True
 
     def _resolve_slot_state(self) -> SlotState | None:

tests/test_sync.py

@@ -7,7 +7,7 @@
 
 import pytest
 
-from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.issue_registry import (
     IssueSeverity,
@@ -25,7 +25,7 @@
 from custom_components.lock_code_manager.models import SlotCode, SyncState
 from custom_components.lock_code_manager.sync import SlotState, SlotSyncManager
 
-from .common import SLOT_1_IN_SYNC_ENTITY
+from .common import SLOT_1_ACTIVE_ENTITY, SLOT_1_IN_SYNC_ENTITY, SLOT_1_PIN_ENTITY
 from .conftest import async_trigger_sync_tick, get_in_sync_entity_obj
 
 
@@ -426,6 +426,64 @@ async def test_loading_to_out_of_sync(
         await async_trigger_sync_tick(hass, SLOT_1_IN_SYNC_ENTITY, set_dirty=False)
         assert manager._state is SyncState.OUT_OF_SYNC
 
+    async def test_disabled_slot_with_unknown_pin_exits_loading(
+        self,
+        hass: HomeAssistant,
+        mock_lock_config_entry,
+        lock_code_manager_config_entry,
+    ) -> None:
+        """Disabled slot with unknown PIN/code transitions out of LOADING."""
+        entity_obj = get_in_sync_entity_obj(hass, SLOT_1_IN_SYNC_ENTITY)
+        manager = entity_obj._sync_manager
+        manager._state = SyncState.LOADING
+
+        # Simulate disabled slot: active=off, PIN unknown
+        hass.states.async_set(SLOT_1_ACTIVE_ENTITY, STATE_OFF)
+        hass.states.async_set(SLOT_1_PIN_ENTITY, STATE_UNKNOWN)
+        # Coordinator has slot as EMPTY (no code on lock)
+        manager._coordinator.data[1] = SlotCode.EMPTY
+
+        await async_trigger_sync_tick(hass, SLOT_1_IN_SYNC_ENTITY, set_dirty=False)
+
+        # Should transition to IN_SYNC (slot off, code empty = in sync)
+        assert manager._state is SyncState.IN_SYNC
+
+    async def test_active_unknown_stays_in_loading(
+        self,
+        hass: HomeAssistant,
+        mock_lock_config_entry,
+        lock_code_manager_config_entry,
+    ) -> None:
+        """Slot stays in LOADING when active entity is STATE_UNKNOWN."""
+        entity_obj = get_in_sync_entity_obj(hass, SLOT_1_IN_SYNC_ENTITY)
+        manager = entity_obj._sync_manager
+        manager._state = SyncState.LOADING
+
+        hass.states.async_set(SLOT_1_ACTIVE_ENTITY, STATE_UNKNOWN)
+        manager._coordinator.data[1] = SlotCode.EMPTY
+
+        await async_trigger_sync_tick(hass, SLOT_1_IN_SYNC_ENTITY, set_dirty=False)
+        assert manager._state is SyncState.LOADING
+
+    async def test_enabled_slot_with_unknown_pin_stays_in_loading(
+        self,
+        hass: HomeAssistant,
+        mock_lock_config_entry,
+        lock_code_manager_config_entry,
+    ) -> None:
+        """Enabled slot with unknown PIN stays in LOADING (needs PIN to sync)."""
+        entity_obj = get_in_sync_entity_obj(hass, SLOT_1_IN_SYNC_ENTITY)
+        manager = entity_obj._sync_manager
+        manager._state = SyncState.LOADING
+
+        # Active=on but PIN unknown — can't sync without knowing what PIN to set
+        hass.states.async_set(SLOT_1_ACTIVE_ENTITY, STATE_ON)
+        hass.states.async_set(SLOT_1_PIN_ENTITY, STATE_UNKNOWN)
+        manager._coordinator.data[1] = SlotCode.EMPTY
+
+        await async_trigger_sync_tick(hass, SLOT_1_IN_SYNC_ENTITY, set_dirty=False)
+        assert manager._state is SyncState.LOADING
+
     async def test_loading_to_synced(
         self,
         hass: HomeAssistant,