diff --git a/tests/helpers/test_area_registry.py b/tests/helpers/test_area_registry.py index ea42417aef9..3128e5b80b0 100644 --- a/tests/helpers/test_area_registry.py +++ b/tests/helpers/test_area_registry.py @@ -2,15 +2,9 @@ import pytest from homeassistant.core import callback -from homeassistant.helpers import area_registry +from homeassistant.helpers import area_registry as ar -from tests.common import ANY, flush_store, mock_area_registry - - -@pytest.fixture -def registry(hass): - """Return an empty, loaded, registry.""" - return mock_area_registry(hass) +from tests.common import ANY, flush_store @pytest.fixture @@ -22,29 +16,29 @@ def update_events(hass): def async_capture(event): events.append(event.data) - hass.bus.async_listen(area_registry.EVENT_AREA_REGISTRY_UPDATED, async_capture) + hass.bus.async_listen(ar.EVENT_AREA_REGISTRY_UPDATED, async_capture) return events -async def test_list_areas(registry): +async def test_list_areas(area_registry): """Make sure that we can read areas.""" - registry.async_create("mock") + area_registry.async_create("mock") - areas = registry.async_list_areas() + areas = area_registry.async_list_areas() - assert len(areas) == len(registry.areas) + assert len(areas) == len(area_registry.areas) -async def test_create_area(hass, registry, update_events): +async def test_create_area(hass, area_registry, update_events): """Make sure that we can create an area.""" # Create area with only mandatory parameters - area = registry.async_create("mock") + area = area_registry.async_create("mock") - assert area == area_registry.AreaEntry( + assert area == ar.AreaEntry( name="mock", normalized_name=ANY, aliases=set(), id=ANY, picture=None ) - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 await hass.async_block_till_done() @@ -53,18 +47,18 @@ async def test_create_area(hass, registry, update_events): assert update_events[-1]["area_id"] == area.id # Create area with all parameters - area = registry.async_create( + area = area_registry.async_create( "mock 2", aliases={"alias_1", "alias_2"}, picture="/image/example.png" ) - assert area == area_registry.AreaEntry( + assert area == ar.AreaEntry( name="mock 2", normalized_name=ANY, aliases={"alias_1", "alias_2"}, id=ANY, picture="/image/example.png", ) - assert len(registry.areas) == 2 + assert len(area_registry.areas) == 2 await hass.async_block_till_done() @@ -73,39 +67,39 @@ async def test_create_area(hass, registry, update_events): assert update_events[-1]["area_id"] == area.id -async def test_create_area_with_name_already_in_use(hass, registry, update_events): +async def test_create_area_with_name_already_in_use(hass, area_registry, update_events): """Make sure that we can't create an area with a name already in use.""" - area1 = registry.async_create("mock") + area1 = area_registry.async_create("mock") with pytest.raises(ValueError) as e_info: - area2 = registry.async_create("mock") + area2 = area_registry.async_create("mock") assert area1 != area2 assert e_info == "The name mock 2 (mock2) is already in use" await hass.async_block_till_done() - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 assert len(update_events) == 1 -async def test_create_area_with_id_already_in_use(registry): +async def test_create_area_with_id_already_in_use(area_registry): """Make sure that we can't create an area with a name already in use.""" - area1 = registry.async_create("mock") + area1 = area_registry.async_create("mock") - updated_area1 = registry.async_update(area1.id, name="New Name") + updated_area1 = area_registry.async_update(area1.id, name="New Name") assert updated_area1.id == area1.id - area2 = registry.async_create("mock") + area2 = area_registry.async_create("mock") assert area2.id == "mock_2" -async def test_delete_area(hass, registry, update_events): +async def test_delete_area(hass, area_registry, update_events): """Make sure that we can delete an area.""" - area = registry.async_create("mock") + area = area_registry.async_create("mock") - registry.async_delete(area.id) + area_registry.async_delete(area.id) - assert not registry.areas + assert not area_registry.areas await hass.async_block_till_done() @@ -116,21 +110,21 @@ async def test_delete_area(hass, registry, update_events): assert update_events[1]["area_id"] == area.id -async def test_delete_non_existing_area(registry): +async def test_delete_non_existing_area(area_registry): """Make sure that we can't delete an area that doesn't exist.""" - registry.async_create("mock") + area_registry.async_create("mock") with pytest.raises(KeyError): - await registry.async_delete("") + await area_registry.async_delete("") - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 -async def test_update_area(hass, registry, update_events): +async def test_update_area(hass, area_registry, update_events): """Make sure that we can read areas.""" - area = registry.async_create("mock") + area = area_registry.async_create("mock") - updated_area = registry.async_update( + updated_area = area_registry.async_update( area.id, aliases={"alias_1", "alias_2"}, name="mock1", @@ -138,14 +132,14 @@ async def test_update_area(hass, registry, update_events): ) assert updated_area != area - assert updated_area == area_registry.AreaEntry( + assert updated_area == ar.AreaEntry( name="mock1", normalized_name=ANY, aliases={"alias_1", "alias_2"}, id=ANY, picture="/image/example.png", ) - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 await hass.async_block_till_done() @@ -156,68 +150,68 @@ async def test_update_area(hass, registry, update_events): assert update_events[1]["area_id"] == area.id -async def test_update_area_with_same_name(registry): +async def test_update_area_with_same_name(area_registry): """Make sure that we can reapply the same name to the area.""" - area = registry.async_create("mock") + area = area_registry.async_create("mock") - updated_area = registry.async_update(area.id, name="mock") + updated_area = area_registry.async_update(area.id, name="mock") assert updated_area == area - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 -async def test_update_area_with_same_name_change_case(registry): +async def test_update_area_with_same_name_change_case(area_registry): """Make sure that we can reapply the same name with a different case to the area.""" - area = registry.async_create("mock") + area = area_registry.async_create("mock") - updated_area = registry.async_update(area.id, name="Mock") + updated_area = area_registry.async_update(area.id, name="Mock") assert updated_area.name == "Mock" assert updated_area.id == area.id assert updated_area.normalized_name == area.normalized_name - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 -async def test_update_area_with_name_already_in_use(registry): +async def test_update_area_with_name_already_in_use(area_registry): """Make sure that we can't update an area with a name already in use.""" - area1 = registry.async_create("mock1") - area2 = registry.async_create("mock2") + area1 = area_registry.async_create("mock1") + area2 = area_registry.async_create("mock2") with pytest.raises(ValueError) as e_info: - registry.async_update(area1.id, name="mock2") + area_registry.async_update(area1.id, name="mock2") assert e_info == "The name mock 2 (mock2) is already in use" assert area1.name == "mock1" assert area2.name == "mock2" - assert len(registry.areas) == 2 + assert len(area_registry.areas) == 2 -async def test_update_area_with_normalized_name_already_in_use(registry): +async def test_update_area_with_normalized_name_already_in_use(area_registry): """Make sure that we can't update an area with a normalized name already in use.""" - area1 = registry.async_create("mock1") - area2 = registry.async_create("Moc k2") + area1 = area_registry.async_create("mock1") + area2 = area_registry.async_create("Moc k2") with pytest.raises(ValueError) as e_info: - registry.async_update(area1.id, name="mock2") + area_registry.async_update(area1.id, name="mock2") assert e_info == "The name mock 2 (mock2) is already in use" assert area1.name == "mock1" assert area2.name == "Moc k2" - assert len(registry.areas) == 2 + assert len(area_registry.areas) == 2 -async def test_load_area(hass, registry): +async def test_load_area(hass, area_registry): """Make sure that we can load/save data correctly.""" - area1 = registry.async_create("mock1") - area2 = registry.async_create("mock2") + area1 = area_registry.async_create("mock1") + area2 = area_registry.async_create("mock2") - assert len(registry.areas) == 2 + assert len(area_registry.areas) == 2 - registry2 = area_registry.AreaRegistry(hass) - await flush_store(registry._store) + registry2 = ar.AreaRegistry(hass) + await flush_store(area_registry._store) await registry2.async_load() - assert list(registry.areas) == list(registry2.areas) + assert list(area_registry.areas) == list(registry2.areas) area1_registry2 = registry2.async_get_or_create("mock1") assert area1_registry2.id == area1.id @@ -228,9 +222,9 @@ async def test_load_area(hass, registry): @pytest.mark.parametrize("load_registries", [False]) async def test_loading_area_from_storage(hass, hass_storage): """Test loading stored areas on start.""" - hass_storage[area_registry.STORAGE_KEY] = { - "version": area_registry.STORAGE_VERSION_MAJOR, - "minor_version": area_registry.STORAGE_VERSION_MINOR, + hass_storage[ar.STORAGE_KEY] = { + "version": ar.STORAGE_VERSION_MAJOR, + "minor_version": ar.STORAGE_VERSION_MINOR, "data": { "areas": [ { @@ -243,8 +237,8 @@ async def test_loading_area_from_storage(hass, hass_storage): }, } - await area_registry.async_load(hass) - registry = area_registry.async_get(hass) + await ar.async_load(hass) + registry = ar.async_get(hass) assert len(registry.areas) == 1 @@ -252,13 +246,13 @@ async def test_loading_area_from_storage(hass, hass_storage): @pytest.mark.parametrize("load_registries", [False]) async def test_migration_from_1_1(hass, hass_storage): """Test migration from version 1.1.""" - hass_storage[area_registry.STORAGE_KEY] = { + hass_storage[ar.STORAGE_KEY] = { "version": 1, "data": {"areas": [{"id": "12345A", "name": "mock"}]}, } - await area_registry.async_load(hass) - registry = area_registry.async_get(hass) + await ar.async_load(hass) + registry = ar.async_get(hass) # Test data was loaded entry = registry.async_get_or_create("mock") @@ -266,49 +260,49 @@ async def test_migration_from_1_1(hass, hass_storage): # Check we store migrated data await flush_store(registry._store) - assert hass_storage[area_registry.STORAGE_KEY] == { - "version": area_registry.STORAGE_VERSION_MAJOR, - "minor_version": area_registry.STORAGE_VERSION_MINOR, - "key": area_registry.STORAGE_KEY, + assert hass_storage[ar.STORAGE_KEY] == { + "version": ar.STORAGE_VERSION_MAJOR, + "minor_version": ar.STORAGE_VERSION_MINOR, + "key": ar.STORAGE_KEY, "data": { "areas": [{"aliases": [], "id": "12345A", "name": "mock", "picture": None}] }, } -async def test_async_get_or_create(hass, registry): +async def test_async_get_or_create(area_registry): """Make sure we can get the area by name.""" - area = registry.async_get_or_create("Mock1") - area2 = registry.async_get_or_create("mock1") - area3 = registry.async_get_or_create("mock 1") + area = area_registry.async_get_or_create("Mock1") + area2 = area_registry.async_get_or_create("mock1") + area3 = area_registry.async_get_or_create("mock 1") assert area == area2 assert area == area3 assert area2 == area3 -async def test_async_get_area_by_name(hass, registry): +async def test_async_get_area_by_name(area_registry): """Make sure we can get the area by name.""" - registry.async_create("Mock1") + area_registry.async_create("Mock1") - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 - assert registry.async_get_area_by_name("M o c k 1").normalized_name == "mock1" + assert area_registry.async_get_area_by_name("M o c k 1").normalized_name == "mock1" -async def test_async_get_area_by_name_not_found(hass, registry): +async def test_async_get_area_by_name_not_found(area_registry): """Make sure we return None for non-existent areas.""" - registry.async_create("Mock1") + area_registry.async_create("Mock1") - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 - assert registry.async_get_area_by_name("non_exist") is None + assert area_registry.async_get_area_by_name("non_exist") is None -async def test_async_get_area(hass, registry): +async def test_async_get_area(area_registry): """Make sure we can get the area by id.""" - area = registry.async_create("Mock1") + area = area_registry.async_create("Mock1") - assert len(registry.areas) == 1 + assert len(area_registry.areas) == 1 - assert registry.async_get_area(area.id).normalized_name == "mock1" + assert area_registry.async_get_area(area.id).normalized_name == "mock1" diff --git a/tests/helpers/test_device_registry.py b/tests/helpers/test_device_registry.py index fd7637d5c53..b0116a158ea 100644 --- a/tests/helpers/test_device_registry.py +++ b/tests/helpers/test_device_registry.py @@ -8,26 +8,9 @@ from homeassistant import config_entries from homeassistant.const import EVENT_HOMEASSISTANT_STARTED from homeassistant.core import CoreState, HomeAssistant, callback from homeassistant.exceptions import RequiredParameterMissing -from homeassistant.helpers import device_registry, entity_registry +from homeassistant.helpers import device_registry as dr, entity_registry as er -from tests.common import ( - MockConfigEntry, - flush_store, - mock_area_registry, - mock_device_registry, -) - - -@pytest.fixture -def registry(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def area_registry(hass): - """Return an empty, loaded, registry.""" - return mock_area_registry(hass) +from tests.common import MockConfigEntry, flush_store @pytest.fixture @@ -39,18 +22,18 @@ def update_events(hass): def async_capture(event): events.append(event.data) - hass.bus.async_listen(device_registry.EVENT_DEVICE_REGISTRY_UPDATED, async_capture) + hass.bus.async_listen(dr.EVENT_DEVICE_REGISTRY_UPDATED, async_capture) return events async def test_get_or_create_returns_same_entry( - hass, registry, area_registry, update_events + hass, device_registry, area_registry, update_events ): """Make sure we do not duplicate entries.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, sw_version="sw-version", name="name", @@ -58,24 +41,24 @@ async def test_get_or_create_returns_same_entry( model="model", suggested_area="Game Room", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "11:22:33:66:77:88")}, + connections={(dr.CONNECTION_NETWORK_MAC, "11:22:33:66:77:88")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", suggested_area="Game Room", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) game_room_area = area_registry.async_get_area_by_name("Game Room") assert game_room_area is not None assert len(area_registry.areas) == 1 - assert len(registry.devices) == 1 + assert len(device_registry.devices) == 1 assert entry.area_id == game_room_area.id assert entry.id == entry2.id assert entry.id == entry3.id @@ -104,16 +87,16 @@ async def test_get_or_create_returns_same_entry( } -async def test_requirement_for_identifier_or_connection(registry): +async def test_requirement_for_identifier_or_connection(device_registry): """Make sure we do require some descriptor of device.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers=set(), manufacturer="manufacturer", model="model", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="1234", connections=set(), identifiers={("bridgeid", "0123")}, @@ -121,12 +104,12 @@ async def test_requirement_for_identifier_or_connection(registry): model="model", ) - assert len(registry.devices) == 2 + assert len(device_registry.devices) == 2 assert entry assert entry2 with pytest.raises(RequiredParameterMissing) as exc_info: - registry.async_get_or_create( + device_registry.async_get_or_create( config_entry_id="1234", connections=set(), identifiers=set(), @@ -137,31 +120,31 @@ async def test_requirement_for_identifier_or_connection(registry): assert exc_info.value.parameter_names == ["identifiers", "connections"] -async def test_multiple_config_entries(registry): +async def test_multiple_config_entries(device_registry): """Make sure we do not get duplicate entries.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="456", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 1 + assert len(device_registry.devices) == 1 assert entry.id == entry2.id assert entry.id == entry3.id assert entry2.config_entries == {"123", "456"} @@ -170,9 +153,9 @@ async def test_multiple_config_entries(registry): @pytest.mark.parametrize("load_registries", [False]) async def test_loading_from_storage(hass, hass_storage): """Test loading stored devices on start.""" - hass_storage[device_registry.STORAGE_KEY] = { - "version": device_registry.STORAGE_VERSION_MAJOR, - "minor_version": device_registry.STORAGE_VERSION_MINOR, + hass_storage[dr.STORAGE_KEY] = { + "version": dr.STORAGE_VERSION_MAJOR, + "minor_version": dr.STORAGE_VERSION_MINOR, "data": { "devices": [ { @@ -180,8 +163,8 @@ async def test_loading_from_storage(hass, hass_storage): "config_entries": ["1234"], "configuration_url": "configuration_url", "connections": [["Zigbee", "01.23.45.67.89"]], - "disabled_by": device_registry.DeviceEntryDisabler.USER, - "entry_type": device_registry.DeviceEntryType.SERVICE, + "disabled_by": dr.DeviceEntryDisabler.USER, + "entry_type": dr.DeviceEntryType.SERVICE, "hw_version": "hw_version", "id": "abcdefghijklm", "identifiers": [["serial", "12:34:56:AB:CD:EF"]], @@ -205,8 +188,8 @@ async def test_loading_from_storage(hass, hass_storage): }, } - await device_registry.async_load(hass) - registry = device_registry.async_get(hass) + await dr.async_load(hass) + registry = dr.async_get(hass) assert len(registry.devices) == 1 assert len(registry.deleted_devices) == 1 @@ -217,13 +200,13 @@ async def test_loading_from_storage(hass, hass_storage): manufacturer="manufacturer", model="model", ) - assert entry == device_registry.DeviceEntry( + assert entry == dr.DeviceEntry( area_id="12345A", config_entries={"1234"}, configuration_url="configuration_url", connections={("Zigbee", "01.23.45.67.89")}, - disabled_by=device_registry.DeviceEntryDisabler.USER, - entry_type=device_registry.DeviceEntryType.SERVICE, + disabled_by=dr.DeviceEntryDisabler.USER, + entry_type=dr.DeviceEntryType.SERVICE, hw_version="hw_version", id="abcdefghijklm", identifiers={("serial", "12:34:56:AB:CD:EF")}, @@ -246,7 +229,7 @@ async def test_loading_from_storage(hass, hass_storage): manufacturer="manufacturer", model="model", ) - assert entry == device_registry.DeviceEntry( + assert entry == dr.DeviceEntry( config_entries={"1234"}, connections={("Zigbee", "23.45.67.89.01")}, id="bcdefghijklmn", @@ -263,7 +246,7 @@ async def test_loading_from_storage(hass, hass_storage): @pytest.mark.parametrize("load_registries", [False]) async def test_migration_1_1_to_1_3(hass, hass_storage): """Test migration from version 1.1 to 1.3.""" - hass_storage[device_registry.STORAGE_KEY] = { + hass_storage[dr.STORAGE_KEY] = { "version": 1, "minor_version": 1, "data": { @@ -308,8 +291,8 @@ async def test_migration_1_1_to_1_3(hass, hass_storage): }, } - await device_registry.async_load(hass) - registry = device_registry.async_get(hass) + await dr.async_load(hass) + registry = dr.async_get(hass) # Test data was loaded entry = registry.async_get_or_create( @@ -330,10 +313,10 @@ async def test_migration_1_1_to_1_3(hass, hass_storage): # Check we store migrated data await flush_store(registry._store) - assert hass_storage[device_registry.STORAGE_KEY] == { - "version": device_registry.STORAGE_VERSION_MAJOR, - "minor_version": device_registry.STORAGE_VERSION_MINOR, - "key": device_registry.STORAGE_KEY, + assert hass_storage[dr.STORAGE_KEY] == { + "version": dr.STORAGE_VERSION_MAJOR, + "minor_version": dr.STORAGE_VERSION_MINOR, + "key": dr.STORAGE_KEY, "data": { "devices": [ { @@ -387,10 +370,10 @@ async def test_migration_1_1_to_1_3(hass, hass_storage): @pytest.mark.parametrize("load_registries", [False]) async def test_migration_1_2_to_1_3(hass, hass_storage): """Test migration from version 1.2 to 1.3.""" - hass_storage[device_registry.STORAGE_KEY] = { + hass_storage[dr.STORAGE_KEY] = { "version": 1, "minor_version": 2, - "key": device_registry.STORAGE_KEY, + "key": dr.STORAGE_KEY, "data": { "devices": [ { @@ -430,8 +413,8 @@ async def test_migration_1_2_to_1_3(hass, hass_storage): }, } - await device_registry.async_load(hass) - registry = device_registry.async_get(hass) + await dr.async_load(hass) + registry = dr.async_get(hass) # Test data was loaded entry = registry.async_get_or_create( @@ -453,10 +436,10 @@ async def test_migration_1_2_to_1_3(hass, hass_storage): # Check we store migrated data await flush_store(registry._store) - assert hass_storage[device_registry.STORAGE_KEY] == { - "version": device_registry.STORAGE_VERSION_MAJOR, - "minor_version": device_registry.STORAGE_VERSION_MINOR, - "key": device_registry.STORAGE_KEY, + assert hass_storage[dr.STORAGE_KEY] == { + "version": dr.STORAGE_VERSION_MAJOR, + "minor_version": dr.STORAGE_VERSION_MINOR, + "key": dr.STORAGE_KEY, "data": { "devices": [ { @@ -499,38 +482,38 @@ async def test_migration_1_2_to_1_3(hass, hass_storage): } -async def test_removing_config_entries(hass, registry, update_events): +async def test_removing_config_entries(hass, device_registry, update_events): """Make sure we do not get duplicate entries.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="456", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, identifiers={("bridgeid", "4567")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 2 + assert len(device_registry.devices) == 2 assert entry.id == entry2.id assert entry.id != entry3.id assert entry2.config_entries == {"123", "456"} - registry.async_clear_config_entry("123") - entry = registry.async_get_device({("bridgeid", "0123")}) - entry3_removed = registry.async_get_device({("bridgeid", "4567")}) + device_registry.async_clear_config_entry("123") + entry = device_registry.async_get_device({("bridgeid", "0123")}) + entry3_removed = device_registry.async_get_device({("bridgeid", "4567")}) assert entry.config_entries == {"456"} assert entry3_removed is None @@ -555,41 +538,43 @@ async def test_removing_config_entries(hass, registry, update_events): assert "changes" not in update_events[4] -async def test_deleted_device_removing_config_entries(hass, registry, update_events): +async def test_deleted_device_removing_config_entries( + hass, device_registry, update_events +): """Make sure we do not get duplicate entries.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="456", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, identifiers={("bridgeid", "4567")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 2 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 2 + assert len(device_registry.deleted_devices) == 0 assert entry.id == entry2.id assert entry.id != entry3.id assert entry2.config_entries == {"123", "456"} - registry.async_remove_device(entry.id) - registry.async_remove_device(entry3.id) + device_registry.async_remove_device(entry.id) + device_registry.async_remove_device(entry3.id) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 2 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 2 await hass.async_block_till_done() assert len(update_events) == 5 @@ -609,22 +594,22 @@ async def test_deleted_device_removing_config_entries(hass, registry, update_eve assert update_events[4]["device_id"] == entry3.id assert "changes" not in update_events[4] - registry.async_clear_config_entry("123") - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 2 + device_registry.async_clear_config_entry("123") + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 2 - registry.async_clear_config_entry("456") - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 2 + device_registry.async_clear_config_entry("456") + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 2 # No event when a deleted device is purged await hass.async_block_till_done() assert len(update_events) == 5 # Re-add, expect to keep the device id - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="456", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", @@ -632,15 +617,15 @@ async def test_deleted_device_removing_config_entries(hass, registry, update_eve assert entry.id == entry2.id - future_time = time.time() + device_registry.ORPHANED_DEVICE_KEEP_SECONDS + 1 + future_time = time.time() + dr.ORPHANED_DEVICE_KEEP_SECONDS + 1 with patch("time.time", return_value=future_time): - registry.async_purge_expired_orphaned_devices() + device_registry.async_purge_expired_orphaned_devices() # Re-add, expect to get a new device id after the purge - entry4 = registry.async_get_or_create( + entry4 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", @@ -648,36 +633,36 @@ async def test_deleted_device_removing_config_entries(hass, registry, update_eve assert entry3.id != entry4.id -async def test_removing_area_id(registry): +async def test_removing_area_id(device_registry): """Make sure we can clear area id.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry_w_area = registry.async_update_device(entry.id, area_id="12345A") + entry_w_area = device_registry.async_update_device(entry.id, area_id="12345A") - registry.async_clear_area_id("12345A") - entry_wo_area = registry.async_get_device({("bridgeid", "0123")}) + device_registry.async_clear_area_id("12345A") + entry_wo_area = device_registry.async_get_device({("bridgeid", "0123")}) assert not entry_wo_area.area_id assert entry_w_area != entry_wo_area -async def test_specifying_via_device_create(registry): +async def test_specifying_via_device_create(device_registry): """Test specifying a via_device and removal of the hub device.""" - via = registry.async_get_or_create( + via = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("hue", "0123")}, manufacturer="manufacturer", model="via", ) - light = registry.async_get_or_create( + light = device_registry.async_get_or_create( config_entry_id="456", connections=set(), identifiers={("hue", "456")}, @@ -688,14 +673,14 @@ async def test_specifying_via_device_create(registry): assert light.via_device_id == via.id - registry.async_remove_device(via.id) - light = registry.async_get_device({("hue", "456")}) + device_registry.async_remove_device(via.id) + light = device_registry.async_get_device({("hue", "456")}) assert light.via_device_id is None -async def test_specifying_via_device_update(registry): +async def test_specifying_via_device_update(device_registry): """Test specifying a via_device and updating.""" - light = registry.async_get_or_create( + light = device_registry.async_get_or_create( config_entry_id="456", connections=set(), identifiers={("hue", "456")}, @@ -706,15 +691,15 @@ async def test_specifying_via_device_update(registry): assert light.via_device_id is None - via = registry.async_get_or_create( + via = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("hue", "0123")}, manufacturer="manufacturer", model="via", ) - light = registry.async_get_or_create( + light = device_registry.async_get_or_create( config_entry_id="456", connections=set(), identifiers={("hue", "456")}, @@ -726,11 +711,11 @@ async def test_specifying_via_device_update(registry): assert light.via_device_id == via.id -async def test_loading_saving_data(hass, registry, area_registry): +async def test_loading_saving_data(hass, device_registry): """Test that we load/save data correctly.""" - orig_via = registry.async_get_or_create( + orig_via = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("hue", "0123")}, manufacturer="manufacturer", model="via", @@ -739,17 +724,17 @@ async def test_loading_saving_data(hass, registry, area_registry): entry_type=None, ) - orig_light = registry.async_get_or_create( + orig_light = device_registry.async_get_or_create( config_entry_id="456", connections=set(), identifiers={("hue", "456")}, manufacturer="manufacturer", model="light", via_device=("hue", "0123"), - disabled_by=device_registry.DeviceEntryDisabler.USER, + disabled_by=dr.DeviceEntryDisabler.USER, ) - orig_light2 = registry.async_get_or_create( + orig_light2 = device_registry.async_get_or_create( config_entry_id="456", connections=set(), identifiers={("hue", "789")}, @@ -758,63 +743,63 @@ async def test_loading_saving_data(hass, registry, area_registry): via_device=("hue", "0123"), ) - registry.async_remove_device(orig_light2.id) + device_registry.async_remove_device(orig_light2.id) - orig_light3 = registry.async_get_or_create( + orig_light3 = device_registry.async_get_or_create( config_entry_id="789", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, identifiers={("hue", "abc")}, manufacturer="manufacturer", model="light", ) - registry.async_get_or_create( + device_registry.async_get_or_create( config_entry_id="abc", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, identifiers={("abc", "123")}, manufacturer="manufacturer", model="light", ) - registry.async_remove_device(orig_light3.id) + device_registry.async_remove_device(orig_light3.id) - orig_light4 = registry.async_get_or_create( + orig_light4 = device_registry.async_get_or_create( config_entry_id="789", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, identifiers={("hue", "abc")}, manufacturer="manufacturer", model="light", - entry_type=device_registry.DeviceEntryType.SERVICE, + entry_type=dr.DeviceEntryType.SERVICE, ) assert orig_light4.id == orig_light3.id - orig_kitchen_light = registry.async_get_or_create( + orig_kitchen_light = device_registry.async_get_or_create( config_entry_id="999", connections=set(), identifiers={("hue", "999")}, manufacturer="manufacturer", model="light", via_device=("hue", "0123"), - disabled_by=device_registry.DeviceEntryDisabler.USER, + disabled_by=dr.DeviceEntryDisabler.USER, suggested_area="Kitchen", ) - assert len(registry.devices) == 4 - assert len(registry.deleted_devices) == 1 + assert len(device_registry.devices) == 4 + assert len(device_registry.deleted_devices) == 1 - orig_via = registry.async_update_device( + orig_via = device_registry.async_update_device( orig_via.id, area_id="mock-area-id", name_by_user="mock-name-by-user" ) # Now load written data in new registry - registry2 = device_registry.DeviceRegistry(hass) - await flush_store(registry._store) + registry2 = dr.DeviceRegistry(hass) + await flush_store(device_registry._store) await registry2.async_load() # Ensure same order - assert list(registry.devices) == list(registry2.devices) - assert list(registry.deleted_devices) == list(registry2.deleted_devices) + assert list(device_registry.devices) == list(registry2.devices) + assert list(device_registry.deleted_devices) == list(registry2.deleted_devices) new_via = registry2.async_get_device({("hue", "0123")}) new_light = registry2.async_get_device({("hue", "456")}) @@ -837,16 +822,16 @@ async def test_loading_saving_data(hass, registry, area_registry): new_kitchen_light = registry2.async_get_device({("hue", "999")}) assert orig_kitchen_light.suggested_area == "Kitchen" - orig_kitchen_light_witout_suggested_area = registry.async_update_device( + orig_kitchen_light_witout_suggested_area = device_registry.async_update_device( orig_kitchen_light.id, suggested_area=None ) assert orig_kitchen_light_witout_suggested_area.suggested_area is None assert orig_kitchen_light_witout_suggested_area == new_kitchen_light -async def test_no_unnecessary_changes(registry): +async def test_no_unnecessary_changes(device_registry): """Make sure we do not consider devices changes.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", connections={("ethernet", "12:34:56:78:90:AB:CD:EF")}, identifiers={("hue", "456"), ("bla", "123")}, @@ -854,7 +839,7 @@ async def test_no_unnecessary_changes(registry): with patch( "homeassistant.helpers.device_registry.DeviceRegistry.async_schedule_save" ) as mock_save: - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("hue", "456")} ) @@ -862,20 +847,20 @@ async def test_no_unnecessary_changes(registry): assert len(mock_save.mock_calls) == 0 -async def test_format_mac(registry): +async def test_format_mac(device_registry): """Make sure we normalize mac addresses.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for mac in ["123456ABCDEF", "123456abcdef", "12:34:56:ab:cd:ef", "1234.56ab.cdef"]: - test_entry = registry.async_get_or_create( + test_entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, mac)}, + connections={(dr.CONNECTION_NETWORK_MAC, mac)}, ) assert test_entry.id == entry.id, mac assert test_entry.connections == { - (device_registry.CONNECTION_NETWORK_MAC, "12:34:56:ab:cd:ef") + (dr.CONNECTION_NETWORK_MAC, "12:34:56:ab:cd:ef") } # This should not raise @@ -887,31 +872,31 @@ async def test_format_mac(registry): "1234.56abcdef", # not enough . "123.456.abc.def", # too many . ]: - invalid_mac_entry = registry.async_get_or_create( + invalid_mac_entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, invalid)}, + connections={(dr.CONNECTION_NETWORK_MAC, invalid)}, ) assert list(invalid_mac_entry.connections)[0][1] == invalid -async def test_update(hass, registry, update_events): +async def test_update(hass, device_registry, update_events): """Verify that we can update some attributes of a device.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("hue", "456"), ("bla", "123")}, ) new_identifiers = {("hue", "654"), ("bla", "321")} assert not entry.area_id assert not entry.name_by_user - with patch.object(registry, "async_schedule_save") as mock_save: - updated_entry = registry.async_update_device( + with patch.object(device_registry, "async_schedule_save") as mock_save: + updated_entry = device_registry.async_update_device( entry.id, area_id="12345A", configuration_url="configuration_url", - disabled_by=device_registry.DeviceEntryDisabler.USER, - entry_type=device_registry.DeviceEntryType.SERVICE, + disabled_by=dr.DeviceEntryDisabler.USER, + entry_type=dr.DeviceEntryType.SERVICE, hw_version="hw_version", manufacturer="Test Producer", model="Test Model", @@ -925,13 +910,13 @@ async def test_update(hass, registry, update_events): assert mock_save.call_count == 1 assert updated_entry != entry - assert updated_entry == device_registry.DeviceEntry( + assert updated_entry == dr.DeviceEntry( area_id="12345A", config_entries={"1234"}, configuration_url="configuration_url", connections={("mac", "12:34:56:ab:cd:ef")}, - disabled_by=device_registry.DeviceEntryDisabler.USER, - entry_type=device_registry.DeviceEntryType.SERVICE, + disabled_by=dr.DeviceEntryDisabler.USER, + entry_type=dr.DeviceEntryType.SERVICE, hw_version="hw_version", id=entry.id, identifiers={("bla", "321"), ("hue", "654")}, @@ -944,20 +929,20 @@ async def test_update(hass, registry, update_events): via_device_id="98765B", ) - assert registry.async_get_device({("hue", "456")}) is None - assert registry.async_get_device({("bla", "123")}) is None + assert device_registry.async_get_device({("hue", "456")}) is None + assert device_registry.async_get_device({("bla", "123")}) is None - assert registry.async_get_device({("hue", "654")}) == updated_entry - assert registry.async_get_device({("bla", "321")}) == updated_entry + assert device_registry.async_get_device({("hue", "654")}) == updated_entry + assert device_registry.async_get_device({("bla", "321")}) == updated_entry assert ( - registry.async_get_device( - {}, {(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")} + device_registry.async_get_device( + {}, {(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")} ) == updated_entry ) - assert registry.async_get(updated_entry.id) is not None + assert device_registry.async_get(updated_entry.id) is not None await hass.async_block_till_done() @@ -984,46 +969,46 @@ async def test_update(hass, registry, update_events): } -async def test_update_remove_config_entries(hass, registry, update_events): +async def test_update_remove_config_entries(hass, device_registry, update_events): """Make sure we do not get duplicate entries.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="456", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, identifiers={("bridgeid", "4567")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 2 + assert len(device_registry.devices) == 2 assert entry.id == entry2.id assert entry.id != entry3.id assert entry2.config_entries == {"123", "456"} - updated_entry = registry.async_update_device( + updated_entry = device_registry.async_update_device( entry2.id, remove_config_entry_id="123" ) - removed_entry = registry.async_update_device( + removed_entry = device_registry.async_update_device( entry3.id, remove_config_entry_id="123" ) assert updated_entry.config_entries == {"456"} assert removed_entry is None - removed_entry = registry.async_get_device({("bridgeid", "4567")}) + removed_entry = device_registry.async_get_device({("bridgeid", "4567")}) assert removed_entry is None @@ -1047,11 +1032,13 @@ async def test_update_remove_config_entries(hass, registry, update_events): assert "changes" not in update_events[4] -async def test_update_suggested_area(hass, registry, area_registry, update_events): +async def test_update_suggested_area( + hass, device_registry, area_registry, update_events +): """Verify that we can update the suggested area version of a device.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bla", "123")}, ) assert not entry.suggested_area @@ -1059,8 +1046,8 @@ async def test_update_suggested_area(hass, registry, area_registry, update_event suggested_area = "Pool" - with patch.object(registry, "async_schedule_save") as mock_save: - updated_entry = registry.async_update_device( + with patch.object(device_registry, "async_schedule_save") as mock_save: + updated_entry = device_registry.async_update_device( entry.id, suggested_area=suggested_area ) @@ -1086,77 +1073,81 @@ async def test_update_suggested_area(hass, registry, area_registry, update_event # Do not save or fire the event if the suggested # area does not result in a change of area # but still update the actual entry - with patch.object(registry, "async_schedule_save") as mock_save_2: - updated_entry = registry.async_update_device(entry.id, suggested_area="Other") + with patch.object(device_registry, "async_schedule_save") as mock_save_2: + updated_entry = device_registry.async_update_device( + entry.id, suggested_area="Other" + ) assert len(update_events) == 2 assert mock_save_2.call_count == 0 assert updated_entry != entry assert updated_entry.suggested_area == "Other" -async def test_cleanup_device_registry(hass, registry): +async def test_cleanup_device_registry(hass, device_registry): """Test cleanup works.""" config_entry = MockConfigEntry(domain="hue") config_entry.add_to_hass(hass) - d1 = registry.async_get_or_create( + d1 = device_registry.async_get_or_create( identifiers={("hue", "d1")}, config_entry_id=config_entry.entry_id ) - registry.async_get_or_create( + device_registry.async_get_or_create( identifiers={("hue", "d2")}, config_entry_id=config_entry.entry_id ) - d3 = registry.async_get_or_create( + d3 = device_registry.async_get_or_create( identifiers={("hue", "d3")}, config_entry_id=config_entry.entry_id ) - registry.async_get_or_create( + device_registry.async_get_or_create( identifiers={("something", "d4")}, config_entry_id="non_existing" ) - ent_reg = entity_registry.async_get(hass) + ent_reg = er.async_get(hass) ent_reg.async_get_or_create("light", "hue", "e1", device_id=d1.id) ent_reg.async_get_or_create("light", "hue", "e2", device_id=d1.id) ent_reg.async_get_or_create("light", "hue", "e3", device_id=d3.id) - device_registry.async_cleanup(hass, registry, ent_reg) + dr.async_cleanup(hass, device_registry, ent_reg) - assert registry.async_get_device({("hue", "d1")}) is not None - assert registry.async_get_device({("hue", "d2")}) is not None - assert registry.async_get_device({("hue", "d3")}) is not None - assert registry.async_get_device({("something", "d4")}) is None + assert device_registry.async_get_device({("hue", "d1")}) is not None + assert device_registry.async_get_device({("hue", "d2")}) is not None + assert device_registry.async_get_device({("hue", "d3")}) is not None + assert device_registry.async_get_device({("something", "d4")}) is None -async def test_cleanup_device_registry_removes_expired_orphaned_devices(hass, registry): +async def test_cleanup_device_registry_removes_expired_orphaned_devices( + hass, device_registry +): """Test cleanup removes expired orphaned devices.""" config_entry = MockConfigEntry(domain="hue") config_entry.add_to_hass(hass) - registry.async_get_or_create( + device_registry.async_get_or_create( identifiers={("hue", "d1")}, config_entry_id=config_entry.entry_id ) - registry.async_get_or_create( + device_registry.async_get_or_create( identifiers={("hue", "d2")}, config_entry_id=config_entry.entry_id ) - registry.async_get_or_create( + device_registry.async_get_or_create( identifiers={("hue", "d3")}, config_entry_id=config_entry.entry_id ) - registry.async_clear_config_entry(config_entry.entry_id) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 3 + device_registry.async_clear_config_entry(config_entry.entry_id) + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 3 - ent_reg = entity_registry.async_get(hass) - device_registry.async_cleanup(hass, registry, ent_reg) + ent_reg = er.async_get(hass) + dr.async_cleanup(hass, device_registry, ent_reg) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 3 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 3 - future_time = time.time() + device_registry.ORPHANED_DEVICE_KEEP_SECONDS + 1 + future_time = time.time() + dr.ORPHANED_DEVICE_KEEP_SECONDS + 1 with patch("time.time", return_value=future_time): - device_registry.async_cleanup(hass, registry, ent_reg) + dr.async_cleanup(hass, device_registry, ent_reg) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 0 async def test_cleanup_startup(hass: HomeAssistant) -> None: @@ -1179,9 +1170,9 @@ async def test_cleanup_entity_registry_change(hass: HomeAssistant) -> None: Don't pre-load the registries as the debouncer will then not be waiting for EVENT_ENTITY_REGISTRY_UPDATED events. """ - await device_registry.async_load(hass) - await entity_registry.async_load(hass) - ent_reg = entity_registry.async_get(hass) + await dr.async_load(hass) + await er.async_load(hass) + ent_reg = er.async_get(hass) with patch( "homeassistant.helpers.device_registry.Debouncer.async_call" @@ -1206,34 +1197,34 @@ async def test_cleanup_entity_registry_change(hass: HomeAssistant) -> None: assert len(mock_call.mock_calls) == 2 -async def test_restore_device(hass, registry, update_events): +async def test_restore_device(hass, device_registry, update_events): """Make sure device id is stable.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 - registry.async_remove_device(entry.id) + device_registry.async_remove_device(entry.id) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 1 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 1 - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, identifiers={("bridgeid", "4567")}, manufacturer="manufacturer", model="model", ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, manufacturer="manufacturer", model="model", @@ -1241,8 +1232,8 @@ async def test_restore_device(hass, registry, update_events): assert entry.id == entry3.id assert entry.id != entry2.id - assert len(registry.devices) == 2 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 2 + assert len(device_registry.deleted_devices) == 0 assert isinstance(entry3.config_entries, set) assert isinstance(entry3.connections, set) @@ -1265,37 +1256,37 @@ async def test_restore_device(hass, registry, update_events): assert "changes" not in update_events[3] -async def test_restore_simple_device(hass, registry, update_events): +async def test_restore_simple_device(hass, device_registry, update_events): """Make sure device id is stable.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, ) - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 - registry.async_remove_device(entry.id) + device_registry.async_remove_device(entry.id) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 1 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 1 - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:78:CD:EF:12")}, identifiers={("bridgeid", "4567")}, ) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, ) assert entry.id == entry3.id assert entry.id != entry2.id - assert len(registry.devices) == 2 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 2 + assert len(device_registry.deleted_devices) == 0 await hass.async_block_till_done() @@ -1314,80 +1305,80 @@ async def test_restore_simple_device(hass, registry, update_events): assert "changes" not in update_events[3] -async def test_restore_shared_device(hass, registry, update_events): +async def test_restore_shared_device(hass, device_registry, update_events): """Make sure device id is stable for shared devices.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("entry_123", "0123")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 - registry.async_get_or_create( + device_registry.async_get_or_create( config_entry_id="234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("entry_234", "2345")}, manufacturer="manufacturer", model="model", ) - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 - registry.async_remove_device(entry.id) + device_registry.async_remove_device(entry.id) - assert len(registry.devices) == 0 - assert len(registry.deleted_devices) == 1 + assert len(device_registry.devices) == 0 + assert len(device_registry.deleted_devices) == 1 - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("entry_123", "0123")}, manufacturer="manufacturer", model="model", ) assert entry.id == entry2.id - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 assert isinstance(entry2.config_entries, set) assert isinstance(entry2.connections, set) assert isinstance(entry2.identifiers, set) - registry.async_remove_device(entry.id) + device_registry.async_remove_device(entry.id) - entry3 = registry.async_get_or_create( + entry3 = device_registry.async_get_or_create( config_entry_id="234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("entry_234", "2345")}, manufacturer="manufacturer", model="model", ) assert entry.id == entry3.id - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 assert isinstance(entry3.config_entries, set) assert isinstance(entry3.connections, set) assert isinstance(entry3.identifiers, set) - entry4 = registry.async_get_or_create( + entry4 = device_registry.async_get_or_create( config_entry_id="123", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("entry_123", "0123")}, manufacturer="manufacturer", model="model", ) assert entry.id == entry4.id - assert len(registry.devices) == 1 - assert len(registry.deleted_devices) == 0 + assert len(device_registry.devices) == 1 + assert len(device_registry.deleted_devices) == 0 assert isinstance(entry4.config_entries, set) assert isinstance(entry4.connections, set) @@ -1425,16 +1416,16 @@ async def test_restore_shared_device(hass, registry, update_events): } -async def test_get_or_create_empty_then_set_default_values(hass, registry): +async def test_get_or_create_empty_then_set_default_values(device_registry): """Test creating an entry, then setting default name, model, manufacturer.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( identifiers={("bridgeid", "0123")}, config_entry_id="1234" ) assert entry.name is None assert entry.model is None assert entry.manufacturer is None - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, default_name="default name 1", @@ -1445,7 +1436,7 @@ async def test_get_or_create_empty_then_set_default_values(hass, registry): assert entry.model == "default model 1" assert entry.manufacturer == "default manufacturer 1" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, default_name="default name 2", @@ -1457,16 +1448,16 @@ async def test_get_or_create_empty_then_set_default_values(hass, registry): assert entry.manufacturer == "default manufacturer 1" -async def test_get_or_create_empty_then_update(hass, registry): +async def test_get_or_create_empty_then_update(device_registry): """Test creating an entry, then setting name, model, manufacturer.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( identifiers={("bridgeid", "0123")}, config_entry_id="1234" ) assert entry.name is None assert entry.model is None assert entry.manufacturer is None - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, name="name 1", @@ -1477,7 +1468,7 @@ async def test_get_or_create_empty_then_update(hass, registry): assert entry.model == "model 1" assert entry.manufacturer == "manufacturer 1" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, default_name="default name 1", @@ -1489,9 +1480,9 @@ async def test_get_or_create_empty_then_update(hass, registry): assert entry.manufacturer == "manufacturer 1" -async def test_get_or_create_sets_default_values(hass, registry): +async def test_get_or_create_sets_default_values(device_registry): """Test creating an entry, then setting default name, model, manufacturer.""" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, default_name="default name 1", @@ -1502,7 +1493,7 @@ async def test_get_or_create_sets_default_values(hass, registry): assert entry.model == "default model 1" assert entry.manufacturer == "default manufacturer 1" - entry = registry.async_get_or_create( + entry = device_registry.async_get_or_create( config_entry_id="1234", identifiers={("bridgeid", "0123")}, default_name="default name 2", @@ -1515,27 +1506,29 @@ async def test_get_or_create_sets_default_values(hass, registry): async def test_verify_suggested_area_does_not_overwrite_area_id( - hass, registry, area_registry + device_registry, area_registry ): """Make sure suggested area does not override a set area id.""" game_room_area = area_registry.async_create("Game Room") - original_entry = registry.async_get_or_create( + original_entry = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, sw_version="sw-version", name="name", manufacturer="manufacturer", model="model", ) - entry = registry.async_update_device(original_entry.id, area_id=game_room_area.id) + entry = device_registry.async_update_device( + original_entry.id, area_id=game_room_area.id + ) assert entry.area_id == game_room_area.id - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id="1234", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, identifiers={("bridgeid", "0123")}, sw_version="sw-version", name="name", @@ -1546,19 +1539,19 @@ async def test_verify_suggested_area_does_not_overwrite_area_id( assert entry2.area_id == game_room_area.id -async def test_disable_config_entry_disables_devices(hass, registry): +async def test_disable_config_entry_disables_devices(hass, device_registry): """Test that we disable entities tied to a config entry.""" config_entry = MockConfigEntry(domain="light") config_entry.add_to_hass(hass) - entry1 = registry.async_get_or_create( + entry1 = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry2 = registry.async_get_or_create( + entry2 = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, - disabled_by=device_registry.DeviceEntryDisabler.USER, + connections={(dr.CONNECTION_NETWORK_MAC, "34:56:AB:CD:EF:12")}, + disabled_by=dr.DeviceEntryDisabler.USER, ) assert not entry1.disabled @@ -1569,37 +1562,39 @@ async def test_disable_config_entry_disables_devices(hass, registry): ) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.id) + entry1 = device_registry.async_get(entry1.id) assert entry1.disabled - assert entry1.disabled_by is device_registry.DeviceEntryDisabler.CONFIG_ENTRY - entry2 = registry.async_get(entry2.id) + assert entry1.disabled_by is dr.DeviceEntryDisabler.CONFIG_ENTRY + entry2 = device_registry.async_get(entry2.id) assert entry2.disabled - assert entry2.disabled_by is device_registry.DeviceEntryDisabler.USER + assert entry2.disabled_by is dr.DeviceEntryDisabler.USER await hass.config_entries.async_set_disabled_by(config_entry.entry_id, None) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.id) + entry1 = device_registry.async_get(entry1.id) assert not entry1.disabled - entry2 = registry.async_get(entry2.id) + entry2 = device_registry.async_get(entry2.id) assert entry2.disabled - assert entry2.disabled_by is device_registry.DeviceEntryDisabler.USER + assert entry2.disabled_by is dr.DeviceEntryDisabler.USER -async def test_only_disable_device_if_all_config_entries_are_disabled(hass, registry): +async def test_only_disable_device_if_all_config_entries_are_disabled( + hass, device_registry +): """Test that we only disable device if all related config entries are disabled.""" config_entry1 = MockConfigEntry(domain="light") config_entry1.add_to_hass(hass) config_entry2 = MockConfigEntry(domain="light") config_entry2.add_to_hass(hass) - registry.async_get_or_create( + device_registry.async_get_or_create( config_entry_id=config_entry1.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry1 = registry.async_get_or_create( + entry1 = device_registry.async_get_or_create( config_entry_id=config_entry2.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) assert len(entry1.config_entries) == 2 assert not entry1.disabled @@ -1609,7 +1604,7 @@ async def test_only_disable_device_if_all_config_entries_are_disabled(hass, regi ) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.id) + entry1 = device_registry.async_get(entry1.id) assert not entry1.disabled await hass.config_entries.async_set_disabled_by( @@ -1617,12 +1612,12 @@ async def test_only_disable_device_if_all_config_entries_are_disabled(hass, regi ) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.id) + entry1 = device_registry.async_get(entry1.id) assert entry1.disabled - assert entry1.disabled_by is device_registry.DeviceEntryDisabler.CONFIG_ENTRY + assert entry1.disabled_by is dr.DeviceEntryDisabler.CONFIG_ENTRY await hass.config_entries.async_set_disabled_by(config_entry1.entry_id, None) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.id) + entry1 = device_registry.async_get(entry1.id) assert not entry1.disabled diff --git a/tests/helpers/test_entity.py b/tests/helpers/test_entity.py index 80298686dde..8ad41c59f4c 100644 --- a/tests/helpers/test_entity.py +++ b/tests/helpers/test_entity.py @@ -776,19 +776,21 @@ async def test_removing_entity_unavailable(hass: HomeAssistant) -> None: assert state.state == STATE_UNAVAILABLE -async def test_get_supported_features_entity_registry(hass: HomeAssistant) -> None: +async def test_get_supported_features_entity_registry( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test get_supported_features falls back to entity registry.""" - entity_reg = mock_registry(hass) - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( "hello", "world", "5678", supported_features=456 ).entity_id assert entity.get_supported_features(hass, entity_id) == 456 -async def test_get_supported_features_prioritize_state(hass: HomeAssistant) -> None: +async def test_get_supported_features_prioritize_state( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test get_supported_features gives priority to state.""" - entity_reg = mock_registry(hass) - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( "hello", "world", "5678", supported_features=456 ).entity_id assert entity.get_supported_features(hass, entity_id) == 456 diff --git a/tests/helpers/test_entity_platform.py b/tests/helpers/test_entity_platform.py index e1473bbc4cb..c9df8f14ac6 100644 --- a/tests/helpers/test_entity_platform.py +++ b/tests/helpers/test_entity_platform.py @@ -508,13 +508,14 @@ async def test_using_prescribed_entity_id_with_unique_id(hass: HomeAssistant) -> async def test_using_prescribed_entity_id_which_is_registered( - hass: HomeAssistant, + hass: HomeAssistant, entity_registry: er.EntityRegistry ) -> None: """Test not allowing predefined entity ID that already registered.""" component = EntityComponent(_LOGGER, DOMAIN, hass) - registry = mock_registry(hass) # Register test_domain.world - registry.async_get_or_create(DOMAIN, "test", "1234", suggested_object_id="world") + entity_registry.async_get_or_create( + DOMAIN, "test", "1234", suggested_object_id="world" + ) # This entity_id will be rewritten await component.async_add_entities([MockEntity(entity_id="test_domain.world")]) @@ -522,13 +523,16 @@ async def test_using_prescribed_entity_id_which_is_registered( assert "test_domain.world_2" in hass.states.async_entity_ids() -async def test_name_which_conflict_with_registered(hass: HomeAssistant) -> None: +async def test_name_which_conflict_with_registered( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test not generating conflicting entity ID based on name.""" component = EntityComponent(_LOGGER, DOMAIN, hass) - registry = mock_registry(hass) # Register test_domain.world - registry.async_get_or_create(DOMAIN, "test", "1234", suggested_object_id="world") + entity_registry.async_get_or_create( + DOMAIN, "test", "1234", suggested_object_id="world" + ) await component.async_add_entities([MockEntity(name="world")]) @@ -570,9 +574,10 @@ async def test_overriding_name_from_registry(hass: HomeAssistant) -> None: assert state.name == "Overridden" -async def test_registry_respect_entity_namespace(hass: HomeAssistant) -> None: +async def test_registry_respect_entity_namespace( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test that the registry respects entity namespace.""" - mock_registry(hass) platform = MockEntityPlatform(hass, entity_namespace="ns") entity = MockEntity(unique_id="1234", name="Device Name") await platform.async_add_entities([entity]) @@ -652,9 +657,10 @@ async def test_entity_registry_updates_name(hass: HomeAssistant) -> None: assert state.name == "after update" -async def test_setup_entry(hass: HomeAssistant) -> None: +async def test_setup_entry( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test we can setup an entry.""" - registry = mock_registry(hass) async def async_setup_entry(hass, config_entry, async_add_entities): """Mock setup entry method.""" @@ -672,8 +678,10 @@ async def test_setup_entry(hass: HomeAssistant) -> None: full_name = f"{entity_platform.domain}.{config_entry.domain}" assert full_name in hass.config.components assert len(hass.states.async_entity_ids()) == 1 - assert len(registry.entities) == 1 - assert registry.entities["test_domain.test1"].config_entry_id == "super-mock-id" + assert len(entity_registry.entities) == 1 + assert ( + entity_registry.entities["test_domain.test1"].config_entry_id == "super-mock-id" + ) async def test_setup_entry_platform_not_ready(hass, caplog): @@ -1275,10 +1283,11 @@ async def test_entity_info_added_to_entity_registry(hass: HomeAssistant) -> None ) -async def test_override_restored_entities(hass: HomeAssistant) -> None: +async def test_override_restored_entities( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test that we allow overriding restored entities.""" - registry = mock_registry(hass) - registry.async_get_or_create( + entity_registry.async_get_or_create( "test_domain", "test_domain", "1234", suggested_object_id="world" ) @@ -1369,9 +1378,10 @@ class MockBlockingEntity(MockEntity): await asyncio.sleep(1000) -async def test_setup_entry_with_entities_that_block_forever(hass, caplog): +async def test_setup_entry_with_entities_that_block_forever( + hass, caplog, entity_registry +): """Test we cancel adding entities when we reach the timeout.""" - registry = mock_registry(hass) async def async_setup_entry(hass, config_entry, async_add_entities): """Mock setup entry method.""" @@ -1392,7 +1402,7 @@ async def test_setup_entry_with_entities_that_block_forever(hass, caplog): full_name = f"{mock_entity_platform.domain}.{config_entry.domain}" assert full_name in hass.config.components assert len(hass.states.async_entity_ids()) == 0 - assert len(registry.entities) == 1 + assert len(entity_registry.entities) == 1 assert "Timed out adding entities" in caplog.text assert "test_domain.test1" in caplog.text assert "test_domain" in caplog.text diff --git a/tests/helpers/test_entity_registry.py b/tests/helpers/test_entity_registry.py index 37de867b57a..11bf294073b 100644 --- a/tests/helpers/test_entity_registry.py +++ b/tests/helpers/test_entity_registry.py @@ -11,22 +11,11 @@ from homeassistant.exceptions import MaxLengthExceeded from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity import EntityCategory -from tests.common import ( - MockConfigEntry, - flush_store, - mock_device_registry, - mock_registry, -) +from tests.common import MockConfigEntry, flush_store YAML__OPEN_PATH = "homeassistant.util.yaml.loader.open" -@pytest.fixture -def registry(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def update_events(hass): """Capture update events.""" @@ -41,14 +30,14 @@ def update_events(hass): return events -async def test_get_or_create_returns_same_entry(hass, registry, update_events): +async def test_get_or_create_returns_same_entry(hass, entity_registry, update_events): """Make sure we do not duplicate entries.""" - entry = registry.async_get_or_create("light", "hue", "1234") - entry2 = registry.async_get_or_create("light", "hue", "1234") + entry = entity_registry.async_get_or_create("light", "hue", "1234") + entry2 = entity_registry.async_get_or_create("light", "hue", "1234") await hass.async_block_till_done() - assert len(registry.entities) == 1 + assert len(entity_registry.entities) == 1 assert entry is entry2 assert entry.entity_id == "light.hue_1234" assert len(update_events) == 1 @@ -56,20 +45,20 @@ async def test_get_or_create_returns_same_entry(hass, registry, update_events): assert update_events[0]["entity_id"] == entry.entity_id -def test_get_or_create_suggested_object_id(registry): +def test_get_or_create_suggested_object_id(entity_registry): """Test that suggested_object_id works.""" - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "1234", suggested_object_id="beer" ) assert entry.entity_id == "light.beer" -def test_get_or_create_updates_data(registry): +def test_get_or_create_updates_data(entity_registry): """Test that we update data in get_or_create.""" orig_config_entry = MockConfigEntry(domain="light") - orig_entry = registry.async_get_or_create( + orig_entry = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -113,7 +102,7 @@ def test_get_or_create_updates_data(registry): new_config_entry = MockConfigEntry(domain="light") - new_entry = registry.async_get_or_create( + new_entry = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -157,7 +146,7 @@ def test_get_or_create_updates_data(registry): unit_of_measurement="updated-unit_of_measurement", ) - new_entry = registry.async_get_or_create( + new_entry = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -202,12 +191,12 @@ def test_get_or_create_updates_data(registry): ) -def test_get_or_create_suggested_object_id_conflict_register(registry): +def test_get_or_create_suggested_object_id_conflict_register(entity_registry): """Test that we don't generate an entity id that is already registered.""" - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "1234", suggested_object_id="beer" ) - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "5678", suggested_object_id="beer" ) @@ -215,27 +204,27 @@ def test_get_or_create_suggested_object_id_conflict_register(registry): assert entry2.entity_id == "light.beer_2" -def test_get_or_create_suggested_object_id_conflict_existing(hass, registry): +def test_get_or_create_suggested_object_id_conflict_existing(hass, entity_registry): """Test that we don't generate an entity id that currently exists.""" hass.states.async_set("light.hue_1234", "on") - entry = registry.async_get_or_create("light", "hue", "1234") + entry = entity_registry.async_get_or_create("light", "hue", "1234") assert entry.entity_id == "light.hue_1234_2" -def test_create_triggers_save(hass, registry): +def test_create_triggers_save(entity_registry): """Test that registering entry triggers a save.""" - with patch.object(registry, "async_schedule_save") as mock_schedule_save: - registry.async_get_or_create("light", "hue", "1234") + with patch.object(entity_registry, "async_schedule_save") as mock_schedule_save: + entity_registry.async_get_or_create("light", "hue", "1234") assert len(mock_schedule_save.mock_calls) == 1 -async def test_loading_saving_data(hass, registry): +async def test_loading_saving_data(hass, entity_registry): """Test that we load/save data correctly.""" mock_config = MockConfigEntry(domain="light") - orig_entry1 = registry.async_get_or_create("light", "hue", "1234") - orig_entry2 = registry.async_get_or_create( + orig_entry1 = entity_registry.async_get_or_create("light", "hue", "1234") + orig_entry2 = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -253,7 +242,7 @@ async def test_loading_saving_data(hass, registry): translation_key="initial-translation_key", unit_of_measurement="initial-unit_of_measurement", ) - registry.async_update_entity( + entity_registry.async_update_entity( orig_entry2.entity_id, aliases={"initial_alias_1", "initial_alias_2"}, area_id="mock-area-id", @@ -261,22 +250,22 @@ async def test_loading_saving_data(hass, registry): name="User Name", icon="hass:user-icon", ) - registry.async_update_entity_options( + entity_registry.async_update_entity_options( orig_entry2.entity_id, "light", {"minimum_brightness": 20} ) - orig_entry2 = registry.async_get(orig_entry2.entity_id) + orig_entry2 = entity_registry.async_get(orig_entry2.entity_id) - assert len(registry.entities) == 2 + assert len(entity_registry.entities) == 2 # Now load written data in new registry registry2 = er.EntityRegistry(hass) - await flush_store(registry._store) + await flush_store(entity_registry._store) await registry2.async_load() # Ensure same order - assert list(registry.entities) == list(registry2.entities) - new_entry1 = registry.async_get_or_create("light", "hue", "1234") - new_entry2 = registry.async_get_or_create("light", "hue", "5678") + assert list(entity_registry.entities) == list(registry2.entities) + new_entry1 = entity_registry.async_get_or_create("light", "hue", "1234") + new_entry2 = entity_registry.async_get_or_create("light", "hue", "5678") assert orig_entry1 == new_entry1 assert orig_entry2 == new_entry2 @@ -301,24 +290,30 @@ async def test_loading_saving_data(hass, registry): assert new_entry2.unit_of_measurement == "initial-unit_of_measurement" -def test_generate_entity_considers_registered_entities(registry): +def test_generate_entity_considers_registered_entities(entity_registry): """Test that we don't create entity id that are already registered.""" - entry = registry.async_get_or_create("light", "hue", "1234") + entry = entity_registry.async_get_or_create("light", "hue", "1234") assert entry.entity_id == "light.hue_1234" - assert registry.async_generate_entity_id("light", "hue_1234") == "light.hue_1234_2" + assert ( + entity_registry.async_generate_entity_id("light", "hue_1234") + == "light.hue_1234_2" + ) -def test_generate_entity_considers_existing_entities(hass, registry): +def test_generate_entity_considers_existing_entities(hass, entity_registry): """Test that we don't create entity id that currently exists.""" hass.states.async_set("light.kitchen", "on") - assert registry.async_generate_entity_id("light", "kitchen") == "light.kitchen_2" + assert ( + entity_registry.async_generate_entity_id("light", "kitchen") + == "light.kitchen_2" + ) -def test_is_registered(registry): +def test_is_registered(entity_registry): """Test that is_registered works.""" - entry = registry.async_get_or_create("light", "hue", "1234") - assert registry.async_is_registered(entry.entity_id) - assert not registry.async_is_registered("light.non_existing") + entry = entity_registry.async_get_or_create("light", "hue", "1234") + assert entity_registry.async_is_registered(entry.entity_id) + assert not entity_registry.async_is_registered("light.non_existing") @pytest.mark.parametrize("load_registries", [False]) @@ -403,23 +398,25 @@ async def test_filter_on_load(hass, hass_storage): assert entry_system_category.entity_category is None -def test_async_get_entity_id(registry): +def test_async_get_entity_id(entity_registry): """Test that entity_id is returned.""" - entry = registry.async_get_or_create("light", "hue", "1234") + entry = entity_registry.async_get_or_create("light", "hue", "1234") assert entry.entity_id == "light.hue_1234" - assert registry.async_get_entity_id("light", "hue", "1234") == "light.hue_1234" - assert registry.async_get_entity_id("light", "hue", "123") is None + assert ( + entity_registry.async_get_entity_id("light", "hue", "1234") == "light.hue_1234" + ) + assert entity_registry.async_get_entity_id("light", "hue", "123") is None -async def test_updating_config_entry_id(hass, registry, update_events): +async def test_updating_config_entry_id(hass, entity_registry, update_events): """Test that we update config entry id in registry.""" mock_config_1 = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config_1 ) mock_config_2 = MockConfigEntry(domain="light", entry_id="mock-id-2") - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config_2 ) assert entry.entity_id == entry2.entity_id @@ -435,17 +432,17 @@ async def test_updating_config_entry_id(hass, registry, update_events): assert update_events[1]["changes"] == {"config_entry_id": "mock-id-1"} -async def test_removing_config_entry_id(hass, registry, update_events): +async def test_removing_config_entry_id(hass, entity_registry, update_events): """Test that we update config entry id in registry.""" mock_config = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config ) assert entry.config_entry_id == "mock-id-1" - registry.async_clear_config_entry("mock-id-1") + entity_registry.async_clear_config_entry("mock-id-1") - assert not registry.entities + assert not entity_registry.entities await hass.async_block_till_done() @@ -456,14 +453,16 @@ async def test_removing_config_entry_id(hass, registry, update_events): assert update_events[1]["entity_id"] == entry.entity_id -async def test_removing_area_id(registry): +async def test_removing_area_id(entity_registry): """Make sure we can clear area id.""" - entry = registry.async_get_or_create("light", "hue", "5678") + entry = entity_registry.async_get_or_create("light", "hue", "5678") - entry_w_area = registry.async_update_entity(entry.entity_id, area_id="12345A") + entry_w_area = entity_registry.async_update_entity( + entry.entity_id, area_id="12345A" + ) - registry.async_clear_area_id("12345A") - entry_wo_area = registry.async_get(entry.entity_id) + entity_registry.async_clear_area_id("12345A") + entry_wo_area = entity_registry.async_get(entry.entity_id) assert not entry_wo_area.area_id assert entry_w_area != entry_wo_area @@ -568,69 +567,81 @@ async def test_migration_1_7(hass, hass_storage): assert entry.original_device_class == "class_by_integration" -async def test_update_entity_unique_id(registry): +async def test_update_entity_unique_id(entity_registry): """Test entity's unique_id is updated.""" mock_config = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config ) - assert registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + assert ( + entity_registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + ) new_unique_id = "1234" - with patch.object(registry, "async_schedule_save") as mock_schedule_save: - updated_entry = registry.async_update_entity( + with patch.object(entity_registry, "async_schedule_save") as mock_schedule_save: + updated_entry = entity_registry.async_update_entity( entry.entity_id, new_unique_id=new_unique_id ) assert updated_entry != entry assert updated_entry.unique_id == new_unique_id assert mock_schedule_save.call_count == 1 - assert registry.async_get_entity_id("light", "hue", "5678") is None - assert registry.async_get_entity_id("light", "hue", "1234") == entry.entity_id + assert entity_registry.async_get_entity_id("light", "hue", "5678") is None + assert ( + entity_registry.async_get_entity_id("light", "hue", "1234") == entry.entity_id + ) -async def test_update_entity_unique_id_conflict(registry): +async def test_update_entity_unique_id_conflict(entity_registry): """Test migration raises when unique_id already in use.""" mock_config = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config ) - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "1234", config_entry=mock_config ) with patch.object( - registry, "async_schedule_save" + entity_registry, "async_schedule_save" ) as mock_schedule_save, pytest.raises(ValueError): - registry.async_update_entity(entry.entity_id, new_unique_id=entry2.unique_id) + entity_registry.async_update_entity( + entry.entity_id, new_unique_id=entry2.unique_id + ) assert mock_schedule_save.call_count == 0 - assert registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id - assert registry.async_get_entity_id("light", "hue", "1234") == entry2.entity_id + assert ( + entity_registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + ) + assert ( + entity_registry.async_get_entity_id("light", "hue", "1234") == entry2.entity_id + ) -async def test_update_entity_entity_id(registry): +async def test_update_entity_entity_id(entity_registry): """Test entity's entity_id is updated.""" - entry = registry.async_get_or_create("light", "hue", "5678") - assert registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + entry = entity_registry.async_get_or_create("light", "hue", "5678") + assert ( + entity_registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + ) new_entity_id = "light.blah" assert new_entity_id != entry.entity_id - with patch.object(registry, "async_schedule_save") as mock_schedule_save: - updated_entry = registry.async_update_entity( + with patch.object(entity_registry, "async_schedule_save") as mock_schedule_save: + updated_entry = entity_registry.async_update_entity( entry.entity_id, new_entity_id=new_entity_id ) assert updated_entry != entry assert updated_entry.entity_id == new_entity_id assert mock_schedule_save.call_count == 1 - assert registry.async_get(entry.entity_id) is None - assert registry.async_get(new_entity_id) is not None + assert entity_registry.async_get(entry.entity_id) is None + assert entity_registry.async_get(new_entity_id) is not None -async def test_update_entity_entity_id_entity_id(hass: HomeAssistant, registry): +async def test_update_entity_entity_id_entity_id(hass: HomeAssistant, entity_registry): """Test update raises when entity_id already in use.""" - entry = registry.async_get_or_create("light", "hue", "5678") - entry2 = registry.async_get_or_create("light", "hue", "1234") + entry = entity_registry.async_get_or_create("light", "hue", "5678") + entry2 = entity_registry.async_get_or_create("light", "hue", "1234") state_entity_id = "light.blah" hass.states.async_set(state_entity_id, "on") assert entry.entity_id != state_entity_id @@ -638,30 +649,40 @@ async def test_update_entity_entity_id_entity_id(hass: HomeAssistant, registry): # Try updating to a registered entity_id with patch.object( - registry, "async_schedule_save" + entity_registry, "async_schedule_save" ) as mock_schedule_save, pytest.raises(ValueError): - registry.async_update_entity(entry.entity_id, new_entity_id=entry2.entity_id) + entity_registry.async_update_entity( + entry.entity_id, new_entity_id=entry2.entity_id + ) assert mock_schedule_save.call_count == 0 - assert registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id - assert registry.async_get(entry.entity_id) is entry - assert registry.async_get_entity_id("light", "hue", "1234") == entry2.entity_id - assert registry.async_get(entry2.entity_id) is entry2 + assert ( + entity_registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + ) + assert entity_registry.async_get(entry.entity_id) is entry + assert ( + entity_registry.async_get_entity_id("light", "hue", "1234") == entry2.entity_id + ) + assert entity_registry.async_get(entry2.entity_id) is entry2 # Try updating to an entity_id which is in the state machine with patch.object( - registry, "async_schedule_save" + entity_registry, "async_schedule_save" ) as mock_schedule_save, pytest.raises(ValueError): - registry.async_update_entity(entry.entity_id, new_entity_id=state_entity_id) + entity_registry.async_update_entity( + entry.entity_id, new_entity_id=state_entity_id + ) assert mock_schedule_save.call_count == 0 - assert registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id - assert registry.async_get(entry.entity_id) is entry - assert registry.async_get(state_entity_id) is None + assert ( + entity_registry.async_get_entity_id("light", "hue", "5678") == entry.entity_id + ) + assert entity_registry.async_get(entry.entity_id) is entry + assert entity_registry.async_get(state_entity_id) is None -async def test_update_entity(registry): +async def test_update_entity(entity_registry): """Test updating entity.""" mock_config = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config ) @@ -672,73 +693,73 @@ async def test_update_entity(registry): ("name", "new name"), ): changes = {attr_name: new_value} - updated_entry = registry.async_update_entity(entry.entity_id, **changes) + updated_entry = entity_registry.async_update_entity(entry.entity_id, **changes) assert updated_entry != entry assert getattr(updated_entry, attr_name) == new_value assert getattr(updated_entry, attr_name) != getattr(entry, attr_name) assert ( - registry.async_get_entity_id("light", "hue", "5678") + entity_registry.async_get_entity_id("light", "hue", "5678") == updated_entry.entity_id ) entry = updated_entry -async def test_update_entity_options(registry): +async def test_update_entity_options(entity_registry): """Test updating entity.""" mock_config = MockConfigEntry(domain="light", entry_id="mock-id-1") - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=mock_config ) - registry.async_update_entity_options( + entity_registry.async_update_entity_options( entry.entity_id, "light", {"minimum_brightness": 20} ) - new_entry_1 = registry.async_get(entry.entity_id) + new_entry_1 = entity_registry.async_get(entry.entity_id) assert entry.options == {} assert new_entry_1.options == {"light": {"minimum_brightness": 20}} - registry.async_update_entity_options( + entity_registry.async_update_entity_options( entry.entity_id, "light", {"minimum_brightness": 30} ) - new_entry_2 = registry.async_get(entry.entity_id) + new_entry_2 = entity_registry.async_get(entry.entity_id) assert entry.options == {} assert new_entry_1.options == {"light": {"minimum_brightness": 20}} assert new_entry_2.options == {"light": {"minimum_brightness": 30}} -async def test_disabled_by(registry): +async def test_disabled_by(entity_registry): """Test that we can disable an entry when we create it.""" - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", disabled_by=er.RegistryEntryDisabler.HASS ) assert entry.disabled_by is er.RegistryEntryDisabler.HASS - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", disabled_by=er.RegistryEntryDisabler.INTEGRATION ) assert entry.disabled_by is er.RegistryEntryDisabler.HASS - entry2 = registry.async_get_or_create("light", "hue", "1234") + entry2 = entity_registry.async_get_or_create("light", "hue", "1234") assert entry2.disabled_by is None -async def test_disabled_by_config_entry_pref(registry): +async def test_disabled_by_config_entry_pref(entity_registry): """Test config entry preference setting disabled_by.""" mock_config = MockConfigEntry( domain="light", entry_id="mock-id-1", pref_disable_new_entities=True, ) - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "AAAA", config_entry=mock_config ) assert entry.disabled_by is er.RegistryEntryDisabler.INTEGRATION - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "BBBB", @@ -893,9 +914,8 @@ async def test_async_get_device_class_lookup(hass: HomeAssistant) -> None: } -async def test_remove_device_removes_entities(hass, registry): +async def test_remove_device_removes_entities(hass, entity_registry, device_registry): """Test that we remove entities tied to a device.""" - device_registry = mock_device_registry(hass) config_entry = MockConfigEntry(domain="light") device_entry = device_registry.async_get_or_create( @@ -903,7 +923,7 @@ async def test_remove_device_removes_entities(hass, registry): connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -911,17 +931,18 @@ async def test_remove_device_removes_entities(hass, registry): device_id=device_entry.id, ) - assert registry.async_is_registered(entry.entity_id) + assert entity_registry.async_is_registered(entry.entity_id) device_registry.async_remove_device(device_entry.id) await hass.async_block_till_done() - assert not registry.async_is_registered(entry.entity_id) + assert not entity_registry.async_is_registered(entry.entity_id) -async def test_remove_config_entry_from_device_removes_entities(hass, registry): +async def test_remove_config_entry_from_device_removes_entities( + hass, device_registry, entity_registry +): """Test that we remove entities tied to a device when config entry is removed.""" - device_registry = mock_device_registry(hass) config_entry_1 = MockConfigEntry(domain="hue") config_entry_2 = MockConfigEntry(domain="device_tracker") @@ -940,7 +961,7 @@ async def test_remove_config_entry_from_device_removes_entities(hass, registry): } # Create one entity for each config entry - entry_1 = registry.async_get_or_create( + entry_1 = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -948,7 +969,7 @@ async def test_remove_config_entry_from_device_removes_entities(hass, registry): device_id=device_entry.id, ) - entry_2 = registry.async_get_or_create( + entry_2 = entity_registry.async_get_or_create( "sensor", "device_tracker", "6789", @@ -956,8 +977,8 @@ async def test_remove_config_entry_from_device_removes_entities(hass, registry): device_id=device_entry.id, ) - assert registry.async_is_registered(entry_1.entity_id) - assert registry.async_is_registered(entry_2.entity_id) + assert entity_registry.async_is_registered(entry_1.entity_id) + assert entity_registry.async_is_registered(entry_2.entity_id) # Remove the first config entry from the device, the entity associated with it # should be removed @@ -967,8 +988,8 @@ async def test_remove_config_entry_from_device_removes_entities(hass, registry): await hass.async_block_till_done() assert device_registry.async_get(device_entry.id) - assert not registry.async_is_registered(entry_1.entity_id) - assert registry.async_is_registered(entry_2.entity_id) + assert not entity_registry.async_is_registered(entry_1.entity_id) + assert entity_registry.async_is_registered(entry_2.entity_id) # Remove the second config entry from the device, the entity associated with it # (and the device itself) should be removed @@ -978,13 +999,14 @@ async def test_remove_config_entry_from_device_removes_entities(hass, registry): await hass.async_block_till_done() assert not device_registry.async_get(device_entry.id) - assert not registry.async_is_registered(entry_1.entity_id) - assert not registry.async_is_registered(entry_2.entity_id) + assert not entity_registry.async_is_registered(entry_1.entity_id) + assert not entity_registry.async_is_registered(entry_2.entity_id) -async def test_remove_config_entry_from_device_removes_entities_2(hass, registry): +async def test_remove_config_entry_from_device_removes_entities_2( + hass, device_registry, entity_registry +): """Test that we don't remove entities with no config entry when device is modified.""" - device_registry = mock_device_registry(hass) config_entry_1 = MockConfigEntry(domain="hue") config_entry_2 = MockConfigEntry(domain="device_tracker") @@ -1003,14 +1025,14 @@ async def test_remove_config_entry_from_device_removes_entities_2(hass, registry } # Create one entity for each config entry - entry_1 = registry.async_get_or_create( + entry_1 = entity_registry.async_get_or_create( "light", "hue", "5678", device_id=device_entry.id, ) - assert registry.async_is_registered(entry_1.entity_id) + assert entity_registry.async_is_registered(entry_1.entity_id) # Remove the first config entry from the device device_registry.async_update_device( @@ -1019,12 +1041,11 @@ async def test_remove_config_entry_from_device_removes_entities_2(hass, registry await hass.async_block_till_done() assert device_registry.async_get(device_entry.id) - assert registry.async_is_registered(entry_1.entity_id) + assert entity_registry.async_is_registered(entry_1.entity_id) -async def test_update_device_race(hass, registry): +async def test_update_device_race(hass, device_registry, entity_registry): """Test race when a device is created, updated and removed.""" - device_registry = mock_device_registry(hass) config_entry = MockConfigEntry(domain="light") # Create device @@ -1039,7 +1060,7 @@ async def test_update_device_race(hass, registry): connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) # Add entity to the device - entry = registry.async_get_or_create( + entry = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -1047,17 +1068,16 @@ async def test_update_device_race(hass, registry): device_id=device_entry.id, ) - assert registry.async_is_registered(entry.entity_id) + assert entity_registry.async_is_registered(entry.entity_id) device_registry.async_remove_device(device_entry.id) await hass.async_block_till_done() - assert not registry.async_is_registered(entry.entity_id) + assert not entity_registry.async_is_registered(entry.entity_id) -async def test_disable_device_disables_entities(hass, registry): +async def test_disable_device_disables_entities(hass, device_registry, entity_registry): """Test that we disable entities tied to a device.""" - device_registry = mock_device_registry(hass) config_entry = MockConfigEntry(domain="light") config_entry.add_to_hass(hass) @@ -1066,14 +1086,14 @@ async def test_disable_device_disables_entities(hass, registry): connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry1 = registry.async_get_or_create( + entry1 = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=config_entry, device_id=device_entry.id, ) - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "ABCD", @@ -1081,7 +1101,7 @@ async def test_disable_device_disables_entities(hass, registry): device_id=device_entry.id, disabled_by=er.RegistryEntryDisabler.USER, ) - entry3 = registry.async_get_or_create( + entry3 = entity_registry.async_get_or_create( "light", "hue", "EFGH", @@ -1099,32 +1119,33 @@ async def test_disable_device_disables_entities(hass, registry): ) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.entity_id) + entry1 = entity_registry.async_get(entry1.entity_id) assert entry1.disabled assert entry1.disabled_by is er.RegistryEntryDisabler.DEVICE - entry2 = registry.async_get(entry2.entity_id) + entry2 = entity_registry.async_get(entry2.entity_id) assert entry2.disabled assert entry2.disabled_by is er.RegistryEntryDisabler.USER - entry3 = registry.async_get(entry3.entity_id) + entry3 = entity_registry.async_get(entry3.entity_id) assert entry3.disabled assert entry3.disabled_by is er.RegistryEntryDisabler.CONFIG_ENTRY device_registry.async_update_device(device_entry.id, disabled_by=None) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.entity_id) + entry1 = entity_registry.async_get(entry1.entity_id) assert not entry1.disabled - entry2 = registry.async_get(entry2.entity_id) + entry2 = entity_registry.async_get(entry2.entity_id) assert entry2.disabled assert entry2.disabled_by is er.RegistryEntryDisabler.USER - entry3 = registry.async_get(entry3.entity_id) + entry3 = entity_registry.async_get(entry3.entity_id) assert entry3.disabled assert entry3.disabled_by is er.RegistryEntryDisabler.CONFIG_ENTRY -async def test_disable_config_entry_disables_entities(hass, registry): +async def test_disable_config_entry_disables_entities( + hass, device_registry, entity_registry +): """Test that we disable entities tied to a config entry.""" - device_registry = mock_device_registry(hass) config_entry = MockConfigEntry(domain="light") config_entry.add_to_hass(hass) @@ -1133,14 +1154,14 @@ async def test_disable_config_entry_disables_entities(hass, registry): connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry1 = registry.async_get_or_create( + entry1 = entity_registry.async_get_or_create( "light", "hue", "5678", config_entry=config_entry, device_id=device_entry.id, ) - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "ABCD", @@ -1148,7 +1169,7 @@ async def test_disable_config_entry_disables_entities(hass, registry): device_id=device_entry.id, disabled_by=er.RegistryEntryDisabler.USER, ) - entry3 = registry.async_get_or_create( + entry3 = entity_registry.async_get_or_create( "light", "hue", "EFGH", @@ -1166,32 +1187,33 @@ async def test_disable_config_entry_disables_entities(hass, registry): ) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.entity_id) + entry1 = entity_registry.async_get(entry1.entity_id) assert entry1.disabled assert entry1.disabled_by is er.RegistryEntryDisabler.CONFIG_ENTRY - entry2 = registry.async_get(entry2.entity_id) + entry2 = entity_registry.async_get(entry2.entity_id) assert entry2.disabled assert entry2.disabled_by is er.RegistryEntryDisabler.USER - entry3 = registry.async_get(entry3.entity_id) + entry3 = entity_registry.async_get(entry3.entity_id) assert entry3.disabled assert entry3.disabled_by is er.RegistryEntryDisabler.DEVICE await hass.config_entries.async_set_disabled_by(config_entry.entry_id, None) await hass.async_block_till_done() - entry1 = registry.async_get(entry1.entity_id) + entry1 = entity_registry.async_get(entry1.entity_id) assert not entry1.disabled - entry2 = registry.async_get(entry2.entity_id) + entry2 = entity_registry.async_get(entry2.entity_id) assert entry2.disabled assert entry2.disabled_by is er.RegistryEntryDisabler.USER # The device was re-enabled, so entity disabled by the device will be re-enabled too - entry3 = registry.async_get(entry3.entity_id) + entry3 = entity_registry.async_get(entry3.entity_id) assert not entry3.disabled_by -async def test_disabled_entities_excluded_from_entity_list(hass, registry): +async def test_disabled_entities_excluded_from_entity_list( + hass, device_registry, entity_registry +): """Test that disabled entities are excluded from async_entries_for_device.""" - device_registry = mock_device_registry(hass) config_entry = MockConfigEntry(domain="light") device_entry = device_registry.async_get_or_create( @@ -1199,7 +1221,7 @@ async def test_disabled_entities_excluded_from_entity_list(hass, registry): connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entry1 = registry.async_get_or_create( + entry1 = entity_registry.async_get_or_create( "light", "hue", "5678", @@ -1207,7 +1229,7 @@ async def test_disabled_entities_excluded_from_entity_list(hass, registry): device_id=device_entry.id, ) - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "ABCD", @@ -1216,16 +1238,16 @@ async def test_disabled_entities_excluded_from_entity_list(hass, registry): disabled_by=er.RegistryEntryDisabler.USER, ) - entries = er.async_entries_for_device(registry, device_entry.id) + entries = er.async_entries_for_device(entity_registry, device_entry.id) assert entries == [entry1] entries = er.async_entries_for_device( - registry, device_entry.id, include_disabled_entities=True + entity_registry, device_entry.id, include_disabled_entities=True ) assert entries == [entry1, entry2] -async def test_entity_max_length_exceeded(hass, registry): +async def test_entity_max_length_exceeded(entity_registry): """Test that an exception is raised when the max character length is exceeded.""" long_domain_name = ( @@ -1236,7 +1258,7 @@ async def test_entity_max_length_exceeded(hass, registry): ) with pytest.raises(MaxLengthExceeded) as exc_info: - registry.async_generate_entity_id(long_domain_name, "sensor") + entity_registry.async_generate_entity_id(long_domain_name, "sensor") assert exc_info.value.property_name == "domain" assert exc_info.value.max_length == 64 @@ -1251,43 +1273,55 @@ async def test_entity_max_length_exceeded(hass, registry): ) known = [] - new_id = registry.async_generate_entity_id("sensor", long_entity_id_name, known) + new_id = entity_registry.async_generate_entity_id( + "sensor", long_entity_id_name, known + ) assert new_id == "sensor." + long_entity_id_name[: 255 - 7] known.append(new_id) - new_id = registry.async_generate_entity_id("sensor", long_entity_id_name, known) + new_id = entity_registry.async_generate_entity_id( + "sensor", long_entity_id_name, known + ) assert new_id == "sensor." + long_entity_id_name[: 255 - 7 - 2] + "_2" known.append(new_id) - new_id = registry.async_generate_entity_id("sensor", long_entity_id_name, known) + new_id = entity_registry.async_generate_entity_id( + "sensor", long_entity_id_name, known + ) assert new_id == "sensor." + long_entity_id_name[: 255 - 7 - 2] + "_3" -async def test_resolve_entity_ids(hass, registry): +async def test_resolve_entity_ids(entity_registry): """Test resolving entity IDs.""" - entry1 = registry.async_get_or_create( + entry1 = entity_registry.async_get_or_create( "light", "hue", "1234", suggested_object_id="beer" ) assert entry1.entity_id == "light.beer" - entry2 = registry.async_get_or_create( + entry2 = entity_registry.async_get_or_create( "light", "hue", "2345", suggested_object_id="milk" ) assert entry2.entity_id == "light.milk" expected = ["light.beer", "light.milk"] - assert er.async_validate_entity_ids(registry, [entry1.id, entry2.id]) == expected + assert ( + er.async_validate_entity_ids(entity_registry, [entry1.id, entry2.id]) + == expected + ) expected = ["light.beer", "light.milk"] - assert er.async_validate_entity_ids(registry, ["light.beer", entry2.id]) == expected + assert ( + er.async_validate_entity_ids(entity_registry, ["light.beer", entry2.id]) + == expected + ) with pytest.raises(vol.Invalid): - er.async_validate_entity_ids(registry, ["light.beer", "bad_uuid"]) + er.async_validate_entity_ids(entity_registry, ["light.beer", "bad_uuid"]) expected = ["light.unknown"] - assert er.async_validate_entity_ids(registry, ["light.unknown"]) == expected + assert er.async_validate_entity_ids(entity_registry, ["light.unknown"]) == expected with pytest.raises(vol.Invalid): - er.async_validate_entity_ids(registry, ["unknown_uuid"]) + er.async_validate_entity_ids(entity_registry, ["unknown_uuid"]) def test_entity_registry_items() -> None: @@ -1364,12 +1398,12 @@ async def test_hidden_by_str_not_allowed(hass: HomeAssistant) -> None: reg.async_update_entity(entity_id, hidden_by=er.RegistryEntryHider.USER.value) -def test_migrate_entity_to_new_platform(hass, registry): +def test_migrate_entity_to_new_platform(hass, entity_registry): """Test migrate_entity_to_new_platform.""" orig_config_entry = MockConfigEntry(domain="light") orig_unique_id = "5678" - orig_entry = registry.async_get_or_create( + orig_entry = entity_registry.async_get_or_create( "light", "hue", orig_unique_id, @@ -1381,8 +1415,8 @@ def test_migrate_entity_to_new_platform(hass, registry): original_icon="initial-original_icon", original_name="initial-original_name", ) - assert registry.async_get("light.light") is orig_entry - registry.async_update_entity( + assert entity_registry.async_get("light.light") is orig_entry + entity_registry.async_update_entity( "light.light", name="new_name", icon="new_icon", @@ -1391,16 +1425,16 @@ def test_migrate_entity_to_new_platform(hass, registry): new_config_entry = MockConfigEntry(domain="light") new_unique_id = "1234" - assert registry.async_update_entity_platform( + assert entity_registry.async_update_entity_platform( "light.light", "hue2", new_unique_id=new_unique_id, new_config_entry_id=new_config_entry.entry_id, ) - assert not registry.async_get_entity_id("light", "hue", orig_unique_id) + assert not entity_registry.async_get_entity_id("light", "hue", orig_unique_id) - assert (new_entry := registry.async_get("light.light")) is not orig_entry + assert (new_entry := entity_registry.async_get("light.light")) is not orig_entry assert new_entry.config_entry_id == new_config_entry.entry_id assert new_entry.unique_id == new_unique_id @@ -1410,7 +1444,7 @@ def test_migrate_entity_to_new_platform(hass, registry): # Test nonexisting entity with pytest.raises(KeyError): - registry.async_update_entity_platform( + entity_registry.async_update_entity_platform( "light.not_a_real_light", "hue2", new_unique_id=new_unique_id, @@ -1419,7 +1453,7 @@ def test_migrate_entity_to_new_platform(hass, registry): # Test migrate entity without new config entry ID with pytest.raises(ValueError): - registry.async_update_entity_platform( + entity_registry.async_update_entity_platform( "light.light", "hue3", ) @@ -1427,7 +1461,7 @@ def test_migrate_entity_to_new_platform(hass, registry): # Test entity with a state hass.states.async_set("light.light", "on") with pytest.raises(ValueError): - registry.async_update_entity_platform( + entity_registry.async_update_entity_platform( "light.light", "hue2", new_unique_id=new_unique_id, diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py index 15c705b4cd8..bdff145789e 100644 --- a/tests/helpers/test_template.py +++ b/tests/helpers/test_template.py @@ -28,7 +28,13 @@ from homeassistant.const import ( ) from homeassistant.core import HomeAssistant from homeassistant.exceptions import TemplateError -from homeassistant.helpers import device_registry as dr, entity, template +from homeassistant.helpers import ( + area_registry as ar, + device_registry as dr, + entity, + entity_registry as er, + template, +) from homeassistant.helpers.entity_platform import EntityPlatform from homeassistant.helpers.json import json_dumps from homeassistant.helpers.typing import TemplateVarsType @@ -36,12 +42,7 @@ from homeassistant.setup import async_setup_component import homeassistant.util.dt as dt_util from homeassistant.util.unit_system import UnitSystem -from tests.common import ( - MockConfigEntry, - mock_area_registry, - mock_device_registry, - mock_registry, -) +from tests.common import MockConfigEntry def _set_up_units(hass: HomeAssistant) -> None: @@ -2509,11 +2510,13 @@ async def test_expand(hass: HomeAssistant) -> None: ) -async def test_device_entities(hass: HomeAssistant) -> None: +async def test_device_entities( + hass: HomeAssistant, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test device_entities function.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - entity_registry = mock_registry(hass) # Test non existing device ids info = render_to_info(hass, "{{ device_entities('abc123') }}") @@ -2591,10 +2594,10 @@ async def test_device_entities(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_integration_entities(hass: HomeAssistant) -> None: +async def test_integration_entities( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test integration_entities function.""" - entity_registry = mock_registry(hass) - # test entities for given config entry title config_entry = MockConfigEntry(domain="mock", title="Mock bridge 2") config_entry.add_to_hass(hass) @@ -2629,11 +2632,12 @@ async def test_integration_entities(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_config_entry_id(hass: HomeAssistant) -> None: +async def test_config_entry_id( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test config_entry_id function.""" config_entry = MockConfigEntry(domain="light", title="Some integration") config_entry.add_to_hass(hass) - entity_registry = mock_registry(hass) entity_entry = entity_registry.async_get_or_create( "sensor", "test", "test", suggested_object_id="test", config_entry=config_entry ) @@ -2655,11 +2659,13 @@ async def test_config_entry_id(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_device_id(hass: HomeAssistant) -> None: +async def test_device_id( + hass: HomeAssistant, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test device_id function.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - entity_registry = mock_registry(hass) device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, @@ -2698,11 +2704,13 @@ async def test_device_id(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_device_attr(hass: HomeAssistant) -> None: +async def test_device_attr( + hass: HomeAssistant, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test device_attr and is_device_attr functions.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - entity_registry = mock_registry(hass) # Test non existing device ids (device_attr) info = render_to_info(hass, "{{ device_attr('abc123', 'id') }}") @@ -2821,12 +2829,14 @@ async def test_device_attr(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_area_id(hass: HomeAssistant) -> None: +async def test_area_id( + hass: HomeAssistant, + area_registry: ar.AreaRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test area_id function.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - entity_registry = mock_registry(hass) - area_registry = mock_area_registry(hass) # Test non existing entity id info = render_to_info(hass, "{{ area_id('sensor.fake') }}") @@ -2925,12 +2935,14 @@ async def test_area_id(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_area_name(hass: HomeAssistant) -> None: +async def test_area_name( + hass: HomeAssistant, + area_registry: ar.AreaRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test area_name function.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - entity_registry = mock_registry(hass) - area_registry = mock_area_registry(hass) # Test non existing entity id info = render_to_info(hass, "{{ area_name('sensor.fake') }}") @@ -3004,12 +3016,14 @@ async def test_area_name(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_area_entities(hass: HomeAssistant) -> None: +async def test_area_entities( + hass: HomeAssistant, + area_registry: ar.AreaRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, +) -> None: """Test area_entities function.""" config_entry = MockConfigEntry(domain="light") - entity_registry = mock_registry(hass) - device_registry = mock_device_registry(hass) - area_registry = mock_area_registry(hass) # Test non existing device id info = render_to_info(hass, "{{ area_entities('deadbeef') }}") @@ -3057,11 +3071,13 @@ async def test_area_entities(hass: HomeAssistant) -> None: assert info.rate_limit is None -async def test_area_devices(hass: HomeAssistant) -> None: +async def test_area_devices( + hass: HomeAssistant, + area_registry: ar.AreaRegistry, + device_registry: dr.DeviceRegistry, +) -> None: """Test area_devices function.""" config_entry = MockConfigEntry(domain="light") - device_registry = mock_device_registry(hass) - area_registry = mock_area_registry(hass) # Test non existing device id info = render_to_info(hass, "{{ area_devices('deadbeef') }}") diff --git a/tests/test_config_entries.py b/tests/test_config_entries.py index 1619a19d079..be9c47c8b29 100644 --- a/tests/test_config_entries.py +++ b/tests/test_config_entries.py @@ -38,7 +38,6 @@ from .common import ( mock_coro, mock_entity_platform, mock_integration, - mock_registry, ) @@ -1443,15 +1442,14 @@ async def test_support_entry_unload(hass: HomeAssistant) -> None: async def test_reload_entry_entity_registry_ignores_no_entry( - hass: HomeAssistant, + hass: HomeAssistant, entity_registry: er.EntityRegistry ) -> None: """Test reloading entry in entity registry skips if no config entry linked.""" handler = config_entries.EntityRegistryDisabledHandler(hass) - registry = mock_registry(hass) # Test we ignore entities without config entry - entry = registry.async_get_or_create("light", "hue", "123") - registry.async_update_entity( + entry = entity_registry.async_get_or_create("light", "hue", "123") + entity_registry.async_update_entity( entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER ) await hass.async_block_till_done() @@ -1459,11 +1457,12 @@ async def test_reload_entry_entity_registry_ignores_no_entry( assert handler._remove_call_later is None -async def test_reload_entry_entity_registry_works(hass: HomeAssistant) -> None: +async def test_reload_entry_entity_registry_works( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test we schedule an entry to be reloaded if disabled_by is updated.""" handler = config_entries.EntityRegistryDisabledHandler(hass) handler.async_setup() - registry = mock_registry(hass) config_entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED @@ -1483,16 +1482,16 @@ async def test_reload_entry_entity_registry_works(hass: HomeAssistant) -> None: mock_entity_platform(hass, "config_flow.comp", None) # Only changing disabled_by should update trigger - entity_entry = registry.async_get_or_create( + entity_entry = entity_registry.async_get_or_create( "light", "hue", "123", config_entry=config_entry ) - registry.async_update_entity(entity_entry.entity_id, name="yo") + entity_registry.async_update_entity(entity_entry.entity_id, name="yo") await hass.async_block_till_done() assert not handler.changed assert handler._remove_call_later is None # Disable entity, we should not do anything, only act when enabled. - registry.async_update_entity( + entity_registry.async_update_entity( entity_entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER ) await hass.async_block_till_done() @@ -1500,7 +1499,7 @@ async def test_reload_entry_entity_registry_works(hass: HomeAssistant) -> None: assert handler._remove_call_later is None # Enable entity, check we are reloading config entry. - registry.async_update_entity(entity_entry.entity_id, disabled_by=None) + entity_registry.async_update_entity(entity_entry.entity_id, disabled_by=None) await hass.async_block_till_done() assert handler.changed == {config_entry.entry_id} assert handler._remove_call_later is not None