evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make input_datetime better handle timezones (#43396)

Browse source 
* Make input_datetime better handle timezones

* Improve test coverage

* Apply suggestions from code review

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

* Revert change to time format

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
This commit is contained in:
Paulus Schoutsen 2020-11-26 20:20:10 +01:00 • committed by GitHub
parent f3033ec01d
commit edf70e9f06
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 227 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

128
tests/components/input_datetime/test_init.py
View file

@ -16,10 +16,13 @@ from homeassistant.components.input_datetime import (
CONF_ID,
CONF_INITIAL,
CONF_NAME,
CONFIG_SCHEMA,
DEFAULT_TIME,
DOMAIN,
FMT_DATE,
FMT_DATETIME,
FMT_TIME,
SERVICE_RELOAD,
SERVICE_SET_DATETIME,
)
from homeassistant.const import ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME, ATTR_NAME
from homeassistant.core import Context, CoreState, State
@ -35,6 +38,8 @@ INITIAL_DATE = "2020-01-10"
INITIAL_TIME = "23:45:56"
INITIAL_DATETIME = f"{INITIAL_DATE} {INITIAL_TIME}"
ORIG_TIMEZONE = dt_util.DEFAULT_TIME_ZONE
@pytest.fixture
def storage_setup(hass, hass_storage):
@ -74,7 +79,7 @@ async def async_set_date_and_time(hass, entity_id, dt_value):
"""Set date and / or time of input_datetime."""
await hass.services.async_call(
DOMAIN,
SERVICE_SET_DATETIME,
"set_datetime",
{
ATTR_ENTITY_ID: entity_id,
ATTR_DATE: dt_value.date(),
@ -88,7 +93,7 @@ async def async_set_datetime(hass, entity_id, dt_value):
"""Set date and / or time of input_datetime."""
await hass.services.async_call(
DOMAIN,
SERVICE_SET_DATETIME,
"set_datetime",
{ATTR_ENTITY_ID: entity_id, ATTR_DATETIME: dt_value},
blocking=True,
)
@ -98,22 +103,24 @@ async def async_set_timestamp(hass, entity_id, timestamp):
"""Set date and / or time of input_datetime."""
await hass.services.async_call(
DOMAIN,
SERVICE_SET_DATETIME,
"set_datetime",
{ATTR_ENTITY_ID: entity_id, ATTR_TIMESTAMP: timestamp},
blocking=True,
)
async def test_invalid_configs(hass):
"""Test config."""
invalid_configs = [
@pytest.mark.parametrize(
"config",
[
None,
{},
{"name with space": None},
{"test_no_value": {"has_time": False, "has_date": False}},
]
for cfg in invalid_configs:
assert not await async_setup_component(hass, DOMAIN, {DOMAIN: cfg})
],
)
def test_invalid_configs(config):
"""Test config."""
with pytest.raises(vol.Invalid):
CONFIG_SCHEMA({DOMAIN: config})
async def test_set_datetime(hass):
@ -129,7 +136,7 @@ async def test_set_datetime(hass):
await async_set_date_and_time(hass, entity_id, dt_obj)
state = hass.states.get(entity_id)
assert state.state == str(dt_obj)
assert state.state == dt_obj.strftime(FMT_DATETIME)
assert state.attributes["has_time"]
assert state.attributes["has_date"]
@ -155,7 +162,7 @@ async def test_set_datetime_2(hass):
await async_set_datetime(hass, entity_id, dt_obj)
state = hass.states.get(entity_id)
assert state.state == str(dt_obj)
assert state.state == dt_obj.strftime(FMT_DATETIME)
assert state.attributes["has_time"]
assert state.attributes["has_date"]
@ -181,7 +188,7 @@ async def test_set_datetime_3(hass):
await async_set_timestamp(hass, entity_id, dt_util.as_utc(dt_obj).timestamp())
state = hass.states.get(entity_id)
assert state.state == str(dt_obj)
assert state.state == dt_obj.strftime(FMT_DATETIME)
assert state.attributes["has_time"]
assert state.attributes["has_date"]
@ -203,12 +210,11 @@ async def test_set_datetime_time(hass):
entity_id = "input_datetime.test_time"
dt_obj = datetime.datetime(2017, 9, 7, 19, 46, 30)
time_portion = dt_obj.time()
await async_set_date_and_time(hass, entity_id, dt_obj)
state = hass.states.get(entity_id)
assert state.state == str(time_portion)
assert state.state == dt_obj.strftime(FMT_TIME)
assert state.attributes["has_time"]
assert not state.attributes["has_date"]
@ -240,7 +246,6 @@ async def test_set_invalid(hass):
{"entity_id": entity_id, "time": time_portion},
blocking=True,
)
await hass.async_block_till_done()
state = hass.states.get(entity_id)
assert state.state == initial
@ -329,7 +334,7 @@ async def test_restore_state(hass):
"test_bogus_data": {
"has_time": True,
"has_date": True,
"initial": str(initial),
"initial": initial.strftime(FMT_DATETIME),
},
"test_was_time": {"has_time": False, "has_date": True},
"test_was_date": {"has_time": True, "has_date": False},
@ -339,22 +344,22 @@ async def test_restore_state(hass):
dt_obj = datetime.datetime(2017, 9, 7, 19, 46)
state_time = hass.states.get("input_datetime.test_time")
assert state_time.state == str(dt_obj.time())
assert state_time.state == dt_obj.strftime(FMT_TIME)
state_date = hass.states.get("input_datetime.test_date")
assert state_date.state == str(dt_obj.date())
assert state_date.state == dt_obj.strftime(FMT_DATE)
state_datetime = hass.states.get("input_datetime.test_datetime")
assert state_datetime.state == str(dt_obj)
assert state_datetime.state == dt_obj.strftime(FMT_DATETIME)
state_bogus = hass.states.get("input_datetime.test_bogus_data")
assert state_bogus.state == str(initial)
assert state_bogus.state == initial.strftime(FMT_DATETIME)
state_was_time = hass.states.get("input_datetime.test_was_time")
assert state_was_time.state == str(default.date())
assert state_was_time.state == default.strftime(FMT_DATE)
state_was_date = hass.states.get("input_datetime.test_was_date")
assert state_was_date.state == str(default.time())
assert state_was_date.state == default.strftime(FMT_TIME)
async def test_default_value(hass):
@ -373,15 +378,15 @@ async def test_default_value(hass):
dt_obj = datetime.datetime(1970, 1, 1, 0, 0)
state_time = hass.states.get("input_datetime.test_time")
assert state_time.state == str(dt_obj.time())
assert state_time.state == dt_obj.strftime(FMT_TIME)
assert state_time.attributes.get("timestamp") is not None
state_date = hass.states.get("input_datetime.test_date")
assert state_date.state == str(dt_obj.date())
assert state_date.state == dt_obj.strftime(FMT_DATE)
assert state_date.attributes.get("timestamp") is not None
state_datetime = hass.states.get("input_datetime.test_datetime")
assert state_datetime.state == str(dt_obj)
assert state_datetime.state == dt_obj.strftime(FMT_DATETIME)
assert state_datetime.attributes.get("timestamp") is not None
@ -434,7 +439,7 @@ async def test_reload(hass, hass_admin_user, hass_read_only_user):
assert state_1 is not None
assert state_2 is None
assert state_3 is not None
assert str(dt_obj.date()) == state_1.state
assert dt_obj.strftime(FMT_DATE) == state_1.state
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt1") == f"{DOMAIN}.dt1"
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt2") is None
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt3") == f"{DOMAIN}.dt3"
@ -473,8 +478,8 @@ async def test_reload(hass, hass_admin_user, hass_read_only_user):
assert state_1 is not None
assert state_2 is not None
assert state_3 is None
assert str(DEFAULT_TIME) == state_1.state
assert str(datetime.datetime(1970, 1, 1, 0, 0)) == state_2.state
assert state_1.state == DEFAULT_TIME.strftime(FMT_TIME)
assert state_2.state == datetime.datetime(1970, 1, 1, 0, 0).strftime(FMT_DATETIME)
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt1") == f"{DOMAIN}.dt1"
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt2") == f"{DOMAIN}.dt2"
@ -641,3 +646,66 @@ async def test_setup_no_config(hass, hass_admin_user):
await hass.async_block_till_done()
assert count_start == len(hass.states.async_entity_ids())
async def test_timestamp(hass):
"""Test timestamp."""
try:
dt_util.set_default_time_zone(dt_util.get_time_zone("America/Los_Angeles"))
assert await async_setup_component(
hass,
DOMAIN,
{
DOMAIN: {
"test_datetime_initial_with_tz": {
"has_time": True,
"has_date": True,
"initial": "2020-12-13 10:00:00+01:00",
},
"test_datetime_initial_without_tz": {
"has_time": True,
"has_date": True,
"initial": "2020-12-13 10:00:00",
},
"test_time_initial": {
"has_time": True,
"has_date": False,
"initial": "10:00:00",
},
}
},
)
# initial has been converted to the set timezone
state_with_tz = hass.states.get("input_datetime.test_datetime_initial_with_tz")
assert state_with_tz is not None
assert state_with_tz.state == "2020-12-13 01:00:00"
assert (
dt_util.as_local(
dt_util.utc_from_timestamp(state_with_tz.attributes[ATTR_TIMESTAMP])
).strftime(FMT_DATETIME)
== "2020-12-13 01:00:00"
)
# initial has been interpreted as being part of set timezone
state_without_tz = hass.states.get(
"input_datetime.test_datetime_initial_without_tz"
)
assert state_without_tz is not None
assert state_without_tz.state == "2020-12-13 10:00:00"
assert (
dt_util.as_local(
dt_util.utc_from_timestamp(state_without_tz.attributes[ATTR_TIMESTAMP])
).strftime(FMT_DATETIME)
== "2020-12-13 10:00:00"
)
# Test initial time sets timestamp correctly.
state_time = hass.states.get("input_datetime.test_time_initial")
assert state_time is not None
assert state_time.state == "10:00:00"
assert state_time.attributes[ATTR_TIMESTAMP] == 10 * 60 * 60
finally:
dt_util.set_default_time_zone(ORIG_TIMEZONE)

6
tests/components/input_datetime/test_reproduce_state.py
View file

@ -19,6 +19,11 @@ async def test_reproducing_states(hass, caplog):
"2010-10-10",
{"has_date": True, "has_time": False},
)
hass.states.async_set(
"input_datetime.invalid_data",
"unavailable",
{"has_date": False, "has_time": False},
)
datetime_calls = async_mock_service(hass, "input_datetime", "set_datetime")
@ -57,6 +62,7 @@ async def test_reproducing_states(hass, caplog):
State("input_datetime.entity_date", "2011-10-10"),
# Should not raise
State("input_datetime.non_existing", "2010-10-10 01:20:00"),
State("input_datetime.invalid_data", "2010-10-10 01:20:00"),
],
)