fix: fallback to the cached network information on failure (#606)

* fix: fallback to the cached network information when failing to lookup network info

* chore: Update roborock/devices/v1_channel.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: allenporter

roborock/devices/v1_channel.py

@@ -142,7 +142,7 @@ async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callab
         # Make an initial, optimistic attempt to connect to local with the
         # cache. The cache information will be refreshed by the background task.
         try:
-            await self._local_connect(use_cache=True)
+            await self._local_connect(prefer_cache=True)
         except RoborockException as err:
             _LOGGER.warning("Could not establish local connection for device %s: %s", self._device_uid, err)
 
@@ -175,33 +175,37 @@ def unsub() -> None:
         self._callback = callback
         return unsub
 
-    async def _get_networking_info(self, *, use_cache: bool = True) -> NetworkInfo:
+    async def _get_networking_info(self, *, prefer_cache: bool = True) -> NetworkInfo:
         """Retrieve networking information for the device.
 
         This is a cloud only command used to get the local device's IP address.
         """
         cache_data = await self._cache.get()
-        if use_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+        if prefer_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
             return network_info
         try:
             network_info = await self._mqtt_rpc_channel.send_command(
                 RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
             )
         except RoborockException as e:
+            _LOGGER.debug("Error fetching network info for device %s", self._device_uid)
+            if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+                _LOGGER.debug("Falling back to cached network info for device %s after error", self._device_uid)
+                return network_info
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
         _LOGGER.debug("Network info for device %s: %s", self._device_uid, network_info)
         self._last_network_info_refresh = datetime.datetime.now(datetime.UTC)
         cache_data.network_info[self._device_uid] = network_info
         await self._cache.set(cache_data)
         return network_info
 
-    async def _local_connect(self, *, use_cache: bool = True) -> None:
+    async def _local_connect(self, *, prefer_cache: bool = True) -> None:
         """Set up local connection if possible."""
         _LOGGER.debug(
-            "Attempting to connect to local channel for device %s (use_cache=%s)", self._device_uid, use_cache
+            "Attempting to connect to local channel for device %s (prefer_cache=%s)", self._device_uid, prefer_cache
         )
-        networking_info = await self._get_networking_info(use_cache=use_cache)
+        networking_info = await self._get_networking_info(prefer_cache=prefer_cache)
         host = networking_info.ip
         _LOGGER.debug("Connecting to local channel at %s", host)
         # Create a new local channel and connect
@@ -236,7 +240,7 @@ async def _background_reconnect(self) -> None:
                     reconnect_backoff = min(reconnect_backoff * RECONNECT_MULTIPLIER, MAX_RECONNECT_INTERVAL)
 
                 use_cache = self._should_use_cache(local_connect_failures)
-                await self._local_connect(use_cache=use_cache)
+                await self._local_connect(prefer_cache=use_cache)
                 # Reset backoff and failures on success
                 reconnect_backoff = MIN_RECONNECT_INTERVAL
                 local_connect_failures = 0

tests/devices/test_v1_channel.py

@@ -33,7 +33,7 @@
 TEST_DEVICE_UID = "abc123"
 TEST_LOCAL_KEY = "local_key"
 TEST_SECURITY_DATA = SecurityData(endpoint="test_endpoint", nonce=b"test_nonce_16byte")
-TEST_HOST = "1.1.1.1"
+TEST_HOST = mock_data.TEST_LOCAL_API_HOST
 
 
 # Test messages for V1 protocol
@@ -112,19 +112,26 @@ def setup_mock_map_decoder() -> Iterator[Mock]:
         yield mock_create_decoder
 
 
+@pytest.fixture(name="cache")
+def cache_fixtures() -> InMemoryCache:
+    """Mock cache for testing."""
+    return InMemoryCache()
+
+
 @pytest.fixture(name="v1_channel")
 def setup_v1_channel(
     mock_mqtt_channel: Mock,
     mock_local_session: Mock,
     mock_create_map_response_decoder: Mock,
+    cache: InMemoryCache,
 ) -> V1Channel:
     """Fixture to set up the V1 channel for tests."""
     return V1Channel(
         device_uid=TEST_DEVICE_UID,
         security_data=TEST_SECURITY_DATA,
         mqtt_channel=mock_mqtt_channel,
         local_session=mock_local_session,
-        cache=InMemoryCache(),
+        cache=cache,
     )
 
 
@@ -437,6 +444,35 @@ async def test_v1_channel_local_connect_network_info_failure(
         await v1_channel._local_connect()
 
 
+async def test_v1_channel_local_connect_network_info_failure_fallback_to_cache(
+    mock_mqtt_channel: FakeChannel,
+    mock_local_session: Mock,
+    v1_channel: V1Channel,
+    cache: InMemoryCache,
+) -> None:
+    """Test local connection falls back to cache when network info retrieval fails."""
+    # Create a cache with pre-populated network info
+    cache_data = CacheData()
+    cache_data.network_info[TEST_DEVICE_UID] = TEST_NETWORKING_INFO
+    await cache.set(cache_data)
+
+    # Setup: MQTT fails to publish
+    mock_mqtt_channel.publish_side_effect = RoborockException("Network info failed")
+
+    # Attempt local connect, forcing a refresh (prefer_cache=False)
+    # This should try MQTT, fail, and then fall back to cache
+    await v1_channel._local_connect(prefer_cache=False)
+
+    # Verify local connection was established
+    assert v1_channel.is_local_connected
+
+    # Verify MQTT was attempted (published message)
+    assert mock_mqtt_channel.published_messages
+
+    # Verify local session was created with the correct IP from cache
+    mock_local_session.assert_called_once_with(TEST_HOST)
+
+
 async def test_v1_channel_command_encoding_validation(
     v1_channel: V1Channel,
     mock_mqtt_channel: Mock,