async def test_devices(device, hass, zigpy_device_mock, monkeypatch,
zha_device_joined_restored):
"""Test device discovery."""
zigpy_device = zigpy_device_mock(
device["endpoints"],
"00:11:22:33:44:55:66:77",
device["manufacturer"],
device["model"],
node_descriptor=device["node_descriptor"],
)
_dispatch = mock.MagicMock(wraps=disc.async_dispatch_discovery_info)
monkeypatch.setattr(core_zha_gw, "async_dispatch_discovery_info",
_dispatch)
entity_registry = await homeassistant.helpers.entity_registry.async_get_registry(
hass)
with mock.patch(
"homeassistant.components.zha.core.discovery._async_create_cluster_channel",
wraps=disc._async_create_cluster_channel,
):
await zha_device_joined_restored(zigpy_device)
await hass.async_block_till_done()
entity_ids = hass.states.async_entity_ids()
await hass.async_block_till_done()
zha_entities = {
ent
for ent in entity_ids if ent.split(".")[0] in zha_const.COMPONENTS
}
zha_gateway = get_zha_gateway(hass)
zha_dev = zha_gateway.get_device(zigpy_device.ieee)
event_channels = { # pylint: disable=protected-access
ch.id
for ch in zha_dev._relay_channels.values()
}
assert zha_entities == set(device["entities"])
assert event_channels == set(device["event_channels"])
entity_map = device["entity_map"]
for calls in _dispatch.call_args_list:
discovery_info = calls[0][2]
unique_id = discovery_info["unique_id"]
channels = discovery_info["channels"]
component = discovery_info["component"]
key = (component, unique_id)
entity_id = entity_registry.async_get_entity_id(
component, "zha", unique_id)
assert key in entity_map
assert entity_id is not None
no_tail_id = NO_TAIL_ID.sub("", entity_map[key]["entity_id"])
assert entity_id.startswith(no_tail_id)
assert set([ch.name for ch in channels
]) == set(entity_map[key]["channels"])
async def test_channel_with_empty_ep_attribute_cluster(
hass_disable_services,
zigpy_device_mock,
zha_device_joined_restored,
):
"""Test device discovery for cluster which does not have em_attribute."""
entity_registry = homeassistant.helpers.entity_registry.async_get(
hass_disable_services)
zigpy_device = zigpy_device_mock(
{1: {
SIG_EP_INPUT: [0x042E],
SIG_EP_OUTPUT: [],
SIG_EP_TYPE: 0x1234
}},
"00:11:22:33:44:55:66:77",
"test manufacturer",
"test model",
patch_cluster=False,
)
zha_dev = await zha_device_joined_restored(zigpy_device)
ha_entity_id = entity_registry.async_get_entity_id(
"sensor", "zha", f"{zha_dev.ieee}-1-1070")
assert ha_entity_id is not None
async def test_devices(
device, hass, zigpy_device_mock, monkeypatch, zha_device_joined_restored
):
"""Test device discovery."""
entity_registry = await homeassistant.helpers.entity_registry.async_get_registry(
hass
)
zigpy_device = zigpy_device_mock(
device["endpoints"],
"00:11:22:33:44:55:66:77",
device["manufacturer"],
device["model"],
node_descriptor=device["node_descriptor"],
)
cluster_identify = _get_first_identify_cluster(zigpy_device)
if cluster_identify:
cluster_identify.request.reset_mock()
orig_new_entity = zha_channels.ChannelPool.async_new_entity
_dispatch = mock.MagicMock(wraps=orig_new_entity)
try:
zha_channels.ChannelPool.async_new_entity = lambda *a, **kw: _dispatch(*a, **kw)
zha_dev = await zha_device_joined_restored(zigpy_device)
await hass.async_block_till_done()
finally:
zha_channels.ChannelPool.async_new_entity = orig_new_entity
entity_ids = hass.states.async_entity_ids()
await hass.async_block_till_done()
zha_entity_ids = {
ent for ent in entity_ids if ent.split(".")[0] in zha_const.COMPONENTS
}
if cluster_identify:
called = int(zha_device_joined_restored.name == "zha_device_joined")
assert cluster_identify.request.call_count == called
assert cluster_identify.request.await_count == called
if called:
assert cluster_identify.request.call_args == mock.call(
False,
64,
(zigpy.types.uint8_t, zigpy.types.uint8_t),
2,
0,
expect_reply=True,
manufacturer=None,
tsn=None,
)
event_channels = {
ch.id for pool in zha_dev.channels.pools for ch in pool.relay_channels.values()
}
entity_map = device["entity_map"]
assert zha_entity_ids == set(
[
e["entity_id"]
for e in entity_map.values()
if not e.get("default_match", False)
]
)
assert event_channels == set(device["event_channels"])
for call in _dispatch.call_args_list:
_, component, entity_cls, unique_id, channels = call[0]
key = (component, unique_id)
entity_id = entity_registry.async_get_entity_id(component, "zha", unique_id)
assert key in entity_map
assert entity_id is not None
no_tail_id = NO_TAIL_ID.sub("", entity_map[key]["entity_id"])
assert entity_id.startswith(no_tail_id)
assert set([ch.name for ch in channels]) == set(entity_map[key]["channels"])
assert entity_cls.__name__ == entity_map[key]["entity_class"]
async def test_devices(
device,
hass_disable_services,
zigpy_device_mock,
zha_device_joined_restored,
):
"""Test device discovery."""
entity_registry = homeassistant.helpers.entity_registry.async_get(
hass_disable_services)
zigpy_device = zigpy_device_mock(
device[SIG_ENDPOINTS],
"00:11:22:33:44:55:66:77",
device[SIG_MANUFACTURER],
device[SIG_MODEL],
node_descriptor=device[SIG_NODE_DESC],
patch_cluster=False,
)
cluster_identify = _get_first_identify_cluster(zigpy_device)
if cluster_identify:
cluster_identify.request.reset_mock()
orig_new_entity = zha_channels.ChannelPool.async_new_entity
_dispatch = mock.MagicMock(wraps=orig_new_entity)
try:
zha_channels.ChannelPool.async_new_entity = lambda *a, **kw: _dispatch(
*a, **kw)
zha_dev = await zha_device_joined_restored(zigpy_device)
await hass_disable_services.async_block_till_done()
finally:
zha_channels.ChannelPool.async_new_entity = orig_new_entity
if cluster_identify:
called = int(zha_device_joined_restored.name == "zha_device_joined")
assert cluster_identify.request.call_count == called
assert cluster_identify.request.await_count == called
if called:
assert cluster_identify.request.call_args == mock.call(
False,
64,
cluster_identify.commands_by_name["trigger_effect"].schema,
2,
0,
expect_reply=True,
manufacturer=None,
tries=1,
tsn=None,
)
event_channels = {
ch.id
for pool in zha_dev.channels.pools
for ch in pool.client_channels.values()
}
assert event_channels == set(device[DEV_SIG_EVT_CHANNELS])
# we need to probe the class create entity factory so we need to reset this to get accurate results
zha_regs.ZHA_ENTITIES.clean_up()
# build a dict of entity_class -> (component, unique_id, channels) tuple
ha_ent_info = {}
created_entity_count = 0
for call in _dispatch.call_args_list:
_, component, entity_cls, unique_id, channels = call[0]
# the factory can return None. We filter these out to get an accurate created entity count
response = entity_cls.create_entity(unique_id, zha_dev, channels)
if response and not contains_ignored_suffix(response.name):
created_entity_count += 1
unique_id_head = UNIQUE_ID_HD.match(unique_id).group(
0) # ieee + endpoint_id
ha_ent_info[(unique_id_head, entity_cls.__name__)] = (
component,
unique_id,
channels,
)
for comp_id, ent_info in device[DEV_SIG_ENT_MAP].items():
component, unique_id = comp_id
no_tail_id = NO_TAIL_ID.sub("", ent_info[DEV_SIG_ENT_MAP_ID])
ha_entity_id = entity_registry.async_get_entity_id(
component, "zha", unique_id)
assert ha_entity_id is not None
assert ha_entity_id.startswith(no_tail_id)
test_ent_class = ent_info[DEV_SIG_ENT_MAP_CLASS]
test_unique_id_head = UNIQUE_ID_HD.match(unique_id).group(0)
assert (test_unique_id_head, test_ent_class) in ha_ent_info
ha_comp, ha_unique_id, ha_channels = ha_ent_info[(test_unique_id_head,
test_ent_class)]
assert component is ha_comp.value
# unique_id used for discover is the same for "multi entities"
assert unique_id.startswith(ha_unique_id)
assert {ch.name
for ch in ha_channels} == set(ent_info[DEV_SIG_CHANNELS])
assert created_entity_count == len(device[DEV_SIG_ENT_MAP])
entity_ids = hass_disable_services.states.async_entity_ids()
await hass_disable_services.async_block_till_done()
zha_entity_ids = {
ent
for ent in entity_ids if not contains_ignored_suffix(ent)
and ent.split(".")[0] in zha_const.PLATFORMS
}
assert zha_entity_ids == {
e[DEV_SIG_ENT_MAP_ID]
for e in device[DEV_SIG_ENT_MAP].values()
}
async def test_devices(
device,
hass_disable_services,
zigpy_device_mock,
zha_device_joined_restored,
):
"""Test device discovery."""
entity_registry = homeassistant.helpers.entity_registry.async_get(
hass_disable_services)
zigpy_device = zigpy_device_mock(
device[SIG_ENDPOINTS],
"00:11:22:33:44:55:66:77",
device[SIG_MANUFACTURER],
device[SIG_MODEL],
node_descriptor=device[SIG_NODE_DESC],
patch_cluster=False,
)
cluster_identify = _get_first_identify_cluster(zigpy_device)
if cluster_identify:
cluster_identify.request.reset_mock()
orig_new_entity = zha_channels.ChannelPool.async_new_entity
_dispatch = mock.MagicMock(wraps=orig_new_entity)
try:
zha_channels.ChannelPool.async_new_entity = lambda *a, **kw: _dispatch(
*a, **kw)
zha_dev = await zha_device_joined_restored(zigpy_device)
await hass_disable_services.async_block_till_done()
finally:
zha_channels.ChannelPool.async_new_entity = orig_new_entity
entity_ids = hass_disable_services.states.async_entity_ids()
await hass_disable_services.async_block_till_done()
zha_entity_ids = {
ent
for ent in entity_ids if ent.split(".")[0] in zha_const.PLATFORMS
}
if cluster_identify:
called = int(zha_device_joined_restored.name == "zha_device_joined")
assert cluster_identify.request.call_count == called
assert cluster_identify.request.await_count == called
if called:
assert cluster_identify.request.call_args == mock.call(
False,
64,
(zigpy.types.uint8_t, zigpy.types.uint8_t),
2,
0,
expect_reply=True,
manufacturer=None,
tries=1,
tsn=None,
)
event_channels = {
ch.id
for pool in zha_dev.channels.pools
for ch in pool.client_channels.values()
}
entity_map = device[DEV_SIG_ENT_MAP]
assert zha_entity_ids == {
e[DEV_SIG_ENT_MAP_ID]
for e in entity_map.values() if not e.get("default_match", False)
}
assert event_channels == set(device[DEV_SIG_EVT_CHANNELS])
for call in _dispatch.call_args_list:
_, component, entity_cls, unique_id, channels = call[0]
key = (component, unique_id)
entity_id = entity_registry.async_get_entity_id(
component, "zha", unique_id)
assert key in entity_map
assert entity_id is not None
no_tail_id = NO_TAIL_ID.sub("", entity_map[key][DEV_SIG_ENT_MAP_ID])
assert entity_id.startswith(no_tail_id)
assert {ch.name
for ch in channels} == set(entity_map[key][DEV_SIG_CHANNELS])
assert entity_cls.__name__ == entity_map[key][DEV_SIG_ENT_MAP_CLASS]
