589 lines
18 KiB
Python
589 lines
18 KiB
Python
"""The tests for the time automation."""
|
|
from datetime import timedelta
|
|
from unittest.mock import Mock, patch
|
|
|
|
import pytest
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.components import automation, sensor
|
|
from homeassistant.components.homeassistant.triggers import time
|
|
from homeassistant.const import ATTR_DEVICE_CLASS, ATTR_ENTITY_ID, SERVICE_TURN_OFF
|
|
from homeassistant.setup import async_setup_component
|
|
import homeassistant.util.dt as dt_util
|
|
|
|
from tests.common import (
|
|
assert_setup_component,
|
|
async_fire_time_changed,
|
|
async_mock_service,
|
|
mock_component,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def calls(hass):
|
|
"""Track calls to a mock service."""
|
|
return async_mock_service(hass, "test", "automation")
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def setup_comp(hass):
|
|
"""Initialize components."""
|
|
mock_component(hass, "group")
|
|
|
|
|
|
async def test_if_fires_using_at(hass, calls):
|
|
"""Test for firing at."""
|
|
now = dt_util.now()
|
|
|
|
trigger_dt = now.replace(hour=5, minute=0, second=0, microsecond=0) + timedelta(2)
|
|
time_that_will_not_match_right_away = trigger_dt - timedelta(minutes=1)
|
|
|
|
with patch(
|
|
"homeassistant.util.dt.utcnow",
|
|
return_value=dt_util.as_utc(time_that_will_not_match_right_away),
|
|
):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "time", "at": "5:00:00"},
|
|
"action": {
|
|
"service": "test.automation",
|
|
"data_template": {
|
|
"some": "{{ trigger.platform }} - {{ trigger.now.hour }}",
|
|
"id": "{{ trigger.id}}",
|
|
},
|
|
},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
assert calls[0].data["some"] == "time - 5"
|
|
assert calls[0].data["id"] == 0
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"has_date,has_time", [(True, True), (True, False), (False, True)]
|
|
)
|
|
async def test_if_fires_using_at_input_datetime(hass, calls, has_date, has_time):
|
|
"""Test for firing at input_datetime."""
|
|
await async_setup_component(
|
|
hass,
|
|
"input_datetime",
|
|
{"input_datetime": {"trigger": {"has_date": has_date, "has_time": has_time}}},
|
|
)
|
|
now = dt_util.now()
|
|
|
|
trigger_dt = now.replace(
|
|
hour=5 if has_time else 0, minute=0, second=0, microsecond=0
|
|
) + timedelta(2)
|
|
|
|
await hass.services.async_call(
|
|
"input_datetime",
|
|
"set_datetime",
|
|
{
|
|
ATTR_ENTITY_ID: "input_datetime.trigger",
|
|
"datetime": str(trigger_dt.replace(tzinfo=None)),
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
time_that_will_not_match_right_away = trigger_dt - timedelta(minutes=1)
|
|
|
|
some_data = "{{ trigger.platform }}-{{ trigger.now.day }}-{{ trigger.now.hour }}-{{trigger.entity_id}}"
|
|
with patch(
|
|
"homeassistant.util.dt.utcnow",
|
|
return_value=dt_util.as_utc(time_that_will_not_match_right_away),
|
|
):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "time", "at": "input_datetime.trigger"},
|
|
"action": {
|
|
"service": "test.automation",
|
|
"data_template": {"some": some_data},
|
|
},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
assert (
|
|
calls[0].data["some"]
|
|
== f"time-{trigger_dt.day}-{trigger_dt.hour}-input_datetime.trigger"
|
|
)
|
|
|
|
if has_date:
|
|
trigger_dt += timedelta(days=1)
|
|
if has_time:
|
|
trigger_dt += timedelta(hours=1)
|
|
|
|
await hass.services.async_call(
|
|
"input_datetime",
|
|
"set_datetime",
|
|
{
|
|
ATTR_ENTITY_ID: "input_datetime.trigger",
|
|
"datetime": str(trigger_dt.replace(tzinfo=None)),
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 2
|
|
assert (
|
|
calls[1].data["some"]
|
|
== f"time-{trigger_dt.day}-{trigger_dt.hour}-input_datetime.trigger"
|
|
)
|
|
|
|
|
|
async def test_if_fires_using_multiple_at(hass, calls):
|
|
"""Test for firing at."""
|
|
|
|
now = dt_util.now()
|
|
|
|
trigger_dt = now.replace(hour=5, minute=0, second=0, microsecond=0) + timedelta(2)
|
|
time_that_will_not_match_right_away = trigger_dt - timedelta(minutes=1)
|
|
|
|
with patch(
|
|
"homeassistant.util.dt.utcnow",
|
|
return_value=dt_util.as_utc(time_that_will_not_match_right_away),
|
|
):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "time", "at": ["5:00:00", "6:00:00"]},
|
|
"action": {
|
|
"service": "test.automation",
|
|
"data_template": {
|
|
"some": "{{ trigger.platform }} - {{ trigger.now.hour }}"
|
|
},
|
|
},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
assert calls[0].data["some"] == "time - 5"
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(hours=1, seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 2
|
|
assert calls[1].data["some"] == "time - 6"
|
|
|
|
|
|
async def test_if_not_fires_using_wrong_at(hass, calls):
|
|
"""YAML translates time values to total seconds.
|
|
|
|
This should break the before rule.
|
|
"""
|
|
now = dt_util.utcnow()
|
|
|
|
time_that_will_not_match_right_away = now.replace(
|
|
year=now.year + 1, hour=1, minute=0, second=0
|
|
)
|
|
|
|
with patch(
|
|
"homeassistant.util.dt.utcnow", return_value=time_that_will_not_match_right_away
|
|
):
|
|
with assert_setup_component(0, automation.DOMAIN):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {
|
|
"platform": "time",
|
|
"at": 3605,
|
|
# Total seconds. Hour = 3600 second
|
|
},
|
|
"action": {"service": "test.automation"},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(
|
|
hass, now.replace(year=now.year + 1, hour=1, minute=0, second=5)
|
|
)
|
|
|
|
await hass.async_block_till_done()
|
|
assert len(calls) == 0
|
|
|
|
|
|
async def test_if_action_before(hass, calls):
|
|
"""Test for if action before."""
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "event", "event_type": "test_event"},
|
|
"condition": {"condition": "time", "before": "10:00"},
|
|
"action": {"service": "test.automation"},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
before_10 = dt_util.now().replace(hour=8)
|
|
after_10 = dt_util.now().replace(hour=14)
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=before_10):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=after_10):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
|
|
async def test_if_action_after(hass, calls):
|
|
"""Test for if action after."""
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "event", "event_type": "test_event"},
|
|
"condition": {"condition": "time", "after": "10:00"},
|
|
"action": {"service": "test.automation"},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
before_10 = dt_util.now().replace(hour=8)
|
|
after_10 = dt_util.now().replace(hour=14)
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=before_10):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 0
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=after_10):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
|
|
async def test_if_action_one_weekday(hass, calls):
|
|
"""Test for if action with one weekday."""
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "event", "event_type": "test_event"},
|
|
"condition": {"condition": "time", "weekday": "mon"},
|
|
"action": {"service": "test.automation"},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
days_past_monday = dt_util.now().weekday()
|
|
monday = dt_util.now() - timedelta(days=days_past_monday)
|
|
tuesday = monday + timedelta(days=1)
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=monday):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=tuesday):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
|
|
async def test_if_action_list_weekday(hass, calls):
|
|
"""Test for action with a list of weekdays."""
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "event", "event_type": "test_event"},
|
|
"condition": {"condition": "time", "weekday": ["mon", "tue"]},
|
|
"action": {"service": "test.automation"},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
days_past_monday = dt_util.now().weekday()
|
|
monday = dt_util.now() - timedelta(days=days_past_monday)
|
|
tuesday = monday + timedelta(days=1)
|
|
wednesday = tuesday + timedelta(days=1)
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=monday):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=tuesday):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 2
|
|
|
|
with patch("homeassistant.helpers.condition.dt_util.now", return_value=wednesday):
|
|
hass.bus.async_fire("test_event")
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 2
|
|
|
|
|
|
async def test_untrack_time_change(hass):
|
|
"""Test for removing tracked time changes."""
|
|
mock_track_time_change = Mock()
|
|
with patch(
|
|
"homeassistant.components.homeassistant.triggers.time.async_track_time_change",
|
|
return_value=mock_track_time_change,
|
|
):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"alias": "test",
|
|
"trigger": {
|
|
"platform": "time",
|
|
"at": ["5:00:00", "6:00:00", "7:00:00"],
|
|
},
|
|
"action": {"service": "test.automation", "data": {"test": "test"}},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
await hass.services.async_call(
|
|
automation.DOMAIN,
|
|
SERVICE_TURN_OFF,
|
|
{ATTR_ENTITY_ID: "automation.test"},
|
|
blocking=True,
|
|
)
|
|
|
|
assert len(mock_track_time_change.mock_calls) == 3
|
|
|
|
|
|
async def test_if_fires_using_at_sensor(hass, calls):
|
|
"""Test for firing at sensor time."""
|
|
now = dt_util.now()
|
|
|
|
trigger_dt = now.replace(hour=5, minute=0, second=0, microsecond=0) + timedelta(2)
|
|
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
trigger_dt.isoformat(),
|
|
{ATTR_DEVICE_CLASS: sensor.DEVICE_CLASS_TIMESTAMP},
|
|
)
|
|
|
|
time_that_will_not_match_right_away = trigger_dt - timedelta(minutes=1)
|
|
|
|
some_data = "{{ trigger.platform }}-{{ trigger.now.day }}-{{ trigger.now.hour }}-{{trigger.entity_id}}"
|
|
with patch(
|
|
"homeassistant.util.dt.utcnow",
|
|
return_value=dt_util.as_utc(time_that_will_not_match_right_away),
|
|
):
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "time", "at": "sensor.next_alarm"},
|
|
"action": {
|
|
"service": "test.automation",
|
|
"data_template": {"some": some_data},
|
|
},
|
|
}
|
|
},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
assert (
|
|
calls[0].data["some"]
|
|
== f"time-{trigger_dt.day}-{trigger_dt.hour}-sensor.next_alarm"
|
|
)
|
|
|
|
trigger_dt += timedelta(days=1, hours=1)
|
|
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
trigger_dt.isoformat(),
|
|
{ATTR_DEVICE_CLASS: sensor.DEVICE_CLASS_TIMESTAMP},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 2
|
|
assert (
|
|
calls[1].data["some"]
|
|
== f"time-{trigger_dt.day}-{trigger_dt.hour}-sensor.next_alarm"
|
|
)
|
|
|
|
for broken in ("unknown", "unavailable", "invalid-ts"):
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
trigger_dt.isoformat(),
|
|
{ATTR_DEVICE_CLASS: sensor.DEVICE_CLASS_TIMESTAMP},
|
|
)
|
|
await hass.async_block_till_done()
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
broken,
|
|
{ATTR_DEVICE_CLASS: sensor.DEVICE_CLASS_TIMESTAMP},
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
# We should not have listened to anything
|
|
assert len(calls) == 2
|
|
|
|
# Now without device class
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
trigger_dt.isoformat(),
|
|
{ATTR_DEVICE_CLASS: sensor.DEVICE_CLASS_TIMESTAMP},
|
|
)
|
|
await hass.async_block_till_done()
|
|
hass.states.async_set(
|
|
"sensor.next_alarm",
|
|
trigger_dt.isoformat(),
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
async_fire_time_changed(hass, trigger_dt + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
# We should not have listened to anything
|
|
assert len(calls) == 2
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"conf",
|
|
[
|
|
{"platform": "time", "at": "input_datetime.bla"},
|
|
{"platform": "time", "at": "sensor.bla"},
|
|
{"platform": "time", "at": "12:34"},
|
|
],
|
|
)
|
|
def test_schema_valid(conf):
|
|
"""Make sure we don't accept number for 'at' value."""
|
|
time.TRIGGER_SCHEMA(conf)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"conf",
|
|
[
|
|
{"platform": "time", "at": "binary_sensor.bla"},
|
|
{"platform": "time", "at": 745},
|
|
{"platform": "time", "at": "25:00"},
|
|
],
|
|
)
|
|
def test_schema_invalid(conf):
|
|
"""Make sure we don't accept number for 'at' value."""
|
|
with pytest.raises(vol.Invalid):
|
|
time.TRIGGER_SCHEMA(conf)
|
|
|
|
|
|
async def test_datetime_in_past_on_load(hass, calls):
|
|
"""Test time trigger works if input_datetime is in past."""
|
|
await async_setup_component(
|
|
hass,
|
|
"input_datetime",
|
|
{"input_datetime": {"my_trigger": {"has_date": True, "has_time": True}}},
|
|
)
|
|
|
|
now = dt_util.now()
|
|
past = now - timedelta(days=2)
|
|
future = now + timedelta(days=1)
|
|
|
|
await hass.services.async_call(
|
|
"input_datetime",
|
|
"set_datetime",
|
|
{
|
|
ATTR_ENTITY_ID: "input_datetime.my_trigger",
|
|
"datetime": str(past.replace(tzinfo=None)),
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
assert await async_setup_component(
|
|
hass,
|
|
automation.DOMAIN,
|
|
{
|
|
automation.DOMAIN: {
|
|
"trigger": {"platform": "time", "at": "input_datetime.my_trigger"},
|
|
"action": {
|
|
"service": "test.automation",
|
|
"data_template": {
|
|
"some": "{{ trigger.platform }}-{{ trigger.now.day }}-{{ trigger.now.hour }}-{{trigger.entity_id}}"
|
|
},
|
|
},
|
|
}
|
|
},
|
|
)
|
|
|
|
async_fire_time_changed(hass, now)
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 0
|
|
|
|
await hass.services.async_call(
|
|
"input_datetime",
|
|
"set_datetime",
|
|
{
|
|
ATTR_ENTITY_ID: "input_datetime.my_trigger",
|
|
"datetime": str(future.replace(tzinfo=None)),
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
async_fire_time_changed(hass, future + timedelta(seconds=1))
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(calls) == 1
|
|
assert (
|
|
calls[0].data["some"]
|
|
== f"time-{future.day}-{future.hour}-input_datetime.my_trigger"
|
|
)
|