Use entity registry id in binary_sensor device conditions (#95251)

homeassistant/components/binary_sensor/device_condition.py

@@ -256,7 +256,7 @@ ENTITY_CONDITIONS = {
 
 CONDITION_SCHEMA = cv.DEVICE_CONDITION_BASE_SCHEMA.extend(
     {
-        vol.Required(CONF_ENTITY_ID): cv.entity_id,
+        vol.Required(CONF_ENTITY_ID): cv.entity_id_or_uuid,
         vol.Required(CONF_TYPE): vol.In(IS_OFF + IS_ON),
         vol.Optional(CONF_FOR): cv.positive_time_period_dict,
     }
@@ -287,7 +287,7 @@ async def async_get_conditions(
                 **template,
                 "condition": "device",
                 "device_id": device_id,
-                "entity_id": entry.entity_id,
+                "entity_id": entry.id,
                 "domain": DOMAIN,
             }
             for template in templates

tests/components/binary_sensor/test_device_condition.py

@@ -45,6 +45,7 @@ async def test_get_conditions(
     platform.init()
     assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
     await hass.async_block_till_done()
+    binary_sensor_entries = {}
 
     config_entry = MockConfigEntry(domain="test", data={})
     config_entry.add_to_hass(hass)
@@ -53,7 +54,7 @@ async def test_get_conditions(
         connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
     for device_class in BinarySensorDeviceClass:
-        entity_registry.async_get_or_create(
+        binary_sensor_entries[device_class] = entity_registry.async_get_or_create(
             DOMAIN,
             "test",
             platform.ENTITIES[device_class].unique_id,
@@ -66,7 +67,7 @@ async def test_get_conditions(
             "domain": DOMAIN,
             "type": condition["type"],
             "device_id": device_entry.id,
-            "entity_id": platform.ENTITIES[device_class].entity_id,
+            "entity_id": binary_sensor_entries[device_class].id,
             "metadata": {"secondary": False},
         }
         for device_class in BinarySensorDeviceClass
@@ -101,7 +102,7 @@ async def test_get_conditions_hidden_auxiliary(
         config_entry_id=config_entry.entry_id,
         connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
-    entity_registry.async_get_or_create(
+    entity_entry = entity_registry.async_get_or_create(
         DOMAIN,
         "test",
         "5678",
@@ -115,7 +116,7 @@ async def test_get_conditions_hidden_auxiliary(
             "domain": DOMAIN,
             "type": condition,
             "device_id": device_entry.id,
-            "entity_id": f"{DOMAIN}.test_5678",
+            "entity_id": entity_entry.id,
             "metadata": {"secondary": True},
         }
         for condition in ["is_on", "is_off"]
@@ -138,15 +139,15 @@ async def test_get_conditions_no_state(
         config_entry_id=config_entry.entry_id,
         connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
     )
-    entity_ids = {}
+    binary_sensor_entries = {}
     for device_class in BinarySensorDeviceClass:
-        entity_ids[device_class] = entity_registry.async_get_or_create(
+        binary_sensor_entries[device_class] = entity_registry.async_get_or_create(
             DOMAIN,
             "test",
             f"5678_{device_class}",
             device_id=device_entry.id,
             original_device_class=device_class,
-        ).entity_id
+        )
 
     await hass.async_block_till_done()
 
@@ -156,7 +157,7 @@ async def test_get_conditions_no_state(
             "domain": DOMAIN,
             "type": condition["type"],
             "device_id": device_entry.id,
-            "entity_id": entity_ids[device_class],
+            "entity_id": binary_sensor_entries[device_class].id,
             "metadata": {"secondary": False},
         }
         for device_class in BinarySensorDeviceClass
@@ -198,8 +199,44 @@ async def test_get_condition_capabilities(
         assert capabilities == expected_capabilities
 
 
+async def test_get_condition_capabilities_legacy(
+    hass: HomeAssistant,
+    device_registry: dr.DeviceRegistry,
+    entity_registry: er.EntityRegistry,
+) -> None:
+    """Test we get the expected capabilities from a binary_sensor condition."""
+    config_entry = MockConfigEntry(domain="test", data={})
+    config_entry.add_to_hass(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")},
+    )
+    entity_registry.async_get_or_create(
+        DOMAIN, "test", "5678", device_id=device_entry.id
+    )
+    expected_capabilities = {
+        "extra_fields": [
+            {"name": "for", "optional": True, "type": "positive_time_period_dict"}
+        ]
+    }
+    conditions = await async_get_device_automations(
+        hass, DeviceAutomationType.CONDITION, device_entry.id
+    )
+    for condition in conditions:
+        condition["entity_id"] = entity_registry.async_get(
+            condition["entity_id"]
+        ).entity_id
+        capabilities = await async_get_device_automation_capabilities(
+            hass, DeviceAutomationType.CONDITION, condition
+        )
+        assert capabilities == expected_capabilities
+
+
 async def test_if_state(
-    hass: HomeAssistant, calls, enable_custom_integrations: None
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    calls,
+    enable_custom_integrations: None,
 ) -> None:
     """Test for turn_on and turn_off conditions."""
     platform = getattr(hass.components, f"test.{DOMAIN}")
@@ -208,7 +245,7 @@ async def test_if_state(
     assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
     await hass.async_block_till_done()
 
-    sensor1 = platform.ENTITIES["battery"]
+    entry = entity_registry.async_get(platform.ENTITIES["battery"].entity_id)
 
     assert await async_setup_component(
         hass,
@@ -222,7 +259,7 @@ async def test_if_state(
                             "condition": "device",
                             "domain": DOMAIN,
                             "device_id": "",
-                            "entity_id": sensor1.entity_id,
+                            "entity_id": entry.id,
                             "type": "is_bat_low",
                         }
                     ],
@@ -241,7 +278,7 @@ async def test_if_state(
                             "condition": "device",
                             "domain": DOMAIN,
                             "device_id": "",
-                            "entity_id": sensor1.entity_id,
+                            "entity_id": entry.id,
                             "type": "is_not_bat_low",
                         }
                     ],
@@ -257,7 +294,7 @@ async def test_if_state(
         },
     )
     await hass.async_block_till_done()
-    assert hass.states.get(sensor1.entity_id).state == STATE_ON
+    assert hass.states.get(entry.entity_id).state == STATE_ON
     assert len(calls) == 0
 
     hass.bus.async_fire("test_event1")
@@ -265,7 +302,7 @@ async def test_if_state(
     assert len(calls) == 1
     assert calls[0].data["some"] == "is_on event - test_event1"
 
-    hass.states.async_set(sensor1.entity_id, STATE_OFF)
+    hass.states.async_set(entry.entity_id, STATE_OFF)
     hass.bus.async_fire("test_event1")
     hass.bus.async_fire("test_event2")
     await hass.async_block_till_done()
@@ -273,8 +310,63 @@ async def test_if_state(
     assert calls[1].data["some"] == "is_off event - test_event2"
 
 
+async def test_if_state_legacy(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    calls,
+    enable_custom_integrations: None,
+) -> None:
+    """Test for turn_on and turn_off conditions."""
+    platform = getattr(hass.components, f"test.{DOMAIN}")
+
+    platform.init()
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
+    await hass.async_block_till_done()
+
+    entry = entity_registry.async_get(platform.ENTITIES["battery"].entity_id)
+
+    assert await async_setup_component(
+        hass,
+        automation.DOMAIN,
+        {
+            automation.DOMAIN: [
+                {
+                    "trigger": {"platform": "event", "event_type": "test_event1"},
+                    "condition": [
+                        {
+                            "condition": "device",
+                            "domain": DOMAIN,
+                            "device_id": "",
+                            "entity_id": entry.entity_id,
+                            "type": "is_bat_low",
+                        }
+                    ],
+                    "action": {
+                        "service": "test.automation",
+                        "data_template": {
+                            "some": "is_on {{ trigger.%s }}"
+                            % "}} - {{ trigger.".join(("platform", "event.event_type"))
+                        },
+                    },
+                },
+            ]
+        },
+    )
+    await hass.async_block_till_done()
+    assert hass.states.get(entry.entity_id).state == STATE_ON
+    assert len(calls) == 0
+
+    hass.bus.async_fire("test_event1")
+    await hass.async_block_till_done()
+    assert len(calls) == 1
+    assert calls[0].data["some"] == "is_on event - test_event1"
+
+
 async def test_if_fires_on_for_condition(
-    hass: HomeAssistant, calls, enable_custom_integrations: None
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    calls,
+    enable_custom_integrations: None,
 ) -> None:
     """Test for firing if condition is on with delay."""
     point1 = dt_util.utcnow()
@@ -287,7 +379,7 @@ async def test_if_fires_on_for_condition(
     assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
     await hass.async_block_till_done()
 
-    sensor1 = platform.ENTITIES["battery"]
+    entry = entity_registry.async_get(platform.ENTITIES["battery"].entity_id)
 
     with freeze_time(point1) as time_freeze:
         assert await async_setup_component(
@@ -301,7 +393,7 @@ async def test_if_fires_on_for_condition(
                             "condition": "device",
                             "domain": DOMAIN,
                             "device_id": "",
-                            "entity_id": sensor1.entity_id,
+                            "entity_id": entry.id,
                             "type": "is_not_bat_low",
                             "for": {"seconds": 5},
                         },
@@ -319,7 +411,7 @@ async def test_if_fires_on_for_condition(
             },
         )
         await hass.async_block_till_done()
-        assert hass.states.get(sensor1.entity_id).state == STATE_ON
+        assert hass.states.get(entry.entity_id).state == STATE_ON
         assert len(calls) == 0
 
         hass.bus.async_fire("test_event1")
@@ -332,7 +424,7 @@ async def test_if_fires_on_for_condition(
         await hass.async_block_till_done()
         assert len(calls) == 0
 
-        hass.states.async_set(sensor1.entity_id, STATE_OFF)
+        hass.states.async_set(entry.entity_id, STATE_OFF)
         hass.bus.async_fire("test_event1")
         await hass.async_block_till_done()
         assert len(calls) == 0