mirror of
https://github.com/home-assistant/core.git
synced 2026-04-03 00:46:46 +01:00
647 lines
23 KiB
Python
647 lines
23 KiB
Python
"""Test window trigger."""
|
|
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from homeassistant.components.cover import ATTR_IS_CLOSED, CoverState
|
|
from homeassistant.const import (
|
|
ATTR_DEVICE_CLASS,
|
|
ATTR_LABEL_ID,
|
|
CONF_ENTITY_ID,
|
|
STATE_OFF,
|
|
STATE_ON,
|
|
)
|
|
from homeassistant.core import HomeAssistant, ServiceCall
|
|
|
|
from tests.components import (
|
|
TriggerStateDescription,
|
|
arm_trigger,
|
|
parametrize_target_entities,
|
|
parametrize_trigger_states,
|
|
set_or_remove_state,
|
|
target_entities,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
async def target_binary_sensors(hass: HomeAssistant) -> dict[str, list[str]]:
|
|
"""Create multiple binary sensor entities associated with different targets."""
|
|
return await target_entities(hass, "binary_sensor")
|
|
|
|
|
|
@pytest.fixture
|
|
async def target_covers(hass: HomeAssistant) -> dict[str, list[str]]:
|
|
"""Create multiple cover entities associated with different targets."""
|
|
return await target_entities(hass, "cover")
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"trigger_key",
|
|
[
|
|
"window.opened",
|
|
"window.closed",
|
|
],
|
|
)
|
|
async def test_window_triggers_gated_by_labs_flag(
|
|
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, trigger_key: str
|
|
) -> None:
|
|
"""Test the window triggers are gated by the labs flag."""
|
|
await arm_trigger(hass, trigger_key, None, {ATTR_LABEL_ID: "test_label"})
|
|
assert (
|
|
"Unnamed automation failed to setup triggers and has been disabled: Trigger "
|
|
f"'{trigger_key}' requires the experimental 'New triggers and conditions' "
|
|
"feature to be enabled in Home Assistant Labs settings (feature flag: "
|
|
"'new_triggers_conditions')"
|
|
) in caplog.text
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("binary_sensor"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[STATE_ON],
|
|
other_states=[STATE_OFF],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[STATE_OFF],
|
|
other_states=[STATE_ON],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_binary_sensor_behavior_any(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_binary_sensors: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires for binary_sensor entities with device_class window."""
|
|
other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
|
|
|
|
for eid in target_binary_sensors["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == (entities_in_target - 1) * state["count"]
|
|
service_calls.clear()
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("cover"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
other_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
other_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_cover_behavior_any(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_covers: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires for cover entities with device_class window."""
|
|
other_entity_ids = set(target_covers["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
|
|
|
|
for eid in target_covers["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == (entities_in_target - 1) * state["count"]
|
|
service_calls.clear()
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("binary_sensor"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[STATE_ON],
|
|
other_states=[STATE_OFF],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[STATE_OFF],
|
|
other_states=[STATE_ON],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_binary_sensor_behavior_first(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_binary_sensors: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires on the first binary_sensor state change."""
|
|
other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
|
|
|
|
for eid in target_binary_sensors["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {"behavior": "first"}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("binary_sensor"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[STATE_ON],
|
|
other_states=[STATE_OFF],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[STATE_OFF],
|
|
other_states=[STATE_ON],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_binary_sensor_behavior_last(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_binary_sensors: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires when the last binary_sensor changes state."""
|
|
other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
|
|
|
|
for eid in target_binary_sensors["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {"behavior": "last"}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("cover"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
other_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
other_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_cover_behavior_first(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_covers: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires on the first cover state change."""
|
|
other_entity_ids = set(target_covers["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
|
|
|
|
for eid in target_covers["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {"behavior": "first"}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
("trigger_target_config", "entity_id", "entities_in_target"),
|
|
parametrize_target_entities("cover"),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("trigger", "trigger_options", "states"),
|
|
[
|
|
*parametrize_trigger_states(
|
|
trigger="window.opened",
|
|
target_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
other_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
*parametrize_trigger_states(
|
|
trigger="window.closed",
|
|
target_states=[
|
|
(CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
|
|
],
|
|
other_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.OPENING, {ATTR_IS_CLOSED: False}),
|
|
(CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
|
|
],
|
|
extra_invalid_states=[
|
|
(CoverState.OPEN, {ATTR_IS_CLOSED: None}),
|
|
(CoverState.OPEN, {}),
|
|
],
|
|
additional_attributes={ATTR_DEVICE_CLASS: "window"},
|
|
trigger_from_none=False,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_cover_behavior_last(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
target_covers: dict[str, list[str]],
|
|
trigger_target_config: dict,
|
|
entity_id: str,
|
|
entities_in_target: int,
|
|
trigger: str,
|
|
trigger_options: dict[str, Any],
|
|
states: list[TriggerStateDescription],
|
|
) -> None:
|
|
"""Test window trigger fires when the last cover changes state."""
|
|
other_entity_ids = set(target_covers["included"]) - {entity_id}
|
|
excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
|
|
|
|
for eid in target_covers["included"]:
|
|
set_or_remove_state(hass, eid, states[0]["included"])
|
|
await hass.async_block_till_done()
|
|
for eid in excluded_entity_ids:
|
|
set_or_remove_state(hass, eid, states[0]["excluded"])
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(hass, trigger, {"behavior": "last"}, trigger_target_config)
|
|
|
|
for state in states[1:]:
|
|
excluded_state = state["excluded"]
|
|
included_state = state["included"]
|
|
for other_entity_id in other_entity_ids:
|
|
set_or_remove_state(hass, other_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
set_or_remove_state(hass, entity_id, included_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == state["count"]
|
|
for service_call in service_calls:
|
|
assert service_call.data[CONF_ENTITY_ID] == entity_id
|
|
service_calls.clear()
|
|
|
|
for excluded_entity_id in excluded_entity_ids:
|
|
set_or_remove_state(hass, excluded_entity_id, excluded_state)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
|
|
@pytest.mark.usefixtures("enable_labs_preview_features")
|
|
@pytest.mark.parametrize(
|
|
(
|
|
"trigger_key",
|
|
"binary_sensor_initial",
|
|
"binary_sensor_target",
|
|
"cover_initial",
|
|
"cover_initial_is_closed",
|
|
"cover_target",
|
|
"cover_target_is_closed",
|
|
),
|
|
[
|
|
(
|
|
"window.opened",
|
|
STATE_OFF,
|
|
STATE_ON,
|
|
CoverState.CLOSED,
|
|
True,
|
|
CoverState.OPEN,
|
|
False,
|
|
),
|
|
(
|
|
"window.closed",
|
|
STATE_ON,
|
|
STATE_OFF,
|
|
CoverState.OPEN,
|
|
False,
|
|
CoverState.CLOSED,
|
|
True,
|
|
),
|
|
],
|
|
)
|
|
async def test_window_trigger_excludes_non_window_device_class(
|
|
hass: HomeAssistant,
|
|
service_calls: list[ServiceCall],
|
|
trigger_key: str,
|
|
binary_sensor_initial: str,
|
|
binary_sensor_target: str,
|
|
cover_initial: str,
|
|
cover_initial_is_closed: bool,
|
|
cover_target: str,
|
|
cover_target_is_closed: bool,
|
|
) -> None:
|
|
"""Test window trigger does not fire for entities without device_class window."""
|
|
entity_id_window = "binary_sensor.test_window"
|
|
entity_id_door = "binary_sensor.test_door"
|
|
entity_id_cover_window = "cover.test_window"
|
|
entity_id_cover_door = "cover.test_door"
|
|
|
|
# Set initial states
|
|
hass.states.async_set(
|
|
entity_id_window, binary_sensor_initial, {ATTR_DEVICE_CLASS: "window"}
|
|
)
|
|
hass.states.async_set(
|
|
entity_id_door, binary_sensor_initial, {ATTR_DEVICE_CLASS: "door"}
|
|
)
|
|
hass.states.async_set(
|
|
entity_id_cover_window,
|
|
cover_initial,
|
|
{ATTR_DEVICE_CLASS: "window", ATTR_IS_CLOSED: cover_initial_is_closed},
|
|
)
|
|
hass.states.async_set(
|
|
entity_id_cover_door,
|
|
cover_initial,
|
|
{ATTR_DEVICE_CLASS: "door", ATTR_IS_CLOSED: cover_initial_is_closed},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
await arm_trigger(
|
|
hass,
|
|
trigger_key,
|
|
{},
|
|
{
|
|
CONF_ENTITY_ID: [
|
|
entity_id_window,
|
|
entity_id_door,
|
|
entity_id_cover_window,
|
|
entity_id_cover_door,
|
|
]
|
|
},
|
|
)
|
|
|
|
# Window binary_sensor changes - should trigger
|
|
hass.states.async_set(
|
|
entity_id_window, binary_sensor_target, {ATTR_DEVICE_CLASS: "window"}
|
|
)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 1
|
|
assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_window
|
|
service_calls.clear()
|
|
|
|
# Door binary_sensor changes - should NOT trigger (wrong device class)
|
|
hass.states.async_set(
|
|
entity_id_door, binary_sensor_target, {ATTR_DEVICE_CLASS: "door"}
|
|
)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|
|
|
|
# Cover window changes - should trigger
|
|
hass.states.async_set(
|
|
entity_id_cover_window,
|
|
cover_target,
|
|
{ATTR_DEVICE_CLASS: "window", ATTR_IS_CLOSED: cover_target_is_closed},
|
|
)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 1
|
|
assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_cover_window
|
|
service_calls.clear()
|
|
|
|
# Door cover changes - should NOT trigger (wrong device class)
|
|
hass.states.async_set(
|
|
entity_id_cover_door,
|
|
cover_target,
|
|
{ATTR_DEVICE_CLASS: "door", ATTR_IS_CLOSED: cover_target_is_closed},
|
|
)
|
|
await hass.async_block_till_done()
|
|
assert len(service_calls) == 0
|