diff --git a/homeassistant/components/device_automation/__init__.py b/homeassistant/components/device_automation/__init__.py index 563b13824b3..da786a634fa 100644 --- a/homeassistant/components/device_automation/__init__.py +++ b/homeassistant/components/device_automation/__init__.py @@ -265,7 +265,10 @@ async def async_get_device_automations( ) continue for automation in device_results: - if automation_type == DeviceAutomationType.ACTION: + if automation_type in ( + DeviceAutomationType.ACTION, + DeviceAutomationType.CONDITION, + ): _async_set_entity_device_automation_metadata(hass, automation) combined_results[automation["device_id"]].append(automation) diff --git a/tests/components/alarm_control_panel/test_device_condition.py b/tests/components/alarm_control_panel/test_device_condition.py index 83f9ff79dca..bcb94a63bc9 100644 --- a/tests/components/alarm_control_panel/test_device_condition.py +++ b/tests/components/alarm_control_panel/test_device_condition.py @@ -14,6 +14,8 @@ from homeassistant.const import ( STATE_ALARM_TRIGGERED, ) from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -120,6 +122,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in basic_condition_types ] @@ -130,6 +133,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in expected_condition_types ] @@ -139,6 +143,54 @@ async def test_get_conditions( assert_lists_same(conditions, expected_conditions) +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_disarmed", "is_triggered"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_if_state(hass, calls): """Test for all conditions.""" assert await async_setup_component( diff --git a/tests/components/binary_sensor/test_device_condition.py b/tests/components/binary_sensor/test_device_condition.py index d06eac43e7c..11d925a8d98 100644 --- a/tests/components/binary_sensor/test_device_condition.py +++ b/tests/components/binary_sensor/test_device_condition.py @@ -10,11 +10,14 @@ from homeassistant.components.binary_sensor.device_condition import ENTITY_CONDI from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component import homeassistant.util.dt as dt_util from tests.common import ( MockConfigEntry, + assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, @@ -71,6 +74,7 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr "type": condition["type"], "device_id": device_entry.id, "entity_id": platform.ENTITIES[device_class].entity_id, + "metadata": {"secondary": False}, } for device_class in BinarySensorDeviceClass for condition in ENTITY_CONDITIONS[device_class] @@ -78,7 +82,55 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id ) - assert conditions == expected_conditions + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_on", "is_off"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) async def test_get_conditions_no_state(hass, device_reg, entity_reg): @@ -108,6 +160,7 @@ async def test_get_conditions_no_state(hass, device_reg, entity_reg): "type": condition["type"], "device_id": device_entry.id, "entity_id": entity_ids[device_class], + "metadata": {"secondary": False}, } for device_class in BinarySensorDeviceClass for condition in ENTITY_CONDITIONS[device_class] diff --git a/tests/components/climate/test_device_condition.py b/tests/components/climate/test_device_condition.py index 82b7fe359a5..ce496812105 100644 --- a/tests/components/climate/test_device_condition.py +++ b/tests/components/climate/test_device_condition.py @@ -6,6 +6,8 @@ import homeassistant.components.automation as automation from homeassistant.components.climate import DOMAIN, const, device_condition from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -91,6 +93,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in expected_condition_types ] @@ -100,6 +103,54 @@ async def test_get_conditions( assert_lists_same(conditions, expected_conditions) +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_hvac_mode"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_if_state(hass, calls): """Test for turn_on and turn_off conditions.""" assert await async_setup_component( diff --git a/tests/components/cover/test_device_condition.py b/tests/components/cover/test_device_condition.py index 8d6403f8b52..735996ba574 100644 --- a/tests/components/cover/test_device_condition.py +++ b/tests/components/cover/test_device_condition.py @@ -19,6 +19,8 @@ from homeassistant.const import ( STATE_UNAVAILABLE, ) from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -103,6 +105,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in expected_condition_types ] @@ -112,6 +115,55 @@ async def test_get_conditions( assert_lists_same(conditions, expected_conditions) +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + supported_features=SUPPORT_CLOSE, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_open", "is_closed", "is_opening", "is_closing"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_get_condition_capabilities( hass, device_reg, entity_reg, enable_custom_integrations ): diff --git a/tests/components/device_automation/test_init.py b/tests/components/device_automation/test_init.py index e9d97c8a70d..9d879b89a95 100644 --- a/tests/components/device_automation/test_init.py +++ b/tests/components/device_automation/test_init.py @@ -105,6 +105,7 @@ async def test_websocket_get_conditions(hass, hass_ws_client, device_reg, entity "type": "is_off", "device_id": device_entry.id, "entity_id": "light.test_5678", + "metadata": {"secondary": False}, }, { "condition": "device", @@ -112,6 +113,7 @@ async def test_websocket_get_conditions(hass, hass_ws_client, device_reg, entity "type": "is_on", "device_id": device_entry.id, "entity_id": "light.test_5678", + "metadata": {"secondary": False}, }, ] diff --git a/tests/components/device_tracker/test_device_condition.py b/tests/components/device_tracker/test_device_condition.py index 070d2b6fec3..9c97304b701 100644 --- a/tests/components/device_tracker/test_device_condition.py +++ b/tests/components/device_tracker/test_device_condition.py @@ -6,6 +6,8 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_tracker import DOMAIN from homeassistant.const import STATE_HOME from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -50,17 +52,60 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_not_home", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_not_home", "is_home"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ { "condition": "device", "domain": DOMAIN, - "type": "is_home", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": True}, + } + for condition in ["is_not_home", "is_home"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id diff --git a/tests/components/fan/test_device_condition.py b/tests/components/fan/test_device_condition.py index d8e60e7d6ca..8a00fd445e0 100644 --- a/tests/components/fan/test_device_condition.py +++ b/tests/components/fan/test_device_condition.py @@ -6,6 +6,8 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.fan import DOMAIN from homeassistant.const import STATE_OFF, STATE_ON from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -50,17 +52,60 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_off", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_off", "is_on"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ { "condition": "device", "domain": DOMAIN, - "type": "is_on", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id diff --git a/tests/components/humidifier/test_device_condition.py b/tests/components/humidifier/test_device_condition.py index 9c9b83a79d6..d63151a3433 100644 --- a/tests/components/humidifier/test_device_condition.py +++ b/tests/components/humidifier/test_device_condition.py @@ -7,6 +7,8 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.humidifier import DOMAIN, const, device_condition from homeassistant.const import ATTR_MODE, STATE_OFF, STATE_ON from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -83,6 +85,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in basic_condition_types ] @@ -93,6 +96,7 @@ async def test_get_conditions( "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } for condition in expected_condition_types ] @@ -102,6 +106,54 @@ async def test_get_conditions( assert_lists_same(conditions, expected_conditions) +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_if_state(hass, calls): """Test for turn_on and turn_off conditions.""" hass.states.async_set("humidifier.entity", STATE_ON, {ATTR_MODE: const.MODE_AWAY}) diff --git a/tests/components/light/test_device_condition.py b/tests/components/light/test_device_condition.py index ba718b385fb..81e95f63771 100644 --- a/tests/components/light/test_device_condition.py +++ b/tests/components/light/test_device_condition.py @@ -9,11 +9,14 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.light import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component import homeassistant.util.dt as dt_util from tests.common import ( MockConfigEntry, + assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, @@ -54,17 +57,12 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_off", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_on", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_off", "is_on"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id @@ -72,6 +70,54 @@ async def test_get_conditions(hass, device_reg, entity_reg): assert conditions == expected_conditions +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_get_condition_capabilities(hass, device_reg, entity_reg): """Test we get the expected capabilities from a light condition.""" config_entry = MockConfigEntry(domain="test", data={}) diff --git a/tests/components/lock/test_device_condition.py b/tests/components/lock/test_device_condition.py index 08cc8c97925..c932b390e90 100644 --- a/tests/components/lock/test_device_condition.py +++ b/tests/components/lock/test_device_condition.py @@ -12,6 +12,8 @@ from homeassistant.const import ( STATE_UNLOCKING, ) from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -56,38 +58,72 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_locked", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in [ + "is_locked", + "is_unlocked", + "is_unlocking", + "is_locking", + "is_jammed", + ] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ { "condition": "device", "domain": DOMAIN, - "type": "is_unlocked", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_unlocking", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_locking", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_jammed", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": True}, + } + for condition in [ + "is_locked", + "is_unlocked", + "is_unlocking", + "is_locking", + "is_jammed", + ] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id diff --git a/tests/components/media_player/test_device_condition.py b/tests/components/media_player/test_device_condition.py index 60e1ae7d19b..111e1048d9c 100644 --- a/tests/components/media_player/test_device_condition.py +++ b/tests/components/media_player/test_device_condition.py @@ -12,6 +12,8 @@ from homeassistant.const import ( STATE_PLAYING, ) from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -56,38 +58,60 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_off", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_off", "is_on", "is_idle", "is_paused", "is_playing"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ { "condition": "device", "domain": DOMAIN, - "type": "is_on", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_idle", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_paused", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_playing", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on", "is_idle", "is_paused", "is_playing"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id diff --git a/tests/components/remote/test_device_condition.py b/tests/components/remote/test_device_condition.py index e3ed3059d8b..b993ccd0f74 100644 --- a/tests/components/remote/test_device_condition.py +++ b/tests/components/remote/test_device_condition.py @@ -9,11 +9,14 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.remote import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component import homeassistant.util.dt as dt_util from tests.common import ( MockConfigEntry, + assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, @@ -54,22 +57,65 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_off", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_on", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_off", "is_on"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id ) - assert conditions == expected_conditions + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) async def test_get_condition_capabilities(hass, device_reg, entity_reg): diff --git a/tests/components/select/test_device_condition.py b/tests/components/select/test_device_condition.py index 5a309924f81..7c1dc443e56 100644 --- a/tests/components/select/test_device_condition.py +++ b/tests/components/select/test_device_condition.py @@ -16,6 +16,7 @@ from homeassistant.helpers import ( device_registry, entity_registry, ) +from homeassistant.helpers.entity import EntityCategory from homeassistant.setup import async_setup_component from tests.common import ( @@ -66,6 +67,7 @@ async def test_get_conditions( "type": "selected_option", "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": False}, } ] conditions = await async_get_device_automations( @@ -74,6 +76,54 @@ async def test_get_conditions( assert_lists_same(conditions, expected_conditions) +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (entity_registry.RegistryEntryHider.INTEGRATION, None), + (entity_registry.RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["selected_option"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + async def test_if_selected_option( hass: HomeAssistant, calls: list[ServiceCall] ) -> None: diff --git a/tests/components/sensor/test_device_condition.py b/tests/components/sensor/test_device_condition.py index d2be84e1233..31a9f13938b 100644 --- a/tests/components/sensor/test_device_condition.py +++ b/tests/components/sensor/test_device_condition.py @@ -7,10 +7,13 @@ from homeassistant.components.sensor import DOMAIN, SensorDeviceClass from homeassistant.components.sensor.device_condition import ENTITY_CONDITIONS from homeassistant.const import CONF_PLATFORM, PERCENTAGE, STATE_UNKNOWN from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( MockConfigEntry, + assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, @@ -68,6 +71,7 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr "type": condition["type"], "device_id": device_entry.id, "entity_id": platform.ENTITIES[device_class].entity_id, + "metadata": {"secondary": False}, } for device_class in SensorDeviceClass if device_class in UNITS_OF_MEASUREMENT @@ -78,7 +82,56 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr hass, DeviceAutomationType.CONDITION, device_entry.id ) assert len(conditions) == 26 - assert conditions == expected_conditions + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + unit_of_measurement="dogs", + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_value"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) async def test_get_conditions_no_state(hass, device_reg, entity_reg): @@ -109,6 +162,7 @@ async def test_get_conditions_no_state(hass, device_reg, entity_reg): "type": condition["type"], "device_id": device_entry.id, "entity_id": entity_ids[device_class], + "metadata": {"secondary": False}, } for device_class in SensorDeviceClass if device_class in UNITS_OF_MEASUREMENT @@ -118,7 +172,7 @@ async def test_get_conditions_no_state(hass, device_reg, entity_reg): conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id ) - assert conditions == expected_conditions + assert_lists_same(conditions, expected_conditions) @pytest.mark.parametrize( diff --git a/tests/components/switch/test_device_condition.py b/tests/components/switch/test_device_condition.py index b4663008b17..501ede5b5be 100644 --- a/tests/components/switch/test_device_condition.py +++ b/tests/components/switch/test_device_condition.py @@ -9,11 +9,14 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.switch import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component import homeassistant.util.dt as dt_util from tests.common import ( MockConfigEntry, + assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, @@ -54,22 +57,65 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_off", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, - { - "condition": "device", - "domain": DOMAIN, - "type": "is_on", - "device_id": device_entry.id, - "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_off", "is_on"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id ) - assert conditions == expected_conditions + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": condition, + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + "metadata": {"secondary": True}, + } + for condition in ["is_off", "is_on"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) async def test_get_condition_capabilities(hass, device_reg, entity_reg): diff --git a/tests/components/vacuum/test_device_condition.py b/tests/components/vacuum/test_device_condition.py index 086d34f65cd..12d4d9154a9 100644 --- a/tests/components/vacuum/test_device_condition.py +++ b/tests/components/vacuum/test_device_condition.py @@ -10,6 +10,8 @@ from homeassistant.components.vacuum import ( STATE_RETURNING, ) from homeassistant.helpers import device_registry +from homeassistant.helpers.entity import EntityCategory +from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -54,17 +56,60 @@ async def test_get_conditions(hass, device_reg, entity_reg): { "condition": "device", "domain": DOMAIN, - "type": "is_cleaning", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": False}, + } + for condition in ["is_cleaning", "is_docked"] + ] + conditions = await async_get_device_automations( + hass, DeviceAutomationType.CONDITION, device_entry.id + ) + assert_lists_same(conditions, expected_conditions) + + +@pytest.mark.parametrize( + "hidden_by,entity_category", + ( + (RegistryEntryHider.INTEGRATION, None), + (RegistryEntryHider.USER, None), + (None, EntityCategory.CONFIG), + (None, EntityCategory.DIAGNOSTIC), + ), +) +async def test_get_conditions_hidden_auxiliary( + hass, + device_reg, + entity_reg, + hidden_by, + entity_category, +): + """Test we get the expected conditions from a hidden or auxiliary entity.""" + config_entry = MockConfigEntry(domain="test", data={}) + config_entry.add_to_hass(hass) + device_entry = device_reg.async_get_or_create( + config_entry_id=config_entry.entry_id, + connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_reg.async_get_or_create( + DOMAIN, + "test", + "5678", + device_id=device_entry.id, + entity_category=entity_category, + hidden_by=hidden_by, + ) + expected_conditions = [ { "condition": "device", "domain": DOMAIN, - "type": "is_docked", + "type": condition, "device_id": device_entry.id, "entity_id": f"{DOMAIN}.test_5678", - }, + "metadata": {"secondary": True}, + } + for condition in ["is_cleaning", "is_docked"] ] conditions = await async_get_device_automations( hass, DeviceAutomationType.CONDITION, device_entry.id diff --git a/tests/components/zwave_js/test_device_condition.py b/tests/components/zwave_js/test_device_condition.py index 2161c8e6fe4..8b538a3c48b 100644 --- a/tests/components/zwave_js/test_device_condition.py +++ b/tests/components/zwave_js/test_device_condition.py @@ -45,6 +45,7 @@ async def test_get_conditions(hass, client, lock_schlage_be469, integration) -> "domain": DOMAIN, "type": "node_status", "device_id": device.id, + "metadata": {}, }, { "condition": "device", @@ -53,12 +54,14 @@ async def test_get_conditions(hass, client, lock_schlage_be469, integration) -> "device_id": device.id, "value_id": value_id, "subtype": f"{config_value.property_} ({name})", + "metadata": {}, }, { "condition": "device", "domain": DOMAIN, "type": "value", "device_id": device.id, + "metadata": {}, }, ] conditions = await async_get_device_automations(