Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
core/tests/components/zwave_js/test_migrate.py

811 lines
30 KiB
Python
Raw Blame History

"""Test the Z-Wave JS migration module."""
import copy
from unittest.mock import patch
import pytest
from zwave_js_server.model.node import Node
from homeassistant.components.zwave_js.api import ENTRY_ID, ID, TYPE
from homeassistant.components.zwave_js.const import DOMAIN
from homeassistant.components.zwave_js.helpers import get_device_id
from homeassistant.helpers import device_registry as dr, entity_registry as er
from .common import AIR_TEMPERATURE_SENSOR, NOTIFICATION_MOTION_BINARY_SENSOR
from tests.common import MockConfigEntry, mock_device_registry, mock_registry
# Switch device
ZWAVE_SWITCH_DEVICE_ID = "zwave_switch_device_id"
ZWAVE_SWITCH_DEVICE_NAME = "Z-Wave Switch Device"
ZWAVE_SWITCH_DEVICE_AREA = "Z-Wave Switch Area"
ZWAVE_SWITCH_ENTITY = "switch.zwave_switch_node"
ZWAVE_SWITCH_UNIQUE_ID = "102-6789"
ZWAVE_SWITCH_NAME = "Z-Wave Switch"
ZWAVE_SWITCH_ICON = "mdi:zwave-test-switch"
ZWAVE_POWER_ENTITY = "sensor.zwave_power"
ZWAVE_POWER_UNIQUE_ID = "102-5678"
ZWAVE_POWER_NAME = "Z-Wave Power"
ZWAVE_POWER_ICON = "mdi:zwave-test-power"
# Multisensor device
ZWAVE_MULTISENSOR_DEVICE_ID = "zwave_multisensor_device_id"
ZWAVE_MULTISENSOR_DEVICE_NAME = "Z-Wave Multisensor Device"
ZWAVE_MULTISENSOR_DEVICE_AREA = "Z-Wave Multisensor Area"
ZWAVE_SOURCE_NODE_ENTITY = "sensor.zwave_source_node"
ZWAVE_SOURCE_NODE_UNIQUE_ID = "52-4321"
ZWAVE_BATTERY_ENTITY = "sensor.zwave_battery_level"
ZWAVE_BATTERY_UNIQUE_ID = "52-1234"
ZWAVE_BATTERY_NAME = "Z-Wave Battery Level"
ZWAVE_BATTERY_ICON = "mdi:zwave-test-battery"
ZWAVE_TAMPERING_ENTITY = "sensor.zwave_tampering"
ZWAVE_TAMPERING_UNIQUE_ID = "52-3456"
ZWAVE_TAMPERING_NAME = "Z-Wave Tampering"
ZWAVE_TAMPERING_ICON = "mdi:zwave-test-tampering"
@pytest.fixture(name="zwave_migration_data")
def zwave_migration_data_fixture(hass):
"""Return mock zwave migration data."""
zwave_switch_device = dr.DeviceEntry(
id=ZWAVE_SWITCH_DEVICE_ID,
name_by_user=ZWAVE_SWITCH_DEVICE_NAME,
area_id=ZWAVE_SWITCH_DEVICE_AREA,
)
zwave_switch_entry = er.RegistryEntry(
entity_id=ZWAVE_SWITCH_ENTITY,
unique_id=ZWAVE_SWITCH_UNIQUE_ID,
platform="zwave",
name=ZWAVE_SWITCH_NAME,
icon=ZWAVE_SWITCH_ICON,
)
zwave_multisensor_device = dr.DeviceEntry(
id=ZWAVE_MULTISENSOR_DEVICE_ID,
name_by_user=ZWAVE_MULTISENSOR_DEVICE_NAME,
area_id=ZWAVE_MULTISENSOR_DEVICE_AREA,
)
zwave_source_node_entry = er.RegistryEntry(
entity_id=ZWAVE_SOURCE_NODE_ENTITY,
unique_id=ZWAVE_SOURCE_NODE_UNIQUE_ID,
platform="zwave",
name="Z-Wave Source Node",
)
zwave_battery_entry = er.RegistryEntry(
entity_id=ZWAVE_BATTERY_ENTITY,
unique_id=ZWAVE_BATTERY_UNIQUE_ID,
platform="zwave",
name=ZWAVE_BATTERY_NAME,
icon=ZWAVE_BATTERY_ICON,
unit_of_measurement="%",
)
zwave_power_entry = er.RegistryEntry(
entity_id=ZWAVE_POWER_ENTITY,
unique_id=ZWAVE_POWER_UNIQUE_ID,
platform="zwave",
name=ZWAVE_POWER_NAME,
icon=ZWAVE_POWER_ICON,
unit_of_measurement="W",
)
zwave_tampering_entry = er.RegistryEntry(
entity_id=ZWAVE_TAMPERING_ENTITY,
unique_id=ZWAVE_TAMPERING_UNIQUE_ID,
platform="zwave",
name=ZWAVE_TAMPERING_NAME,
icon=ZWAVE_TAMPERING_ICON,
unit_of_measurement="", # Test empty string unit normalization.
)
zwave_migration_data = {
ZWAVE_SWITCH_ENTITY: {
"node_id": 102,
"node_instance": 1,
"command_class": 37,
"command_class_label": "",
"value_index": 1,
"device_id": zwave_switch_device.id,
"domain": zwave_switch_entry.domain,
"entity_id": zwave_switch_entry.entity_id,
"unique_id": ZWAVE_SWITCH_UNIQUE_ID,
"unit_of_measurement": zwave_switch_entry.unit_of_measurement,
},
ZWAVE_POWER_ENTITY: {
"node_id": 102,
"node_instance": 1,
"command_class": 50,
"command_class_label": "Power",
"value_index": 8,
"device_id": zwave_switch_device.id,
"domain": zwave_power_entry.domain,
"entity_id": zwave_power_entry.entity_id,
"unique_id": ZWAVE_POWER_UNIQUE_ID,
"unit_of_measurement": zwave_power_entry.unit_of_measurement,
},
ZWAVE_SOURCE_NODE_ENTITY: {
"node_id": 52,
"node_instance": 1,
"command_class": 113,
"command_class_label": "SourceNodeId",
"value_index": 1,
"device_id": zwave_multisensor_device.id,
"domain": zwave_source_node_entry.domain,
"entity_id": zwave_source_node_entry.entity_id,
"unique_id": ZWAVE_SOURCE_NODE_UNIQUE_ID,
"unit_of_measurement": zwave_source_node_entry.unit_of_measurement,
},
ZWAVE_BATTERY_ENTITY: {
"node_id": 52,
"node_instance": 1,
"command_class": 128,
"command_class_label": "Battery Level",
"value_index": 0,
"device_id": zwave_multisensor_device.id,
"domain": zwave_battery_entry.domain,
"entity_id": zwave_battery_entry.entity_id,
"unique_id": ZWAVE_BATTERY_UNIQUE_ID,
"unit_of_measurement": zwave_battery_entry.unit_of_measurement,
},
ZWAVE_TAMPERING_ENTITY: {
"node_id": 52,
"node_instance": 1,
"command_class": 113,
"command_class_label": "Burglar",
"value_index": 10,
"device_id": zwave_multisensor_device.id,
"domain": zwave_tampering_entry.domain,
"entity_id": zwave_tampering_entry.entity_id,
"unique_id": ZWAVE_TAMPERING_UNIQUE_ID,
"unit_of_measurement": zwave_tampering_entry.unit_of_measurement,
},
}
mock_device_registry(
hass,
{
zwave_switch_device.id: zwave_switch_device,
zwave_multisensor_device.id: zwave_multisensor_device,
},
)
mock_registry(
hass,
{
ZWAVE_SWITCH_ENTITY: zwave_switch_entry,
ZWAVE_SOURCE_NODE_ENTITY: zwave_source_node_entry,
ZWAVE_BATTERY_ENTITY: zwave_battery_entry,
ZWAVE_POWER_ENTITY: zwave_power_entry,
ZWAVE_TAMPERING_ENTITY: zwave_tampering_entry,
},
)
return zwave_migration_data
@pytest.fixture(name="zwave_integration")
def zwave_integration_fixture(hass, zwave_migration_data):
"""Mock the zwave integration."""
hass.config.components.add("zwave")
zwave_config_entry = MockConfigEntry(domain="zwave", data={"usb_path": "/dev/test"})
zwave_config_entry.add_to_hass(hass)
with patch(
"homeassistant.components.zwave.async_get_migration_data",
return_value=zwave_migration_data,
):
yield zwave_config_entry
async def test_migrate_zwave(
hass,
zwave_integration,
aeon_smart_switch_6,
multisensor_6,
integration,
hass_ws_client,
):
"""Test the Z-Wave to Z-Wave JS migration websocket api."""
entry = integration
client = await hass_ws_client(hass)
assert hass.config_entries.async_entries("zwave")
await client.send_json(
{
ID: 5,
TYPE: "zwave_js/migrate_zwave",
ENTRY_ID: entry.entry_id,
"dry_run": False,
}
)
msg = await client.receive_json()
result = msg["result"]
migration_entity_map = {
ZWAVE_SWITCH_ENTITY: "switch.smart_switch_6",
ZWAVE_BATTERY_ENTITY: "sensor.multisensor_6_battery_level",
}
assert result["zwave_entity_ids"] == [
ZWAVE_SWITCH_ENTITY,
ZWAVE_POWER_ENTITY,
ZWAVE_SOURCE_NODE_ENTITY,
ZWAVE_BATTERY_ENTITY,
ZWAVE_TAMPERING_ENTITY,
]
expected_zwave_js_entities = [
"switch.smart_switch_6",
"sensor.multisensor_6_air_temperature",
"sensor.multisensor_6_illuminance",
"sensor.multisensor_6_humidity",
"sensor.multisensor_6_ultraviolet",
"binary_sensor.multisensor_6_home_security_tampering_product_cover_removed",
"binary_sensor.multisensor_6_home_security_motion_detection",
"sensor.multisensor_6_battery_level",
"binary_sensor.multisensor_6_low_battery_level",
"light.smart_switch_6",
"sensor.smart_switch_6_electric_consumed_kwh",
"sensor.smart_switch_6_electric_consumed_w",
"sensor.smart_switch_6_electric_consumed_v",
"sensor.smart_switch_6_electric_consumed_a",
]
# Assert that both lists have the same items without checking order
assert not set(result["zwave_js_entity_ids"]) ^ set(expected_zwave_js_entities)
assert result["migration_entity_map"] == migration_entity_map
assert result["migrated"] is True
dev_reg = dr.async_get(hass)
ent_reg = er.async_get(hass)
# check the device registry migration
# check that the migrated entries have correct attributes
multisensor_device_entry = dev_reg.async_get_device(
identifiers={("zwave_js", "3245146787-52")}, connections=set()
)
assert multisensor_device_entry
assert multisensor_device_entry.name_by_user == ZWAVE_MULTISENSOR_DEVICE_NAME
assert multisensor_device_entry.area_id == ZWAVE_MULTISENSOR_DEVICE_AREA
switch_device_entry = dev_reg.async_get_device(
identifiers={("zwave_js", "3245146787-102")}, connections=set()
)
assert switch_device_entry
assert switch_device_entry.name_by_user == ZWAVE_SWITCH_DEVICE_NAME
assert switch_device_entry.area_id == ZWAVE_SWITCH_DEVICE_AREA
migration_device_map = {
ZWAVE_SWITCH_DEVICE_ID: switch_device_entry.id,
ZWAVE_MULTISENSOR_DEVICE_ID: multisensor_device_entry.id,
}
assert result["migration_device_map"] == migration_device_map
# check the entity registry migration
# this should have been migrated and no longer present under that id
assert not ent_reg.async_is_registered("sensor.multisensor_6_battery_level")
# these should not have been migrated and is still in the registry
assert ent_reg.async_is_registered(ZWAVE_SOURCE_NODE_ENTITY)
source_entry = ent_reg.async_get(ZWAVE_SOURCE_NODE_ENTITY)
assert source_entry.unique_id == ZWAVE_SOURCE_NODE_UNIQUE_ID
assert ent_reg.async_is_registered(ZWAVE_POWER_ENTITY)
source_entry = ent_reg.async_get(ZWAVE_POWER_ENTITY)
assert source_entry.unique_id == ZWAVE_POWER_UNIQUE_ID
assert ent_reg.async_is_registered(ZWAVE_TAMPERING_ENTITY)
tampering_entry = ent_reg.async_get(ZWAVE_TAMPERING_ENTITY)
assert tampering_entry.unique_id == ZWAVE_TAMPERING_UNIQUE_ID
assert ent_reg.async_is_registered("sensor.smart_switch_6_electric_consumed_w")
# this is the new entity_ids of the zwave_js entities
assert ent_reg.async_is_registered(ZWAVE_SWITCH_ENTITY)
assert ent_reg.async_is_registered(ZWAVE_BATTERY_ENTITY)
# check that the migrated entries have correct attributes
switch_entry = ent_reg.async_get(ZWAVE_SWITCH_ENTITY)
assert switch_entry
assert switch_entry.unique_id == "3245146787.102-37-0-currentValue"
assert switch_entry.name == ZWAVE_SWITCH_NAME
assert switch_entry.icon == ZWAVE_SWITCH_ICON
battery_entry = ent_reg.async_get(ZWAVE_BATTERY_ENTITY)
assert battery_entry
assert battery_entry.unique_id == "3245146787.52-128-0-level"
assert battery_entry.name == ZWAVE_BATTERY_NAME
assert battery_entry.icon == ZWAVE_BATTERY_ICON
# check that the zwave config entry has been removed
assert not hass.config_entries.async_entries("zwave")
# Check that the zwave integration fails entry setup after migration
zwave_config_entry = MockConfigEntry(domain="zwave")
zwave_config_entry.add_to_hass(hass)
assert not await hass.config_entries.async_setup(zwave_config_entry.entry_id)
async def test_migrate_zwave_dry_run(
hass,
zwave_integration,
aeon_smart_switch_6,
multisensor_6,
integration,
hass_ws_client,
):
"""Test the zwave to zwave_js migration websocket api dry run."""
entry = integration
client = await hass_ws_client(hass)
await client.send_json(
{ID: 5, TYPE: "zwave_js/migrate_zwave", ENTRY_ID: entry.entry_id}
)
msg = await client.receive_json()
result = msg["result"]
migration_entity_map = {
ZWAVE_SWITCH_ENTITY: "switch.smart_switch_6",
ZWAVE_BATTERY_ENTITY: "sensor.multisensor_6_battery_level",
}
assert result["zwave_entity_ids"] == [
ZWAVE_SWITCH_ENTITY,
ZWAVE_POWER_ENTITY,
ZWAVE_SOURCE_NODE_ENTITY,
ZWAVE_BATTERY_ENTITY,
ZWAVE_TAMPERING_ENTITY,
]
expected_zwave_js_entities = [
"switch.smart_switch_6",
"sensor.multisensor_6_air_temperature",
"sensor.multisensor_6_illuminance",
"sensor.multisensor_6_humidity",
"sensor.multisensor_6_ultraviolet",
"binary_sensor.multisensor_6_home_security_tampering_product_cover_removed",
"binary_sensor.multisensor_6_home_security_motion_detection",
"sensor.multisensor_6_battery_level",
"binary_sensor.multisensor_6_low_battery_level",
"light.smart_switch_6",
"sensor.smart_switch_6_electric_consumed_kwh",
"sensor.smart_switch_6_electric_consumed_w",
"sensor.smart_switch_6_electric_consumed_v",
"sensor.smart_switch_6_electric_consumed_a",
]
# Assert that both lists have the same items without checking order
assert not set(result["zwave_js_entity_ids"]) ^ set(expected_zwave_js_entities)
assert result["migration_entity_map"] == migration_entity_map
dev_reg = dr.async_get(hass)
multisensor_device_entry = dev_reg.async_get_device(
identifiers={("zwave_js", "3245146787-52")}, connections=set()
)
assert multisensor_device_entry
assert multisensor_device_entry.name_by_user is None
assert multisensor_device_entry.area_id is None
switch_device_entry = dev_reg.async_get_device(
identifiers={("zwave_js", "3245146787-102")}, connections=set()
)
assert switch_device_entry
assert switch_device_entry.name_by_user is None
assert switch_device_entry.area_id is None
migration_device_map = {
ZWAVE_SWITCH_DEVICE_ID: switch_device_entry.id,
ZWAVE_MULTISENSOR_DEVICE_ID: multisensor_device_entry.id,
}
assert result["migration_device_map"] == migration_device_map
assert result["migrated"] is False
ent_reg = er.async_get(hass)
# no real migration should have been done
assert ent_reg.async_is_registered("switch.smart_switch_6")
assert ent_reg.async_is_registered("sensor.multisensor_6_battery_level")
assert ent_reg.async_is_registered("sensor.smart_switch_6_electric_consumed_w")
assert ent_reg.async_is_registered(ZWAVE_SOURCE_NODE_ENTITY)
source_entry = ent_reg.async_get(ZWAVE_SOURCE_NODE_ENTITY)
assert source_entry
assert source_entry.unique_id == ZWAVE_SOURCE_NODE_UNIQUE_ID
assert ent_reg.async_is_registered(ZWAVE_BATTERY_ENTITY)
battery_entry = ent_reg.async_get(ZWAVE_BATTERY_ENTITY)
assert battery_entry
assert battery_entry.unique_id == ZWAVE_BATTERY_UNIQUE_ID
assert ent_reg.async_is_registered(ZWAVE_POWER_ENTITY)
power_entry = ent_reg.async_get(ZWAVE_POWER_ENTITY)
assert power_entry
assert power_entry.unique_id == ZWAVE_POWER_UNIQUE_ID
# check that the zwave config entry has not been removed
assert hass.config_entries.async_entries("zwave")
# Check that the zwave integration can be setup after dry run
zwave_config_entry = zwave_integration
with patch("openzwave.option.ZWaveOption"), patch("openzwave.network.ZWaveNetwork"):
assert await hass.config_entries.async_setup(zwave_config_entry.entry_id)
async def test_migrate_zwave_not_setup(
hass, aeon_smart_switch_6, multisensor_6, integration, hass_ws_client
):
"""Test the zwave to zwave_js migration websocket without zwave setup."""
entry = integration
client = await hass_ws_client(hass)
await client.send_json(
{ID: 5, TYPE: "zwave_js/migrate_zwave", ENTRY_ID: entry.entry_id}
)
msg = await client.receive_json()
assert not msg["success"]
assert msg["error"]["code"] == "zwave_not_loaded"
assert msg["error"]["message"] == "Integration zwave is not loaded"
async def test_unique_id_migration_dupes(
hass, multisensor_6_state, client, integration
):
"""Test we remove an entity when ."""
ent_reg = er.async_get(hass)
entity_name = AIR_TEMPERATURE_SENSOR.split(".")[1]
# Create entity RegistryEntry using old unique ID format
old_unique_id_1 = (
f"{client.driver.controller.home_id}.52.52-49-00-Air temperature-00"
)
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id_1,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
)
assert entity_entry.entity_id == AIR_TEMPERATURE_SENSOR
assert entity_entry.unique_id == old_unique_id_1
# Create entity RegistryEntry using b0 unique ID format
old_unique_id_2 = (
f"{client.driver.controller.home_id}.52.52-49-0-Air temperature-00-00"
)
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id_2,
suggested_object_id=f"{entity_name}_1",
config_entry=integration,
original_name=entity_name,
)
assert entity_entry.entity_id == f"{AIR_TEMPERATURE_SENSOR}_1"
assert entity_entry.unique_id == old_unique_id_2
# Add a ready node, unique ID should be migrated
node = Node(client, copy.deepcopy(multisensor_6_state))
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(AIR_TEMPERATURE_SENSOR)
new_unique_id = f"{client.driver.controller.home_id}.52-49-0-Air temperature"
assert entity_entry.unique_id == new_unique_id
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id_1) is None
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id_2) is None
@pytest.mark.parametrize(
"id",
[
("52.52-49-00-Air temperature-00"),
("52.52-49-0-Air temperature-00-00"),
("52-49-0-Air temperature-00-00"),
],
)
async def test_unique_id_migration(hass, multisensor_6_state, client, integration, id):
"""Test unique ID is migrated from old format to new."""
ent_reg = er.async_get(hass)
# Migrate version 1
entity_name = AIR_TEMPERATURE_SENSOR.split(".")[1]
# Create entity RegistryEntry using old unique ID format
old_unique_id = f"{client.driver.controller.home_id}.{id}"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
)
assert entity_entry.entity_id == AIR_TEMPERATURE_SENSOR
assert entity_entry.unique_id == old_unique_id
# Add a ready node, unique ID should be migrated
node = Node(client, copy.deepcopy(multisensor_6_state))
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(AIR_TEMPERATURE_SENSOR)
new_unique_id = f"{client.driver.controller.home_id}.52-49-0-Air temperature"
assert entity_entry.unique_id == new_unique_id
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id) is None
@pytest.mark.parametrize(
"id",
[
("32.32-50-00-value-W_Consumed"),
("32.32-50-0-value-66049-W_Consumed"),
("32-50-0-value-66049-W_Consumed"),
],
)
async def test_unique_id_migration_property_key(
hass, hank_binary_switch_state, client, integration, id
):
"""Test unique ID with property key is migrated from old format to new."""
ent_reg = er.async_get(hass)
SENSOR_NAME = "sensor.smart_plug_with_two_usb_ports_value_electric_consumed"
entity_name = SENSOR_NAME.split(".")[1]
# Create entity RegistryEntry using old unique ID format
old_unique_id = f"{client.driver.controller.home_id}.{id}"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
)
assert entity_entry.entity_id == SENSOR_NAME
assert entity_entry.unique_id == old_unique_id
# Add a ready node, unique ID should be migrated
node = Node(client, copy.deepcopy(hank_binary_switch_state))
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(SENSOR_NAME)
new_unique_id = f"{client.driver.controller.home_id}.32-50-0-value-66049"
assert entity_entry.unique_id == new_unique_id
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id) is None
async def test_unique_id_migration_notification_binary_sensor(
hass, multisensor_6_state, client, integration
):
"""Test unique ID is migrated from old format to new for a notification binary sensor."""
ent_reg = er.async_get(hass)
entity_name = NOTIFICATION_MOTION_BINARY_SENSOR.split(".")[1]
# Create entity RegistryEntry using old unique ID format
old_unique_id = f"{client.driver.controller.home_id}.52.52-113-00-Home Security-Motion sensor status.8"
entity_entry = ent_reg.async_get_or_create(
"binary_sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
)
assert entity_entry.entity_id == NOTIFICATION_MOTION_BINARY_SENSOR
assert entity_entry.unique_id == old_unique_id
# Add a ready node, unique ID should be migrated
node = Node(client, copy.deepcopy(multisensor_6_state))
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(NOTIFICATION_MOTION_BINARY_SENSOR)
new_unique_id = f"{client.driver.controller.home_id}.52-113-0-Home Security-Motion sensor status.8"
assert entity_entry.unique_id == new_unique_id
assert ent_reg.async_get_entity_id("binary_sensor", DOMAIN, old_unique_id) is None
async def test_old_entity_migration(
hass, hank_binary_switch_state, client, integration
):
"""Test old entity on a different endpoint is migrated to a new one."""
node = Node(client, copy.deepcopy(hank_binary_switch_state))
ent_reg = er.async_get(hass)
dev_reg = dr.async_get(hass)
device = dev_reg.async_get_or_create(
config_entry_id=integration.entry_id,
identifiers={get_device_id(client, node)},
manufacturer=hank_binary_switch_state["deviceConfig"]["manufacturer"],
model=hank_binary_switch_state["deviceConfig"]["label"],
)
SENSOR_NAME = "sensor.smart_plug_with_two_usb_ports_value_electric_consumed"
entity_name = SENSOR_NAME.split(".")[1]
# Create entity RegistryEntry using fake endpoint
old_unique_id = f"{client.driver.controller.home_id}.32-50-1-value-66049"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
device_id=device.id,
)
assert entity_entry.entity_id == SENSOR_NAME
assert entity_entry.unique_id == old_unique_id
# Do this twice to make sure re-interview doesn't do anything weird
for i in range(0, 2):
# Add a ready node, unique ID should be migrated
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(SENSOR_NAME)
new_unique_id = f"{client.driver.controller.home_id}.32-50-0-value-66049"
assert entity_entry.unique_id == new_unique_id
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id) is None
async def test_different_endpoint_migration_status_sensor(
hass, hank_binary_switch_state, client, integration
):
"""Test that the different endpoint migration logic skips over the status sensor."""
node = Node(client, copy.deepcopy(hank_binary_switch_state))
ent_reg = er.async_get(hass)
dev_reg = dr.async_get(hass)
device = dev_reg.async_get_or_create(
config_entry_id=integration.entry_id,
identifiers={get_device_id(client, node)},
manufacturer=hank_binary_switch_state["deviceConfig"]["manufacturer"],
model=hank_binary_switch_state["deviceConfig"]["label"],
)
SENSOR_NAME = "sensor.smart_plug_with_two_usb_ports_status_sensor"
entity_name = SENSOR_NAME.split(".")[1]
# Create entity RegistryEntry using fake endpoint
old_unique_id = f"{client.driver.controller.home_id}.32.node_status"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
device_id=device.id,
)
assert entity_entry.entity_id == SENSOR_NAME
assert entity_entry.unique_id == old_unique_id
# Do this twice to make sure re-interview doesn't do anything weird
for i in range(0, 2):
# Add a ready node, unique ID should be migrated
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that the RegistryEntry is using the same unique ID
entity_entry = ent_reg.async_get(SENSOR_NAME)
assert entity_entry.unique_id == old_unique_id
async def test_skip_old_entity_migration_for_multiple(
hass, hank_binary_switch_state, client, integration
):
"""Test that multiple entities of the same value but on a different endpoint get skipped."""
node = Node(client, copy.deepcopy(hank_binary_switch_state))
ent_reg = er.async_get(hass)
dev_reg = dr.async_get(hass)
device = dev_reg.async_get_or_create(
config_entry_id=integration.entry_id,
identifiers={get_device_id(client, node)},
manufacturer=hank_binary_switch_state["deviceConfig"]["manufacturer"],
model=hank_binary_switch_state["deviceConfig"]["label"],
)
SENSOR_NAME = "sensor.smart_plug_with_two_usb_ports_value_electric_consumed"
entity_name = SENSOR_NAME.split(".")[1]
# Create two entity entrrys using different endpoints
old_unique_id_1 = f"{client.driver.controller.home_id}.32-50-1-value-66049"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id_1,
suggested_object_id=f"{entity_name}_1",
config_entry=integration,
original_name=f"{entity_name}_1",
device_id=device.id,
)
assert entity_entry.entity_id == f"{SENSOR_NAME}_1"
assert entity_entry.unique_id == old_unique_id_1
# Create two entity entrrys using different endpoints
old_unique_id_2 = f"{client.driver.controller.home_id}.32-50-2-value-66049"
entity_entry = ent_reg.async_get_or_create(
"sensor",
DOMAIN,
old_unique_id_2,
suggested_object_id=f"{entity_name}_2",
config_entry=integration,
original_name=f"{entity_name}_2",
device_id=device.id,
)
assert entity_entry.entity_id == f"{SENSOR_NAME}_2"
assert entity_entry.unique_id == old_unique_id_2
# Add a ready node, unique ID should be migrated
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is created using new unique ID format
entity_entry = ent_reg.async_get(SENSOR_NAME)
new_unique_id = f"{client.driver.controller.home_id}.32-50-0-value-66049"
assert entity_entry.unique_id == new_unique_id
# Check that the old entities stuck around because we skipped the migration step
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id_1)
assert ent_reg.async_get_entity_id("sensor", DOMAIN, old_unique_id_2)
async def test_old_entity_migration_notification_binary_sensor(
hass, multisensor_6_state, client, integration
):
"""Test old entity on a different endpoint is migrated to a new one for a notification binary sensor."""
node = Node(client, copy.deepcopy(multisensor_6_state))
ent_reg = er.async_get(hass)
dev_reg = dr.async_get(hass)
device = dev_reg.async_get_or_create(
config_entry_id=integration.entry_id,
identifiers={get_device_id(client, node)},
manufacturer=multisensor_6_state["deviceConfig"]["manufacturer"],
model=multisensor_6_state["deviceConfig"]["label"],
)
entity_name = NOTIFICATION_MOTION_BINARY_SENSOR.split(".")[1]
# Create entity RegistryEntry using old unique ID format
old_unique_id = f"{client.driver.controller.home_id}.52-113-1-Home Security-Motion sensor status.8"
entity_entry = ent_reg.async_get_or_create(
"binary_sensor",
DOMAIN,
old_unique_id,
suggested_object_id=entity_name,
config_entry=integration,
original_name=entity_name,
device_id=device.id,
)
assert entity_entry.entity_id == NOTIFICATION_MOTION_BINARY_SENSOR
assert entity_entry.unique_id == old_unique_id
# Do this twice to make sure re-interview doesn't do anything weird
for _ in range(0, 2):
# Add a ready node, unique ID should be migrated
event = {"node": node}
client.driver.controller.emit("node added", event)
await hass.async_block_till_done()
# Check that new RegistryEntry is using new unique ID format
entity_entry = ent_reg.async_get(NOTIFICATION_MOTION_BINARY_SENSOR)
new_unique_id = f"{client.driver.controller.home_id}.52-113-0-Home Security-Motion sensor status.8"
assert entity_entry.unique_id == new_unique_id
assert (
ent_reg.async_get_entity_id("binary_sensor", DOMAIN, old_unique_id) is None
)
Reference in New Issue View Git Blame Copy Permalink