Update Shelly coordinator coverage to 100% (home-assistant#157380)

Author: thecode

homeassistant/components/shelly/coordinator.py

@@ -79,6 +79,7 @@
     get_rpc_device_wakeup_period,
     get_rpc_ws_url,
     get_shelly_model_name,
+    is_rpc_ble_scanner_supported,
     update_device_fw_info,
 )
 
@@ -726,6 +727,7 @@ async def _async_connected(self) -> None:
         """Handle device connected."""
         async with self._connection_lock:
             if self.connected:  # Already connected
+                LOGGER.debug("Device %s already connected", self.name)
                 return
             self.connected = True
             try:
@@ -743,10 +745,7 @@ async def _async_run_connected_events(self) -> None:
         is updated.
         """
         if not self.sleep_period:
-            if (
-                self.config_entry.runtime_data.rpc_supports_scripts
-                and not self.config_entry.runtime_data.rpc_zigbee_firmware
-            ):
+            if is_rpc_ble_scanner_supported(self.config_entry):
                 await self._async_connect_ble_scanner()
         else:
             await self._async_setup_outbound_websocket()
@@ -776,6 +775,10 @@ async def _async_connect_ble_scanner(self) -> None:
         if await async_ensure_ble_enabled(self.device):
             # BLE enable required a reboot, don't bother connecting
             # the scanner since it will be disconnected anyway
+            LOGGER.debug(
+                "Device %s BLE enable required a reboot, skipping scanner connect",
+                self.name,
+            )
             return
         assert self.device_id is not None
         self._disconnected_callbacks.append(
@@ -844,21 +847,14 @@ async def shutdown(self) -> None:
         """Shutdown the coordinator."""
         if self.device.connected:
             try:
-                if not self.sleep_period:
+                if not self.sleep_period and is_rpc_ble_scanner_supported(
+                    self.config_entry
+                ):
                     await async_stop_scanner(self.device)
                 await super().shutdown()
             except InvalidAuthError:
                 self.config_entry.async_start_reauth(self.hass)
                 return
-            except RpcCallError as err:
-                # Ignore 404 (No handler for) error
-                if err.code != 404:
-                    LOGGER.debug(
-                        "Error during shutdown for device %s: %s",
-                        self.name,
-                        err.message,
-                    )
-                return
             except DeviceConnectionError as err:
                 # If the device is restarting or has gone offline before
                 # the ping/pong timeout happens, the shutdown command

homeassistant/components/shelly/utils.py

@@ -994,3 +994,11 @@ def async_migrate_rpc_virtual_components_unique_ids(
             }
 
     return None
+
+
+def is_rpc_ble_scanner_supported(entry: ConfigEntry) -> bool:
+    """Return true if BLE scanner is supported."""
+    return (
+        entry.runtime_data.rpc_supports_scripts
+        and not entry.runtime_data.rpc_zigbee_firmware
+    )

tests/components/shelly/test_coordinator.py

@@ -3,7 +3,7 @@
 from datetime import timedelta
 from unittest.mock import AsyncMock, Mock, call, patch
 
-from aioshelly.const import MODEL_BULB, MODEL_BUTTON1
+from aioshelly.const import MODEL_2PM_G3, MODEL_BULB, MODEL_BUTTON1
 from aioshelly.exceptions import DeviceConnectionError, InvalidAuthError
 from freezegun.api import FrozenDateTimeFactory
 import pytest
@@ -29,6 +29,8 @@
 from homeassistant.const import ATTR_DEVICE_ID, STATE_ON, STATE_UNAVAILABLE
 from homeassistant.core import Event, HomeAssistant, State
 from homeassistant.helpers import device_registry as dr, issue_registry as ir
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceRegistry
+from homeassistant.helpers.entity_registry import EntityRegistry
 
 from . import (
     MOCK_MAC,
@@ -40,7 +42,11 @@
     register_entity,
 )
 
-from tests.common import async_fire_time_changed, mock_restore_cache
+from tests.common import (
+    async_fire_time_changed,
+    async_load_json_object_fixture,
+    mock_restore_cache,
+)
 
 RELAY_BLOCK_ID = 0
 LIGHT_BLOCK_ID = 2
@@ -927,6 +933,7 @@ async def test_rpc_runs_connected_events_when_initialized(
     hass: HomeAssistant,
     mock_rpc_device: Mock,
     monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
     supports_scripts: bool,
     zigbee_firmware: bool,
     result: bool,
@@ -950,6 +957,13 @@ async def test_rpc_runs_connected_events_when_initialized(
     # BLE script list is called during connected events if device supports scripts
     # and Zigbee is disabled
     assert bool(call.script_list() in mock_rpc_device.mock_calls) == result
+    assert "Device Test name already connected" not in caplog.text
+
+    # Mock initialized event after already initialized
+    caplog.clear()
+    mock_rpc_device.mock_initialized()
+    await hass.async_block_till_done()
+    assert "Device Test name already connected" in caplog.text
 
 
 async def test_rpc_sleeping_device_unload_ignore_ble_scanner(
@@ -1139,3 +1153,70 @@ async def test_xmod_model_lookup(
     )
     assert device
     assert device.model == xmod_model
+
+
+async def test_sub_device_area_from_main_device(
+    hass: HomeAssistant,
+    mock_rpc_device: Mock,
+    entity_registry: EntityRegistry,
+    device_registry: DeviceRegistry,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test Shelly sub-device area is set to main device area when created."""
+    device_fixture = await async_load_json_object_fixture(hass, "2pm_gen3.json", DOMAIN)
+    monkeypatch.setattr(mock_rpc_device, "shelly", device_fixture["shelly"])
+    monkeypatch.setattr(mock_rpc_device, "status", device_fixture["status"])
+    monkeypatch.setattr(mock_rpc_device, "config", device_fixture["config"])
+
+    config_entry = await init_integration(
+        hass, gen=3, model=MODEL_2PM_G3, skip_setup=True
+    )
+
+    # create main device and set area
+    device_entry = device_registry.async_get_or_create(
+        config_entry_id=config_entry.entry_id,
+        name="Test name",
+        connections={(CONNECTION_NETWORK_MAC, MOCK_MAC)},
+        identifiers={(DOMAIN, MOCK_MAC)},
+        suggested_area="living_room",
+    )
+
+    await hass.config_entries.async_setup(config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    # verify sub-devices have the same area as main device
+    for relay_index in range(2):
+        entity_id = f"switch.test_name_switch_{relay_index}"
+        assert hass.states.get(entity_id) is not None
+        entry = entity_registry.async_get(entity_id)
+        assert entry
+
+        device_entry = device_registry.async_get(entry.device_id)
+        assert device_entry
+        assert device_entry.area_id == "living_room"
+
+
+@pytest.mark.parametrize("restart_required", [True, False])
+async def test_rpc_ble_scanner_enable_reboot(
+    hass: HomeAssistant,
+    mock_rpc_device,
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+    restart_required: bool,
+) -> None:
+    """Test RPC BLE scanner enabling requires reboot."""
+    monkeypatch.setattr(
+        mock_rpc_device,
+        "ble_getconfig",
+        AsyncMock(return_value={"enable": False}),
+    )
+    monkeypatch.setattr(
+        mock_rpc_device,
+        "ble_setconfig",
+        AsyncMock(return_value={"restart_required": restart_required}),
+    )
+    await init_integration(
+        hass, 2, options={CONF_BLE_SCANNER_MODE: BLEScannerMode.ACTIVE}
+    )
+    assert bool("BLE enable required a reboot" in caplog.text) == restart_required
+    assert mock_rpc_device.trigger_reboot.call_count == int(restart_required)