diff --git a/homeassistant/components/alarm_control_panel/const.py b/homeassistant/components/alarm_control_panel/const.py index 77f7846fc34..2844cb286ab 100644 --- a/homeassistant/components/alarm_control_panel/const.py +++ b/homeassistant/components/alarm_control_panel/const.py @@ -5,3 +5,10 @@ SUPPORT_ALARM_ARM_AWAY = 2 SUPPORT_ALARM_ARM_NIGHT = 4 SUPPORT_ALARM_TRIGGER = 8 SUPPORT_ALARM_ARM_CUSTOM_BYPASS = 16 + +CONDITION_TRIGGERED = "is_triggered" +CONDITION_DISARMED = "is_disarmed" +CONDITION_ARMED_HOME = "is_armed_home" +CONDITION_ARMED_AWAY = "is_armed_away" +CONDITION_ARMED_NIGHT = "is_armed_night" +CONDITION_ARMED_CUSTOM_BYPASS = "is_armed_custom_bypass" diff --git a/homeassistant/components/alarm_control_panel/device_condition.py b/homeassistant/components/alarm_control_panel/device_condition.py new file mode 100644 index 00000000000..068c665ca5e --- /dev/null +++ b/homeassistant/components/alarm_control_panel/device_condition.py @@ -0,0 +1,162 @@ +"""Provide the device automations for Alarm control panel.""" +from typing import Dict, List + +import voluptuous as vol + +from homeassistant.components.alarm_control_panel.const import ( + SUPPORT_ALARM_ARM_AWAY, + SUPPORT_ALARM_ARM_CUSTOM_BYPASS, + SUPPORT_ALARM_ARM_HOME, + SUPPORT_ALARM_ARM_NIGHT, +) +from homeassistant.const import ( + ATTR_ENTITY_ID, + CONF_CONDITION, + CONF_DEVICE_ID, + CONF_DOMAIN, + CONF_ENTITY_ID, + CONF_TYPE, + STATE_ALARM_ARMED_AWAY, + STATE_ALARM_ARMED_CUSTOM_BYPASS, + STATE_ALARM_ARMED_HOME, + STATE_ALARM_ARMED_NIGHT, + STATE_ALARM_DISARMED, + STATE_ALARM_TRIGGERED, +) +from homeassistant.core import HomeAssistant +from homeassistant.helpers import condition, config_validation as cv, entity_registry +from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA +from homeassistant.helpers.typing import ConfigType, TemplateVarsType + +from . import DOMAIN +from .const import ( + CONDITION_ARMED_AWAY, + CONDITION_ARMED_CUSTOM_BYPASS, + CONDITION_ARMED_HOME, + CONDITION_ARMED_NIGHT, + CONDITION_DISARMED, + CONDITION_TRIGGERED, +) + +CONDITION_TYPES = { + CONDITION_TRIGGERED, + CONDITION_DISARMED, + CONDITION_ARMED_HOME, + CONDITION_ARMED_AWAY, + CONDITION_ARMED_NIGHT, + CONDITION_ARMED_CUSTOM_BYPASS, +} + +CONDITION_SCHEMA = DEVICE_CONDITION_BASE_SCHEMA.extend( + { + vol.Required(CONF_ENTITY_ID): cv.entity_id, + vol.Required(CONF_TYPE): vol.In(CONDITION_TYPES), + } +) + + +async def async_get_conditions( + hass: HomeAssistant, device_id: str +) -> List[Dict[str, str]]: + """List device conditions for Alarm control panel devices.""" + registry = await entity_registry.async_get_registry(hass) + conditions = [] + + # Get all the integrations entities for this device + for entry in entity_registry.async_entries_for_device(registry, device_id): + if entry.domain != DOMAIN: + continue + + state = hass.states.get(entry.entity_id) + + # We need a state or else we can't populate the different armed conditions + if state is None: + continue + + supported_features = state.attributes["supported_features"] + + # Add conditions for each entity that belongs to this integration + conditions += [ + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_DISARMED, + }, + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_TRIGGERED, + }, + ] + if supported_features & SUPPORT_ALARM_ARM_HOME: + conditions.append( + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_ARMED_HOME, + } + ) + if supported_features & SUPPORT_ALARM_ARM_AWAY: + conditions.append( + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_ARMED_AWAY, + } + ) + if supported_features & SUPPORT_ALARM_ARM_NIGHT: + conditions.append( + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_ARMED_NIGHT, + } + ) + if supported_features & SUPPORT_ALARM_ARM_CUSTOM_BYPASS: + conditions.append( + { + CONF_CONDITION: "device", + CONF_DEVICE_ID: device_id, + CONF_DOMAIN: DOMAIN, + CONF_ENTITY_ID: entry.entity_id, + CONF_TYPE: CONDITION_ARMED_CUSTOM_BYPASS, + } + ) + + return conditions + + +def async_condition_from_config( + config: ConfigType, config_validation: bool +) -> condition.ConditionCheckerType: + """Create a function to test a device condition.""" + if config_validation: + config = CONDITION_SCHEMA(config) + elif config[CONF_TYPE] == CONDITION_TRIGGERED: + state = STATE_ALARM_TRIGGERED + elif config[CONF_TYPE] == CONDITION_DISARMED: + state = STATE_ALARM_DISARMED + elif config[CONF_TYPE] == CONDITION_ARMED_HOME: + state = STATE_ALARM_ARMED_HOME + elif config[CONF_TYPE] == CONDITION_ARMED_AWAY: + state = STATE_ALARM_ARMED_AWAY + elif config[CONF_TYPE] == CONDITION_ARMED_NIGHT: + state = STATE_ALARM_ARMED_NIGHT + elif config[CONF_TYPE] == CONDITION_ARMED_CUSTOM_BYPASS: + state = STATE_ALARM_ARMED_CUSTOM_BYPASS + + def test_is_state(hass: HomeAssistant, variables: TemplateVarsType) -> bool: + """Test if an entity is a certain state.""" + return condition.state(hass, config[ATTR_ENTITY_ID], state) + + return test_is_state diff --git a/homeassistant/components/alarm_control_panel/strings.json b/homeassistant/components/alarm_control_panel/strings.json index cbca15c8cf6..4e14a8c2a3d 100644 --- a/homeassistant/components/alarm_control_panel/strings.json +++ b/homeassistant/components/alarm_control_panel/strings.json @@ -1,18 +1,25 @@ { - "device_automation": { - "action_type": { - "arm_away": "Arm {entity_name} away", - "arm_home": "Arm {entity_name} home", - "arm_night": "Arm {entity_name} night", - "disarm": "Disarm {entity_name}", - "trigger": "Trigger {entity_name}" - }, - "trigger_type": { - "triggered": "{entity_name} triggered", - "disarmed": "{entity_name} disarmed", - "armed_home": "{entity_name} armed home", - "armed_away": "{entity_name} armed away", - "armed_night": "{entity_name} armed night" + "device_automation": { + "action_type": { + "arm_away": "Arm {entity_name} away", + "arm_home": "Arm {entity_name} home", + "arm_night": "Arm {entity_name} night", + "disarm": "Disarm {entity_name}", + "trigger": "Trigger {entity_name}" + }, + "condition_type": { + "is_triggered": "{entity_name} is triggered", + "is_disarmed": "{entity_name} is disarmed", + "is_armed_home": "{entity_name} is armed home", + "is_armed_away": "{entity_name} is armed away", + "is_armed_night": "{entity_name} is armed night" + }, + "trigger_type": { + "triggered": "{entity_name} triggered", + "disarmed": "{entity_name} disarmed", + "armed_home": "{entity_name} armed home", + "armed_away": "{entity_name} armed away", + "armed_night": "{entity_name} armed night" + } } - } } \ No newline at end of file diff --git a/tests/components/alarm_control_panel/test_device_condition.py b/tests/components/alarm_control_panel/test_device_condition.py new file mode 100644 index 00000000000..fcb2ba5a09b --- /dev/null +++ b/tests/components/alarm_control_panel/test_device_condition.py @@ -0,0 +1,334 @@ +"""The tests for Alarm control panel device conditions.""" +import pytest + +from homeassistant.components.alarm_control_panel import DOMAIN +import homeassistant.components.automation as automation +from homeassistant.const import ( + STATE_ALARM_ARMED_AWAY, + STATE_ALARM_ARMED_CUSTOM_BYPASS, + STATE_ALARM_ARMED_HOME, + STATE_ALARM_ARMED_NIGHT, + STATE_ALARM_DISARMED, + STATE_ALARM_TRIGGERED, +) +from homeassistant.helpers import device_registry +from homeassistant.setup import async_setup_component + +from tests.common import ( + MockConfigEntry, + assert_lists_same, + async_get_device_automations, + async_mock_service, + mock_device_registry, + mock_registry, +) + + +@pytest.fixture +def device_reg(hass): + """Return an empty, loaded, registry.""" + return mock_device_registry(hass) + + +@pytest.fixture +def entity_reg(hass): + """Return an empty, loaded, registry.""" + return mock_registry(hass) + + +@pytest.fixture +def calls(hass): + """Track calls to a mock service.""" + return async_mock_service(hass, "test", "automation") + + +async def test_get_no_conditions(hass, device_reg, entity_reg): + """Test we get the expected conditions from a alarm_control_panel.""" + 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) + conditions = await async_get_device_automations(hass, "condition", device_entry.id) + assert_lists_same(conditions, []) + + +async def test_get_minimum_conditions(hass, device_reg, entity_reg): + """Test we get the expected conditions from a alarm_control_panel.""" + 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) + hass.states.async_set( + "alarm_control_panel.test_5678", "attributes", {"supported_features": 0} + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": "is_disarmed", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_triggered", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + ] + + conditions = await async_get_device_automations(hass, "condition", device_entry.id) + assert_lists_same(conditions, expected_conditions) + + +async def test_get_maximum_conditions(hass, device_reg, entity_reg): + """Test we get the expected conditions from a alarm_control_panel.""" + 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) + hass.states.async_set( + "alarm_control_panel.test_5678", "attributes", {"supported_features": 31} + ) + expected_conditions = [ + { + "condition": "device", + "domain": DOMAIN, + "type": "is_disarmed", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_triggered", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_armed_home", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_armed_away", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_armed_night", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + { + "condition": "device", + "domain": DOMAIN, + "type": "is_armed_custom_bypass", + "device_id": device_entry.id, + "entity_id": f"{DOMAIN}.test_5678", + }, + ] + + conditions = await async_get_device_automations(hass, "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( + hass, + automation.DOMAIN, + { + automation.DOMAIN: [ + { + "trigger": {"platform": "event", "event_type": "test_event1"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_triggered", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_triggered - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + { + "trigger": {"platform": "event", "event_type": "test_event2"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_disarmed", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_disarmed - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + { + "trigger": {"platform": "event", "event_type": "test_event3"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_armed_home", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_armed_home - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + { + "trigger": {"platform": "event", "event_type": "test_event4"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_armed_away", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_armed_away - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + { + "trigger": {"platform": "event", "event_type": "test_event5"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_armed_night", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_armed_night - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + { + "trigger": {"platform": "event", "event_type": "test_event6"}, + "condition": [ + { + "condition": "device", + "domain": DOMAIN, + "device_id": "", + "entity_id": "alarm_control_panel.entity", + "type": "is_armed_custom_bypass", + } + ], + "action": { + "service": "test.automation", + "data_template": { + "some": "is_armed_custom_bypass - {{ trigger.platform }} - {{ trigger.event.event_type }}" + }, + }, + }, + ] + }, + ) + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_TRIGGERED) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 1 + assert calls[0].data["some"] == "is_triggered - event - test_event1" + + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_DISARMED) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 2 + assert calls[1].data["some"] == "is_disarmed - event - test_event2" + + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_ARMED_HOME) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 3 + assert calls[2].data["some"] == "is_armed_home - event - test_event3" + + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_ARMED_AWAY) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 4 + assert calls[3].data["some"] == "is_armed_away - event - test_event4" + + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_ARMED_NIGHT) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 5 + assert calls[4].data["some"] == "is_armed_night - event - test_event5" + + hass.states.async_set("alarm_control_panel.entity", STATE_ALARM_ARMED_CUSTOM_BYPASS) + hass.bus.async_fire("test_event1") + hass.bus.async_fire("test_event2") + hass.bus.async_fire("test_event3") + hass.bus.async_fire("test_event4") + hass.bus.async_fire("test_event5") + hass.bus.async_fire("test_event6") + await hass.async_block_till_done() + assert len(calls) == 6 + assert calls[5].data["some"] == "is_armed_custom_bypass - event - test_event6"