jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-17 10:17:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Handle changes to source entities in mold_indicator helper (#148823)

Browse Source 
Co-authored-by: G Johansson <goran.johansson@shiftit.se>
This commit is contained in:
Erik Montnemery 2025-07-15 22:19:32 +02:00 committed by GitHub
parent 3cb579d585
commit 849a25e3cc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 798 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
homeassistant/components/mold_indicator/__init__.py
View File

@ -1,15 +1,93 @@
"""Calculates mold growth indication from temperature and humidity."""
from __future__ import annotations
from collections.abc import Callable
import logging
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.core import Event, HomeAssistant, callback
from homeassistant.helpers import entity_registry as er
from homeassistant.helpers.device import (
async_entity_id_to_device_id,
async_remove_stale_devices_links_keep_entity_device,
)
from homeassistant.helpers.event import async_track_entity_registry_updated_event
from homeassistant.helpers.helper_integration import (
async_handle_source_entity_changes,
async_remove_helper_config_entry_from_source_device,
)
from .const import CONF_INDOOR_HUMIDITY, CONF_INDOOR_TEMP, CONF_OUTDOOR_TEMP
PLATFORMS = [Platform.SENSOR]
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Mold indicator from a config entry."""
# This can be removed in HA Core 2026.2
async_remove_stale_devices_links_keep_entity_device(
hass, entry.entry_id, entry.options[CONF_INDOOR_HUMIDITY]
)
def set_source_entity_id_or_uuid(source_entity_id: str) -> None:
hass.config_entries.async_update_entry(
entry,
options={**entry.options, CONF_INDOOR_HUMIDITY: source_entity_id},
)
entry.async_on_unload(
# We use async_handle_source_entity_changes to track changes to the humidity
# sensor, but not the temperature sensors because the mold_indicator links
# to the humidity sensor's device.
async_handle_source_entity_changes(
hass,
add_helper_config_entry_to_device=False,
helper_config_entry_id=entry.entry_id,
set_source_entity_id_or_uuid=set_source_entity_id_or_uuid,
source_device_id=async_entity_id_to_device_id(
hass, entry.options[CONF_INDOOR_HUMIDITY]
),
source_entity_id_or_uuid=entry.options[CONF_INDOOR_HUMIDITY],
)
)
for temp_sensor in (CONF_INDOOR_TEMP, CONF_OUTDOOR_TEMP):
def get_temp_sensor_updater(
temp_sensor: str,
) -> Callable[[Event[er.EventEntityRegistryUpdatedData]], None]:
"""Return a function to update the config entry with the new temp sensor."""
@callback
def async_sensor_updated(
event: Event[er.EventEntityRegistryUpdatedData],
) -> None:
"""Handle entity registry update."""
data = event.data
if data["action"] != "update":
return
if "entity_id" not in data["changes"]:
return
# Entity_id changed, update the config entry
hass.config_entries.async_update_entry(
entry,
options={**entry.options, temp_sensor: data["entity_id"]},
)
return async_sensor_updated
entry.async_on_unload(
async_track_entity_registry_updated_event(
hass, entry.options[temp_sensor], get_temp_sensor_updater(temp_sensor)
)
)
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
entry.async_on_unload(entry.add_update_listener(update_listener))
@ -24,3 +102,40 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
"""Handle options update."""
await hass.config_entries.async_reload(entry.entry_id)
async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
"""Migrate old entry."""
_LOGGER.debug(
"Migrating configuration from version %s.%s",
config_entry.version,
config_entry.minor_version,
)
if config_entry.version > 1:
# This means the user has downgraded from a future version
return False
if config_entry.version == 1:
if config_entry.minor_version < 2:
# Remove the mold indicator config entry from the source device
if source_device_id := async_entity_id_to_device_id(
hass, config_entry.options[CONF_INDOOR_HUMIDITY]
):
async_remove_helper_config_entry_from_source_device(
hass,
helper_config_entry_id=config_entry.entry_id,
source_device_id=source_device_id,
)
hass.config_entries.async_update_entry(
config_entry, version=1, minor_version=2
)
_LOGGER.debug(
"Migration to configuration version %s.%s successful",
config_entry.version,
config_entry.minor_version,
)
return True

3
homeassistant/components/mold_indicator/config_flow.py
View File

@ -101,6 +101,9 @@ class MoldIndicatorConfigFlowHandler(SchemaConfigFlowHandler, domain=DOMAIN):
config_flow = CONFIG_FLOW
options_flow = OPTIONS_FLOW
VERSION = 1
MINOR_VERSION = 2
def async_config_entry_title(self, options: Mapping[str, Any]) -> str:
"""Return config entry title."""
return cast(str, options[CONF_NAME])

4
homeassistant/components/mold_indicator/sensor.py
View File

@ -35,7 +35,7 @@ from homeassistant.core import (
callback,
)
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.device import async_device_info_to_link_from_entity
from homeassistant.helpers.device import async_entity_id_to_device
from homeassistant.helpers.entity_platform import (
AddConfigEntryEntitiesCallback,
AddEntitiesCallback,
@ -173,7 +173,7 @@ class MoldIndicator(SensorEntity):
self._indoor_hum: float | None = None
self._crit_temp: float | None = None
if indoor_humidity_sensor:
self._attr_device_info = async_device_info_to_link_from_entity(
self.device_entry = async_entity_id_to_device(
hass,
indoor_humidity_sensor,
)

679
tests/components/mold_indicator/test_init.py
View File

@ -2,12 +2,190 @@
from __future__ import annotations
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant
from unittest.mock import patch
import pytest
from homeassistant.components import mold_indicator
from homeassistant.components.mold_indicator.config_flow import (
MoldIndicatorConfigFlowHandler,
)
from homeassistant.components.mold_indicator.const import (
CONF_CALIBRATION_FACTOR,
CONF_INDOOR_HUMIDITY,
CONF_INDOOR_TEMP,
CONF_OUTDOOR_TEMP,
DEFAULT_NAME,
DOMAIN,
)
from homeassistant.config_entries import ConfigEntry, ConfigEntryState
from homeassistant.const import CONF_NAME
from homeassistant.core import Event, HomeAssistant, callback
from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.event import async_track_entity_registry_updated_event
from tests.common import MockConfigEntry
@pytest.fixture
def indoor_humidity_config_entry(hass: HomeAssistant) -> er.RegistryEntry:
"""Fixture to create a sensor config entry."""
sensor_config_entry = MockConfigEntry()
sensor_config_entry.add_to_hass(hass)
return sensor_config_entry
@pytest.fixture
def indoor_humidity_device(
device_registry: dr.DeviceRegistry, indoor_humidity_config_entry: ConfigEntry
) -> dr.DeviceEntry:
"""Fixture to create a sensor device."""
return device_registry.async_get_or_create(
config_entry_id=indoor_humidity_config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:ED")},
)
@pytest.fixture
def indoor_humidity_entity_entry(
entity_registry: er.EntityRegistry,
indoor_humidity_config_entry: ConfigEntry,
indoor_humidity_device: dr.DeviceEntry,
) -> er.RegistryEntry:
"""Fixture to create a sensor entity entry."""
return entity_registry.async_get_or_create(
"sensor",
"test",
"unique_indoor_humidity",
config_entry=indoor_humidity_config_entry,
device_id=indoor_humidity_device.id,
original_name="ABC",
)
@pytest.fixture
def indoor_temperature_config_entry(hass: HomeAssistant) -> er.RegistryEntry:
"""Fixture to create a sensor config entry."""
sensor_config_entry = MockConfigEntry()
sensor_config_entry.add_to_hass(hass)
return sensor_config_entry
@pytest.fixture
def indoor_temperature_device(
device_registry: dr.DeviceRegistry, indoor_temperature_config_entry: ConfigEntry
) -> dr.DeviceEntry:
"""Fixture to create a sensor device."""
return device_registry.async_get_or_create(
config_entry_id=indoor_temperature_config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EE")},
)
@pytest.fixture
def indoor_temperature_entity_entry(
entity_registry: er.EntityRegistry,
indoor_temperature_config_entry: ConfigEntry,
indoor_temperature_device: dr.DeviceEntry,
) -> er.RegistryEntry:
"""Fixture to create a sensor entity entry."""
return entity_registry.async_get_or_create(
"sensor",
"test",
"unique_indoor_temperature",
config_entry=indoor_temperature_config_entry,
device_id=indoor_temperature_device.id,
original_name="ABC",
)
@pytest.fixture
def outdoor_temperature_config_entry(hass: HomeAssistant) -> er.RegistryEntry:
"""Fixture to create a sensor config entry."""
sensor_config_entry = MockConfigEntry()
sensor_config_entry.add_to_hass(hass)
return sensor_config_entry
@pytest.fixture
def outdoor_temperature_device(
device_registry: dr.DeviceRegistry, outdoor_temperature_config_entry: ConfigEntry
) -> dr.DeviceEntry:
"""Fixture to create a sensor device."""
return device_registry.async_get_or_create(
config_entry_id=outdoor_temperature_config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
@pytest.fixture
def outdoor_temperature_entity_entry(
entity_registry: er.EntityRegistry,
outdoor_temperature_config_entry: ConfigEntry,
outdoor_temperature_device: dr.DeviceEntry,
) -> er.RegistryEntry:
"""Fixture to create a sensor entity entry."""
return entity_registry.async_get_or_create(
"sensor",
"test",
"unique_outdoor_temperature",
config_entry=outdoor_temperature_config_entry,
device_id=outdoor_temperature_device.id,
original_name="ABC",
)
@pytest.fixture
def mold_indicator_config_entry(
hass: HomeAssistant,
indoor_humidity_entity_entry: er.RegistryEntry,
indoor_temperature_entity_entry: er.RegistryEntry,
outdoor_temperature_entity_entry: er.RegistryEntry,
) -> MockConfigEntry:
"""Fixture to create a mold_indicator config entry."""
config_entry = MockConfigEntry(
data={},
domain=DOMAIN,
options={
CONF_NAME: "My mold indicator",
CONF_INDOOR_HUMIDITY: indoor_humidity_entity_entry.entity_id,
CONF_INDOOR_TEMP: indoor_temperature_entity_entry.entity_id,
CONF_OUTDOOR_TEMP: outdoor_temperature_entity_entry.entity_id,
CONF_CALIBRATION_FACTOR: 2.0,
},
title="My mold indicator",
version=MoldIndicatorConfigFlowHandler.VERSION,
minor_version=MoldIndicatorConfigFlowHandler.MINOR_VERSION,
)
config_entry.add_to_hass(hass)
return config_entry
@pytest.fixture
def expected_helper_device_id(
request: pytest.FixtureRequest,
indoor_humidity_device: dr.DeviceEntry,
) -> str | None:
"""Fixture to provide the expected helper device ID."""
return indoor_humidity_device.id if request.param == "humidity_device_id" else None
def track_entity_registry_actions(hass: HomeAssistant, entity_id: str) -> list[str]:
"""Track entity registry actions for an entity."""
events = []
@callback
def add_event(event: Event[er.EventEntityRegistryUpdatedData]) -> None:
"""Add entity registry updated event to the list."""
events.append(event.data["action"])
async_track_entity_registry_updated_event(hass, entity_id, add_event)
return events
async def test_unload_entry(hass: HomeAssistant, loaded_entry: MockConfigEntry) -> None:
"""Test unload an entry."""
@ -15,3 +193,500 @@ async def test_unload_entry(hass: HomeAssistant, loaded_entry: MockConfigEntry)
assert await hass.config_entries.async_unload(loaded_entry.entry_id)
await hass.async_block_till_done()
assert loaded_entry.state is ConfigEntryState.NOT_LOADED
async def test_device_cleaning(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test cleaning of devices linked to the helper config entry."""
# Source entity device config entry
source_config_entry = MockConfigEntry()
source_config_entry.add_to_hass(hass)
# Device entry of the source entity
source_device1_entry = device_registry.async_get_or_create(
config_entry_id=source_config_entry.entry_id,
identifiers={("sensor", "identifier_test1")},
connections={("mac", "30:31:32:33:34:01")},
)
# Source entity registry
source_entity = entity_registry.async_get_or_create(
"sensor",
"indoor",
"humidity",
config_entry=source_config_entry,
device_id=source_device1_entry.id,
)
await hass.async_block_till_done()
assert entity_registry.async_get("sensor.indoor_humidity") is not None
# Configure the configuration entry for helper
helper_config_entry = MockConfigEntry(
data={},
domain=DOMAIN,
options={
CONF_NAME: DEFAULT_NAME,
CONF_INDOOR_HUMIDITY: "sensor.indoor_humidity",
CONF_INDOOR_TEMP: "sensor.indoor_temp",
CONF_OUTDOOR_TEMP: "sensor.outdoor_temp",
CONF_CALIBRATION_FACTOR: 2.0,
},
title="Test",
)
helper_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(helper_config_entry.entry_id)
await hass.async_block_till_done()
# Confirm the link between the source entity device and the helper entity
helper_entity = entity_registry.async_get("sensor.mold_indicator")
assert helper_entity is not None
assert helper_entity.device_id == source_entity.device_id
# Device entry incorrectly linked to config entry
device_registry.async_get_or_create(
config_entry_id=helper_config_entry.entry_id,
identifiers={("sensor", "identifier_test2")},
connections={("mac", "30:31:32:33:34:02")},
)
device_registry.async_get_or_create(
config_entry_id=helper_config_entry.entry_id,
identifiers={("sensor", "identifier_test3")},
connections={("mac", "30:31:32:33:34:03")},
)
await hass.async_block_till_done()
# Before reloading the config entry, 3 devices are expected to be linked
devices_before_reload = device_registry.devices.get_devices_for_config_entry_id(
helper_config_entry.entry_id
)
assert len(devices_before_reload) == 2
# Config entry reload
await hass.config_entries.async_reload(helper_config_entry.entry_id)
await hass.async_block_till_done()
# Confirm the link between the source entity device and the helper entity
helper_entity = entity_registry.async_get("sensor.mold_indicator")
assert helper_entity is not None
assert helper_entity.device_id == source_entity.device_id
# After reloading the config entry, only one linked device is expected
devices_after_reload = device_registry.devices.get_devices_for_config_entry_id(
helper_config_entry.entry_id
)
assert len(devices_after_reload) == 0
@pytest.mark.parametrize(
("source_entity_id", "expected_helper_device_id", "expected_events"),
[
("sensor.test_unique_indoor_humidity", None, ["update"]),
("sensor.test_unique_indoor_temperature", "humidity_device_id", []),
("sensor.test_unique_outdoor_temperature", "humidity_device_id", []),
],
indirect=["expected_helper_device_id"],
)
async def test_async_handle_source_entity_changes_source_entity_removed(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
mold_indicator_config_entry: MockConfigEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
source_entity_id: str,
expected_helper_device_id: str | None,
expected_events: list[str],
) -> None:
"""Test the mold_indicator config entry is removed when the source entity is removed."""
source_entity_entry = entity_registry.async_get(source_entity_id)
assert await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
source_device = device_registry.async_get(source_entity_entry.device_id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
events = track_entity_registry_actions(hass, mold_indicator_entity_entry.entity_id)
# Remove the source entity's config entry from the device, this removes the
# source entity
with patch(
"homeassistant.components.mold_indicator.async_unload_entry",
wraps=mold_indicator.async_unload_entry,
) as mock_unload_entry:
device_registry.async_update_device(
source_device.id, remove_config_entry_id=source_entity_entry.config_entry_id
)
await hass.async_block_till_done()
await hass.async_block_till_done()
mock_unload_entry.assert_not_called()
# Check that the helper entity is linked to the expected source device
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert mold_indicator_entity_entry.device_id == expected_helper_device_id
# Check that the device is removed
assert not device_registry.async_get(source_device.id)
# Check that the mold_indicator config entry is not removed
assert mold_indicator_config_entry.entry_id in hass.config_entries.async_entry_ids()
# Check we got the expected events
assert events == expected_events
@pytest.mark.parametrize(
("source_entity_id", "expected_helper_device_id", "expected_events"),
[
("sensor.test_unique_indoor_humidity", None, ["update"]),
("sensor.test_unique_indoor_temperature", "humidity_device_id", []),
("sensor.test_unique_outdoor_temperature", "humidity_device_id", []),
],
indirect=["expected_helper_device_id"],
)
async def test_async_handle_source_entity_changes_source_entity_removed_shared_device(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
mold_indicator_config_entry: MockConfigEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
source_entity_id: str,
expected_helper_device_id: str | None,
expected_events: list[str],
) -> None:
"""Test the mold_indicator config entry is removed when the source entity is removed."""
source_entity_entry = entity_registry.async_get(source_entity_id)
# Add another config entry to the source device
other_config_entry = MockConfigEntry()
other_config_entry.add_to_hass(hass)
device_registry.async_update_device(
source_entity_entry.device_id, add_config_entry_id=other_config_entry.entry_id
)
assert await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
source_device = device_registry.async_get(source_entity_entry.device_id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
events = track_entity_registry_actions(hass, mold_indicator_entity_entry.entity_id)
# Remove the source entity's config entry from the device, this removes the
# source entity
with patch(
"homeassistant.components.mold_indicator.async_unload_entry",
wraps=mold_indicator.async_unload_entry,
) as mock_unload_entry:
device_registry.async_update_device(
source_device.id, remove_config_entry_id=source_entity_entry.config_entry_id
)
await hass.async_block_till_done()
await hass.async_block_till_done()
mock_unload_entry.assert_not_called()
# Check that the helper entity is linked to the expected source device
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert mold_indicator_entity_entry.device_id == expected_helper_device_id
# Check if the mold_indicator config entry is not in the device
source_device = device_registry.async_get(source_device.id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
# Check that the mold_indicator config entry is not removed
assert mold_indicator_config_entry.entry_id in hass.config_entries.async_entry_ids()
# Check we got the expected events
assert events == expected_events
@pytest.mark.parametrize(
(
"source_entity_id",
"unload_entry_calls",
"expected_helper_device_id",
"expected_events",
),
[
("sensor.test_unique_indoor_humidity", 1, None, ["update"]),
("sensor.test_unique_indoor_temperature", 0, "humidity_device_id", []),
("sensor.test_unique_outdoor_temperature", 0, "humidity_device_id", []),
],
indirect=["expected_helper_device_id"],
)
async def test_async_handle_source_entity_changes_source_entity_removed_from_device(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
mold_indicator_config_entry: MockConfigEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
source_entity_id: str,
unload_entry_calls: int,
expected_helper_device_id: str | None,
expected_events: list[str],
) -> None:
"""Test the source entity removed from the source device."""
source_entity_entry = entity_registry.async_get(source_entity_id)
assert await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
source_device = device_registry.async_get(source_entity_entry.device_id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
events = track_entity_registry_actions(hass, mold_indicator_entity_entry.entity_id)
# Remove the source entity from the device
with patch(
"homeassistant.components.mold_indicator.async_unload_entry",
wraps=mold_indicator.async_unload_entry,
) as mock_unload_entry:
entity_registry.async_update_entity(
source_entity_entry.entity_id, device_id=None
)
await hass.async_block_till_done()
assert len(mock_unload_entry.mock_calls) == unload_entry_calls
# Check that the helper entity is linked to the expected source device
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert mold_indicator_entity_entry.device_id == expected_helper_device_id
# Check that the mold_indicator config entry is not in the device
source_device = device_registry.async_get(source_device.id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
# Check that the mold_indicator config entry is not removed
assert mold_indicator_config_entry.entry_id in hass.config_entries.async_entry_ids()
# Check we got the expected events
assert events == expected_events
@pytest.mark.parametrize(
("source_entity_id", "unload_entry_calls", "expected_events"),
[
("sensor.test_unique_indoor_humidity", 1, ["update"]),
("sensor.test_unique_indoor_temperature", 0, []),
("sensor.test_unique_outdoor_temperature", 0, []),
],
)
async def test_async_handle_source_entity_changes_source_entity_moved_other_device(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
mold_indicator_config_entry: MockConfigEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
source_entity_id: str,
unload_entry_calls: int,
expected_events: list[str],
) -> None:
"""Test the source entity is moved to another device."""
source_entity_entry = entity_registry.async_get(source_entity_id)
source_device_2 = device_registry.async_get_or_create(
config_entry_id=source_entity_entry.config_entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:FF")},
)
assert await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
source_device = device_registry.async_get(source_entity_entry.device_id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
source_device_2 = device_registry.async_get(source_device_2.id)
assert mold_indicator_config_entry.entry_id not in source_device_2.config_entries
events = track_entity_registry_actions(hass, mold_indicator_entity_entry.entity_id)
# Move the source entity to another device
with patch(
"homeassistant.components.mold_indicator.async_unload_entry",
wraps=mold_indicator.async_unload_entry,
) as mock_unload_entry:
entity_registry.async_update_entity(
source_entity_entry.entity_id, device_id=source_device_2.id
)
await hass.async_block_till_done()
assert len(mock_unload_entry.mock_calls) == unload_entry_calls
# Check that the helper entity is linked to the expected source device
indoor_humidity_entity_entry = entity_registry.async_get(
indoor_humidity_entity_entry.entity_id
)
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
# Check that the mold_indicator config entry is not in any of the devices
source_device = device_registry.async_get(source_device.id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
source_device_2 = device_registry.async_get(source_device_2.id)
assert mold_indicator_config_entry.entry_id not in source_device_2.config_entries
# Check that the mold_indicator config entry is not removed
assert mold_indicator_config_entry.entry_id in hass.config_entries.async_entry_ids()
# Check we got the expected events
assert events == expected_events
@pytest.mark.parametrize(
("source_entity_id", "config_key"),
[
("sensor.test_unique_indoor_humidity", CONF_INDOOR_HUMIDITY),
("sensor.test_unique_indoor_temperature", CONF_INDOOR_TEMP),
("sensor.test_unique_outdoor_temperature", CONF_OUTDOOR_TEMP),
],
)
async def test_async_handle_source_entity_new_entity_id(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
mold_indicator_config_entry: MockConfigEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
source_entity_id: str,
config_key: str,
) -> None:
"""Test the source entity's entity ID is changed."""
source_entity_entry = entity_registry.async_get(source_entity_id)
assert await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
source_device = device_registry.async_get(source_entity_entry.device_id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
events = track_entity_registry_actions(hass, mold_indicator_entity_entry.entity_id)
# Change the source entity's entity ID
with patch(
"homeassistant.components.mold_indicator.async_unload_entry",
wraps=mold_indicator.async_unload_entry,
) as mock_unload_entry:
entity_registry.async_update_entity(
source_entity_entry.entity_id, new_entity_id="sensor.new_entity_id"
)
await hass.async_block_till_done()
mock_unload_entry.assert_called_once()
# Check that the mold_indicator config entry is updated with the new entity ID
assert mold_indicator_config_entry.options[config_key] == "sensor.new_entity_id"
# Check that the helper config is not in the device
source_device = device_registry.async_get(source_device.id)
assert mold_indicator_config_entry.entry_id not in source_device.config_entries
# Check that the mold_indicator config entry is not removed
assert mold_indicator_config_entry.entry_id in hass.config_entries.async_entry_ids()
# Check we got the expected events
assert events == []
async def test_migration_1_1(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
indoor_humidity_device: dr.DeviceEntry,
indoor_humidity_entity_entry: er.RegistryEntry,
indoor_temperature_entity_entry: er.RegistryEntry,
outdoor_temperature_entity_entry: er.RegistryEntry,
) -> None:
"""Test migration from v1.1 removes mold_indicator config entry from device."""
mold_indicator_config_entry = MockConfigEntry(
data={},
domain=DOMAIN,
options={
CONF_NAME: "My mold indicator",
CONF_INDOOR_HUMIDITY: indoor_humidity_entity_entry.entity_id,
CONF_INDOOR_TEMP: indoor_temperature_entity_entry.entity_id,
CONF_OUTDOOR_TEMP: outdoor_temperature_entity_entry.entity_id,
CONF_CALIBRATION_FACTOR: 2.0,
},
title="My mold indicator",
version=1,
minor_version=1,
)
mold_indicator_config_entry.add_to_hass(hass)
# Add the helper config entry to the device
device_registry.async_update_device(
indoor_humidity_device.id,
add_config_entry_id=mold_indicator_config_entry.entry_id,
)
# Check preconditions
switch_device = device_registry.async_get(indoor_humidity_device.id)
assert mold_indicator_config_entry.entry_id in switch_device.config_entries
await hass.config_entries.async_setup(mold_indicator_config_entry.entry_id)
await hass.async_block_till_done()
assert mold_indicator_config_entry.state is ConfigEntryState.LOADED
# Check that the helper config entry is removed from the device and the helper
# entity is linked to the source device
switch_device = device_registry.async_get(switch_device.id)
assert mold_indicator_config_entry.entry_id not in switch_device.config_entries
mold_indicator_entity_entry = entity_registry.async_get("sensor.my_mold_indicator")
assert (
mold_indicator_entity_entry.device_id == indoor_humidity_entity_entry.device_id
)
assert mold_indicator_config_entry.version == 1
assert mold_indicator_config_entry.minor_version == 2
async def test_migration_from_future_version(
hass: HomeAssistant,
) -> None:
"""Test migration from future version."""
config_entry = MockConfigEntry(
data={},
domain=DOMAIN,
options={
CONF_NAME: DEFAULT_NAME,
CONF_INDOOR_HUMIDITY: "sensor.indoor_humidity",
CONF_INDOOR_TEMP: "sensor.indoor_temp",
CONF_OUTDOOR_TEMP: "sensor.outdoor_temp",
CONF_CALIBRATION_FACTOR: 2.0,
},
title="My mold indicator",
version=2,
minor_version=1,
)
config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert config_entry.state is ConfigEntryState.MIGRATION_ERROR