Bump pylamarzocco to 2.2.0 (home-assistant#156667)

Author: zweckj

homeassistant/components/lamarzocco/__init__.py

@@ -15,16 +15,20 @@
 from pylamarzocco.exceptions import AuthFail, RequestNotSuccessful
 from pylamarzocco.util import InstallationKey, generate_installation_key
 
-from homeassistant.components.bluetooth import async_discovered_service_info
+from homeassistant.components.bluetooth import (
+    async_ble_device_from_address,
+    async_discovered_service_info,
+)
 from homeassistant.const import (
     CONF_MAC,
     CONF_PASSWORD,
     CONF_TOKEN,
     CONF_USERNAME,
+    EVENT_HOMEASSISTANT_STOP,
     Platform,
     __version__,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
@@ -99,7 +103,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
     # initialize Bluetooth
     bluetooth_client: LaMarzoccoBluetoothClient | None = None
     if entry.options.get(CONF_USE_BLUETOOTH, True) and (
-        token := settings.ble_auth_token
+        token := (entry.data.get(CONF_TOKEN) or settings.ble_auth_token)
     ):
         if CONF_MAC not in entry.data:
             for discovery_info in async_discovered_service_info(hass):
@@ -108,7 +112,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
                     and name.startswith(BT_MODEL_PREFIXES)
                     and name.split("_")[1] == serial
                 ):
-                    _LOGGER.debug("Found Bluetooth device, configuring with Bluetooth")
+                    _LOGGER.info("Found lamarzocco Bluetooth device, adding to entry")
                     # found a device, add MAC address to config entry
                     hass.config_entries.async_update_entry(
                         entry,
@@ -118,22 +122,29 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
                         },
                     )
 
-        if not entry.data[CONF_TOKEN]:
-            # update the token in the config entry
-            hass.config_entries.async_update_entry(
-                entry,
-                data={
-                    **entry.data,
-                    CONF_TOKEN: token,
-                },
-            )
-
         if CONF_MAC in entry.data:
-            _LOGGER.debug("Initializing Bluetooth device")
-            bluetooth_client = LaMarzoccoBluetoothClient(
-                address_or_ble_device=entry.data[CONF_MAC],
-                ble_token=token,
-            )
+            ble_device = async_ble_device_from_address(hass, entry.data[CONF_MAC])
+            if ble_device:
+                _LOGGER.info("Setting up lamarzocco with Bluetooth")
+                bluetooth_client = LaMarzoccoBluetoothClient(
+                    ble_device=ble_device,
+                    ble_token=token,
+                )
+
+                async def disconnect_bluetooth(_: Event) -> None:
+                    """Stop push updates when hass stops."""
+                    await bluetooth_client.disconnect()
+
+                entry.async_on_unload(
+                    hass.bus.async_listen_once(
+                        EVENT_HOMEASSISTANT_STOP, disconnect_bluetooth
+                    )
+                )
+                entry.async_on_unload(bluetooth_client.disconnect)
+            else:
+                _LOGGER.info(
+                    "Bluetooth device not found during lamarzocco setup, continuing with cloud only"
+                )
 
     device = LaMarzoccoMachine(
         serial_number=entry.unique_id,

homeassistant/components/lamarzocco/manifest.json

@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.1.3"]
+  "requirements": ["pylamarzocco==2.2.0"]
 }

requirements_all.txt

@@ -147,9 +147,7 @@ def mock_bluetooth(enable_bluetooth: None) -> None:
 @pytest.fixture
 def mock_ble_device() -> BLEDevice:
     """Return a mock BLE device."""
-    return BLEDevice(
-        "00:00:00:00:00:00", "GS_GS012345", details={"path": "path"}, rssi=50
-    )
+    return BLEDevice("00:00:00:00:00:00", "GS_GS012345", details={"path": "path"})
 
 
 @pytest.fixture

requirements_test_all.txt

@@ -3,6 +3,7 @@
 from datetime import timedelta
 from unittest.mock import AsyncMock, MagicMock, patch
 
+from bleak.backends.device import BLEDevice
 from freezegun.api import FrozenDateTimeFactory
 from pylamarzocco.const import FirmwareType, ModelName
 from pylamarzocco.exceptions import AuthFail, RequestNotSuccessful
@@ -196,11 +197,27 @@ async def test_config_flow_entry_migration_downgrade(
     assert not await hass.config_entries.async_setup(entry.entry_id)
 
 
+@pytest.mark.parametrize(
+    ("ble_device", "has_client"),
+    [
+        (None, False),
+        (
+            BLEDevice(
+                address="aa:bb:cc:dd:ee:ff",
+                name="name",
+                details={},
+            ),
+            True,
+        ),
+    ],
+)
 async def test_bluetooth_is_set_from_discovery(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_lamarzocco: MagicMock,
     mock_cloud_client: MagicMock,
+    ble_device: BLEDevice | None,
+    has_client: bool,
 ) -> None:
     """Check we can fill a device from discovery info."""
 
@@ -216,13 +233,17 @@ async def test_bluetooth_is_set_from_discovery(
         patch(
             "homeassistant.components.lamarzocco.LaMarzoccoMachine"
         ) as mock_machine_class,
+        patch(
+            "homeassistant.components.lamarzocco.async_ble_device_from_address",
+            return_value=ble_device,
+        ),
     ):
         mock_machine_class.return_value = mock_lamarzocco
         await async_init_integration(hass, mock_config_entry)
     discovery.assert_called_once()
     assert mock_machine_class.call_count == 1
     _, kwargs = mock_machine_class.call_args
-    assert kwargs["bluetooth_client"] is not None
+    assert (kwargs["bluetooth_client"] is not None) == has_client
 
     assert mock_config_entry.data[CONF_MAC] == service_info.address
     assert mock_config_entry.data[CONF_TOKEN] == "token"
@@ -314,6 +335,50 @@ async def test_device(
     assert device == snapshot
 
 
+async def test_disconnect_on_stop(
+    hass: HomeAssistant,
+    mock_lamarzocco: MagicMock,
+    mock_ble_device: BLEDevice,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test we close the connection with the La Marzocco when Home Assistants stops."""
+    mock_config_entry = MockConfigEntry(
+        title="My LaMarzocco",
+        domain=DOMAIN,
+        version=4,
+        data=USER_INPUT
+        | {
+            CONF_MAC: mock_ble_device.address,
+            CONF_TOKEN: "token",
+            CONF_INSTALLATION_KEY: MOCK_INSTALLATION_KEY,
+        },
+        unique_id=mock_lamarzocco.serial_number,
+    )
+
+    with (
+        patch(
+            "homeassistant.components.lamarzocco.async_ble_device_from_address",
+            return_value=mock_ble_device,
+        ),
+        patch(
+            "homeassistant.components.lamarzocco.LaMarzoccoBluetoothClient",
+            autospec=True,
+        ) as mock_bt_client_cls,
+    ):
+        mock_bt_client = mock_bt_client_cls.return_value
+        mock_bt_client.disconnect = AsyncMock()
+
+        await async_init_integration(hass, mock_config_entry)
+        await hass.async_block_till_done()
+
+        assert mock_config_entry.state is ConfigEntryState.LOADED
+
+        hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)
+        await hass.async_block_till_done()
+
+        mock_bt_client.disconnect.assert_awaited_once()
+
+
 async def test_websocket_reconnects_after_termination(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,