Fix Improv BLE factory reset rediscovery (home-assistant#154354)

Author: bdraco

homeassistant/components/improv_ble/config_flow.py

@@ -138,11 +138,23 @@ def _abort_if_provisioned(self) -> None:
             _LOGGER.debug(
                 (
                     "Aborting improv flow, device with bluetooth address '%s' is "
-                    "already provisioned: %s"
+                    "already provisioned: %s; clearing match history to allow "
+                    "rediscovery if device is factory reset"
                 ),
                 self._discovery_info.address,
                 improv_service_data.state,
             )
+            # Clear match history so device can be rediscovered if factory reset.
+            # This is safe to do on every abort because:
+            # 1. While device stays provisioned, the Bluetooth matcher won't trigger
+            #    new discoveries since the advertisement content hasn't changed
+            # 2. If device is factory reset (state changes to authorized), the
+            #    matcher will see new content and trigger discovery since we cleared
+            #    the history
+            # 3. No ongoing monitoring or callbacks - zero performance overhead
+            bluetooth.async_clear_address_from_match_history(
+                self.hass, self._discovery_info.address
+            )
             raise AbortFlow("already_provisioned")
 
     @callback
@@ -180,6 +192,14 @@ async def async_step_bluetooth(
         self._abort_if_unique_id_configured()
         self._abort_if_provisioned()
 
+        # Clear match history at the start of discovery flow.
+        # This ensures that if the user never provisions the device and it
+        # disappears (powers down), the discovery flow gets cleaned up,
+        # and then the device comes back later, it can be rediscovered.
+        bluetooth.async_clear_address_from_match_history(
+            self.hass, discovery_info.address
+        )
+
         self._remove_bluetooth_callback = bluetooth.async_register_callback(
             self.hass,
             self._async_update_ble,
@@ -317,6 +337,13 @@ async def _do_provision() -> None:
                     return
             else:
                 _LOGGER.debug("Provision successful, redirect URL: %s", redirect_url)
+                # Clear match history so device can be rediscovered if factory reset.
+                # This ensures that if the device is factory reset in the future,
+                # it will trigger a new discovery flow.
+                assert self._discovery_info is not None
+                bluetooth.async_clear_address_from_match_history(
+                    self.hass, self._discovery_info.address
+                )
                 # Abort all flows in progress with same unique ID
                 for flow in self._async_in_progress(include_uninitialized=True):
                     flow_unique_id = flow["context"].get("unique_id")

tests/components/improv_ble/test_config_flow.py

@@ -23,6 +23,7 @@
 )
 
 from tests.common import MockConfigEntry
+from tests.components.bluetooth import inject_bluetooth_service_info_bleak
 
 IMPROV_BLE = "homeassistant.components.improv_ble"
 
@@ -179,6 +180,112 @@ async def test_bluetooth_step_provisioned_device_2(hass: HomeAssistant) -> None:
     assert len(hass.config_entries.flow.async_progress_by_handler("improv_ble")) == 0
 
 
+async def test_bluetooth_step_provisioned_no_rediscovery(hass: HomeAssistant) -> None:
+    """Test that provisioned device is not rediscovered while it stays provisioned."""
+    # Step 1: Inject provisioned device advertisement (triggers discovery, aborts)
+    inject_bluetooth_service_info_bleak(hass, PROVISIONED_IMPROV_BLE_DISCOVERY_INFO)
+    await hass.async_block_till_done()
+
+    # Verify flow was aborted
+    flows = hass.config_entries.flow.async_progress_by_handler(DOMAIN)
+    assert len(flows) == 0
+
+    # Step 2: Inject same provisioned advertisement again
+    # This should NOT trigger a new discovery because the content hasn't changed
+    # even though we cleared the match history
+    inject_bluetooth_service_info_bleak(hass, PROVISIONED_IMPROV_BLE_DISCOVERY_INFO)
+    await hass.async_block_till_done()
+
+    # Verify no new flow was started
+    flows = hass.config_entries.flow.async_progress_by_handler(DOMAIN)
+    assert len(flows) == 0
+
+
+async def test_bluetooth_step_factory_reset_rediscovery(hass: HomeAssistant) -> None:
+    """Test that factory reset device can be rediscovered."""
+    # Start a flow manually with provisioned device to ensure improv_ble is loaded
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": config_entries.SOURCE_BLUETOOTH},
+        data=PROVISIONED_IMPROV_BLE_DISCOVERY_INFO,
+    )
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_provisioned"
+
+    # Now the match history has been cleared by the config flow
+    # Inject authorized device advertisement - should trigger new discovery
+    inject_bluetooth_service_info_bleak(hass, IMPROV_BLE_DISCOVERY_INFO)
+    await hass.async_block_till_done()
+
+    # Verify discovery proceeds (new flow started)
+    flows = hass.config_entries.flow.async_progress_by_handler(DOMAIN)
+    assert len(flows) == 1
+    assert flows[0]["step_id"] == "bluetooth_confirm"
+
+
+async def test_bluetooth_rediscovery_after_successful_provision(
+    hass: HomeAssistant,
+) -> None:
+    """Test that device can be rediscovered after successful provisioning."""
+    # Start provisioning flow
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": config_entries.SOURCE_BLUETOOTH},
+        data=IMPROV_BLE_DISCOVERY_INFO,
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "bluetooth_confirm"
+
+    # Confirm bluetooth setup
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "bluetooth_confirm"
+
+    # Start provisioning
+    with patch(
+        f"{IMPROV_BLE}.config_flow.ImprovBLEClient.can_identify", return_value=False
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {CONF_ADDRESS: IMPROV_BLE_DISCOVERY_INFO.address},
+        )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "provision"
+
+    # Complete provisioning successfully
+    with (
+        patch(
+            f"{IMPROV_BLE}.config_flow.ImprovBLEClient.need_authorization",
+            return_value=False,
+        ),
+        patch(
+            f"{IMPROV_BLE}.config_flow.ImprovBLEClient.provision",
+            return_value=None,
+        ),
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"], {"ssid": "TestNetwork", "password": "secret"}
+        )
+        assert result["type"] is FlowResultType.SHOW_PROGRESS
+        assert result["progress_action"] == "provisioning"
+        assert result["step_id"] == "do_provision"
+        await hass.async_block_till_done()
+
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "provision_successful"
+
+    # Now inject the same device again (simulating factory reset)
+    # The match history was cleared after successful provision, so it should be rediscovered
+    inject_bluetooth_service_info_bleak(hass, IMPROV_BLE_DISCOVERY_INFO)
+    await hass.async_block_till_done()
+
+    # Verify new discovery flow was created
+    flows = hass.config_entries.flow.async_progress_by_handler(DOMAIN)
+    assert len(flows) == 1
+    assert flows[0]["step_id"] == "bluetooth_confirm"
+
+
 async def test_bluetooth_step_success(hass: HomeAssistant) -> None:
     """Test bluetooth step success path."""
     result = await hass.config_entries.flow.async_init(