Normalize unique ID in WLED

homeassistant/components/wled/__init__.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
+import logging
+
+from homeassistant.config_entries import SOURCE_IGNORE
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
@@ -13,8 +17,11 @@
     WLEDConfigEntry,
     WLEDDataUpdateCoordinator,
     WLEDReleasesDataUpdateCoordinator,
+    normalize_mac_address,
 )
 
+_LOGGER = logging.getLogger(__name__)
+
 PLATFORMS = (
     Platform.BUTTON,
     Platform.LIGHT,
@@ -63,3 +70,70 @@ async def async_unload_entry(hass: HomeAssistant, entry: WLEDConfigEntry) -> boo
             coordinator.unsub()
 
     return unload_ok
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: WLEDConfigEntry
+) -> bool:
+    """Migrate old entry."""
+    _LOGGER.debug(
+        "Migrating configuration from version %s.%s",
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    if config_entry.version > 1:
+        # The user has downgraded from a future version
+        return False
+
+    if config_entry.version == 1:
+        if config_entry.minor_version < 2:
+            if config_entry.unique_id is None:
+                _LOGGER.warning(
+                    "Config entry is missing unique ID, cannot migrate to version 1.2"
+                )
+                return False
+            normalized_mac_address = normalize_mac_address(config_entry.unique_id)
+            duplicate_entries = [
+                entry
+                for entry in hass.config_entries.async_entries(DOMAIN)
+                if entry.unique_id
+                and normalize_mac_address(entry.unique_id) == normalized_mac_address
+            ]
+            ignored_entries = [
+                entry
+                for entry in duplicate_entries
+                if entry.entry_id != config_entry.entry_id
+                and entry.source == SOURCE_IGNORE
+            ]
+            if ignored_entries:
+                _LOGGER.info(
+                    "Found %d ignored WLED config entries with the same MAC address, removing them",
+                    len(ignored_entries),
+                )
+                await asyncio.gather(
+                    *[
+                        hass.config_entries.async_remove(entry.entry_id)
+                        for entry in ignored_entries
+                    ]
+                )
+            if len(duplicate_entries) - len(ignored_entries) > 1:
+                _LOGGER.warning(
+                    "Found multiple WLED config entries with the same MAC address, cannot migrate to version 1.2"
+                )
+                return False
+
+            hass.config_entries.async_update_entry(
+                config_entry,
+                unique_id=normalized_mac_address,
+                version=1,
+                minor_version=2,
+            )
+
+    _LOGGER.debug(
+        "Migration to configuration version %s.%s successful",
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    return True

homeassistant/components/wled/config_flow.py

@@ -21,13 +21,14 @@
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import CONF_KEEP_MAIN_LIGHT, DEFAULT_KEEP_MAIN_LIGHT, DOMAIN
-from .coordinator import WLEDConfigEntry
+from .coordinator import WLEDConfigEntry, normalize_mac_address
 
 
 class WLEDFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a WLED config flow."""
 
     VERSION = 1
+    MINOR_VERSION = 2
     discovered_host: str
     discovered_device: Device
 
@@ -53,9 +54,8 @@ async def async_step_user(
             except WLEDConnectionError:
                 errors["base"] = "cannot_connect"
             else:
-                await self.async_set_unique_id(
-                    device.info.mac_address, raise_on_progress=False
-                )
+                mac_address = normalize_mac_address(device.info.mac_address)
+                await self.async_set_unique_id(mac_address, raise_on_progress=False)
                 if self.source == SOURCE_RECONFIGURE:
                     entry = self._get_reconfigure_entry()
                     self._abort_if_unique_id_mismatch(
@@ -104,7 +104,7 @@ async def async_step_zeroconf(
         """Handle zeroconf discovery."""
         # Abort quick if the mac address is provided by discovery info
         if mac := discovery_info.properties.get(CONF_MAC):
-            await self.async_set_unique_id(mac)
+            await self.async_set_unique_id(normalize_mac_address(mac))
             self._abort_if_unique_id_configured(
                 updates={CONF_HOST: discovery_info.host}
             )
@@ -117,7 +117,10 @@ async def async_step_zeroconf(
         except WLEDConnectionError:
             return self.async_abort(reason="cannot_connect")
 
-        await self.async_set_unique_id(self.discovered_device.info.mac_address)
+        device_mac_address = normalize_mac_address(
+            self.discovered_device.info.mac_address
+        )
+        await self.async_set_unique_id(device_mac_address)
         self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.host})
 
         self.context.update(

homeassistant/components/wled/coordinator.py

@@ -32,6 +32,11 @@
 type WLEDConfigEntry = ConfigEntry[WLEDDataUpdateCoordinator]
 
 
+def normalize_mac_address(mac: str) -> str:
+    """Normalize a MAC address to lowercase without separators."""
+    return mac.lower().replace(":", "").strip()
+
+
 class WLEDDataUpdateCoordinator(DataUpdateCoordinator[WLEDDevice]):
     """Class to manage fetching WLED data from single endpoint."""
 
@@ -51,6 +56,9 @@ def __init__(
         self.wled = WLED(entry.data[CONF_HOST], session=async_get_clientsession(hass))
         self.unsub: CALLBACK_TYPE | None = None
 
+        assert entry.unique_id
+        self.config_mac_address = normalize_mac_address(entry.unique_id)
+
         super().__init__(
             hass,
             LOGGER,
@@ -131,7 +139,8 @@ async def _async_update_data(self) -> WLEDDevice:
                 translation_placeholders={"error": str(error)},
             ) from error
 
-        if device.info.mac_address != self.config_entry.unique_id:
+        device_mac_address = normalize_mac_address(device.info.mac_address)
+        if device_mac_address != self.config_mac_address:
             raise ConfigEntryError(
                 translation_domain=DOMAIN,
                 translation_key="mac_address_mismatch",

tests/components/wled/conftest.py

@@ -22,6 +22,7 @@ def mock_config_entry() -> MockConfigEntry:
         domain=DOMAIN,
         data={CONF_HOST: "192.168.1.123"},
         unique_id="aabbccddeeff",
+        minor_version=2,
     )
 
 

tests/components/wled/test_config_flow.py

@@ -281,12 +281,15 @@ async def test_zeroconf_unsupported_version_error(
 
 
 @pytest.mark.usefixtures("mock_wled")
+@pytest.mark.parametrize("device_mac", ["aabbccddeeff", "AABBCCDDEEFF"])
 async def test_user_device_exists_abort(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_wled: MagicMock,
+    device_mac: str,
 ) -> None:
     """Test we abort zeroconf flow if WLED device already configured."""
+    mock_wled.update.return_value.info.mac_address = device_mac
     mock_config_entry.add_to_hass(hass)
     result = await hass.config_entries.flow.async_init(
         DOMAIN,
@@ -323,10 +326,12 @@ async def test_zeroconf_without_mac_device_exists_abort(
     assert result.get("reason") == "already_configured"
 
 
+@pytest.mark.parametrize("device_mac", ["aabbccddeeff", "AABBCCDDEEFF"])
 async def test_zeroconf_with_mac_device_exists_abort(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_wled: MagicMock,
+    device_mac: str,
 ) -> None:
     """Test we abort zeroconf flow if WLED device already configured."""
     mock_config_entry.add_to_hass(hass)
@@ -339,7 +344,7 @@ async def test_zeroconf_with_mac_device_exists_abort(
             hostname="example.local.",
             name="mock_name",
             port=None,
-            properties={CONF_MAC: "aabbccddeeff"},
+            properties={CONF_MAC: device_mac},
             type="mock_type",
         ),
     )