diff --git a/homeassistant/components/input_datetime/__init__.py b/homeassistant/components/input_datetime/__init__.py index e95287d2cbe..aa1f0b8814a 100644 --- a/homeassistant/components/input_datetime/__init__.py +++ b/homeassistant/components/input_datetime/__init__.py @@ -1,5 +1,5 @@ """Support to select a date and/or a time.""" -import datetime +import datetime as py_datetime import logging import typing @@ -33,12 +33,16 @@ CONF_HAS_TIME = "has_time" CONF_INITIAL = "initial" DEFAULT_VALUE = "1970-01-01 00:00:00" -DEFAULT_DATE = datetime.date(1970, 1, 1) -DEFAULT_TIME = datetime.time(0, 0, 0) +DEFAULT_DATE = py_datetime.date(1970, 1, 1) +DEFAULT_TIME = py_datetime.time(0, 0, 0) ATTR_DATETIME = "datetime" ATTR_TIMESTAMP = "timestamp" +FMT_DATE = "%Y-%m-%d" +FMT_TIME = "%H:%M:%S" +FMT_DATETIME = f"{FMT_DATE} {FMT_TIME}" + def validate_set_datetime_attrs(config): """Validate set_datetime service attributes.""" @@ -51,20 +55,6 @@ def validate_set_datetime_attrs(config): return config -SERVICE_SET_DATETIME = "set_datetime" -SERVICE_SET_DATETIME_SCHEMA = vol.All( - vol.Schema( - { - vol.Optional(ATTR_DATE): cv.date, - vol.Optional(ATTR_TIME): cv.time, - vol.Optional(ATTR_DATETIME): cv.datetime, - vol.Optional(ATTR_TIMESTAMP): vol.Coerce(float), - }, - extra=vol.ALLOW_EXTRA, - ), - cv.has_at_least_one_key(ATTR_DATE, ATTR_TIME, ATTR_DATETIME, ATTR_TIMESTAMP), - validate_set_datetime_attrs, -) STORAGE_KEY = DOMAIN STORAGE_VERSION = 1 @@ -162,31 +152,24 @@ async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool: schema=RELOAD_SERVICE_SCHEMA, ) - async def async_set_datetime_service(entity, call): - """Handle a call to the input datetime 'set datetime' service.""" - date = call.data.get(ATTR_DATE) - time = call.data.get(ATTR_TIME) - dttm = call.data.get(ATTR_DATETIME) - tmsp = call.data.get(ATTR_TIMESTAMP) - - if tmsp: - dttm = dt_util.as_local(dt_util.utc_from_timestamp(tmsp)).replace( - tzinfo=None - ) - if dttm: - date = dttm.date() - time = dttm.time() - if not entity.has_date: - date = None - if not entity.has_time: - time = None - if not date and not time: - raise vol.Invalid("Nothing to set") - - entity.async_set_datetime(date, time) - component.async_register_entity_service( - SERVICE_SET_DATETIME, SERVICE_SET_DATETIME_SCHEMA, async_set_datetime_service + "set_datetime", + vol.All( + vol.Schema( + { + vol.Optional(ATTR_DATE): cv.date, + vol.Optional(ATTR_TIME): cv.time, + vol.Optional(ATTR_DATETIME): cv.datetime, + vol.Optional(ATTR_TIMESTAMP): vol.Coerce(float), + }, + extra=vol.ALLOW_EXTRA, + ), + cv.has_at_least_one_key( + ATTR_DATE, ATTR_TIME, ATTR_DATETIME, ATTR_TIMESTAMP + ), + validate_set_datetime_attrs, + ), + "async_set_datetime", ) return True @@ -221,16 +204,31 @@ class InputDatetime(RestoreEntity): self._config = config self.editable = True self._current_datetime = None + initial = config.get(CONF_INITIAL) - if initial: - if self.has_date and self.has_time: - self._current_datetime = dt_util.parse_datetime(initial) - elif self.has_date: - date = dt_util.parse_date(initial) - self._current_datetime = datetime.datetime.combine(date, DEFAULT_TIME) - else: - time = dt_util.parse_time(initial) - self._current_datetime = datetime.datetime.combine(DEFAULT_DATE, time) + if not initial: + return + + if self.has_date and self.has_time: + current_datetime = dt_util.parse_datetime(initial) + + elif self.has_date: + date = dt_util.parse_date(initial) + current_datetime = py_datetime.datetime.combine(date, DEFAULT_TIME) + + else: + time = dt_util.parse_time(initial) + current_datetime = py_datetime.datetime.combine(DEFAULT_DATE, time) + + # If the user passed in an initial value with a timezone, convert it to right tz + if current_datetime.tzinfo is not None: + self._current_datetime = current_datetime.astimezone( + dt_util.DEFAULT_TIME_ZONE + ) + else: + self._current_datetime = dt_util.DEFAULT_TIME_ZONE.localize( + current_datetime + ) @classmethod def from_yaml(cls, config: typing.Dict) -> "InputDatetime": @@ -257,21 +255,27 @@ class InputDatetime(RestoreEntity): if self.has_date and self.has_time: date_time = dt_util.parse_datetime(old_state.state) if date_time is None: - self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) - return - self._current_datetime = date_time + current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) + else: + current_datetime = date_time + elif self.has_date: date = dt_util.parse_date(old_state.state) if date is None: - self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) - return - self._current_datetime = datetime.datetime.combine(date, DEFAULT_TIME) + current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) + else: + current_datetime = py_datetime.datetime.combine(date, DEFAULT_TIME) + else: time = dt_util.parse_time(old_state.state) if time is None: - self._current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) - return - self._current_datetime = datetime.datetime.combine(DEFAULT_DATE, time) + current_datetime = dt_util.parse_datetime(DEFAULT_VALUE) + else: + current_datetime = py_datetime.datetime.combine(DEFAULT_DATE, time) + + self._current_datetime = current_datetime.replace( + tzinfo=dt_util.DEFAULT_TIME_ZONE + ) @property def should_poll(self): @@ -305,10 +309,12 @@ class InputDatetime(RestoreEntity): return None if self.has_date and self.has_time: - return self._current_datetime + return self._current_datetime.strftime(FMT_DATETIME) + if self.has_date: - return self._current_datetime.date() - return self._current_datetime.time() + return self._current_datetime.strftime(FMT_DATE) + + return self._current_datetime.strftime(FMT_TIME) @property def state_attributes(self): @@ -338,11 +344,13 @@ class InputDatetime(RestoreEntity): + self._current_datetime.minute * 60 + self._current_datetime.second ) + elif not self.has_time: - extended = datetime.datetime.combine( - self._current_datetime, datetime.time(0, 0) + extended = py_datetime.datetime.combine( + self._current_datetime, py_datetime.time(0, 0) ) attrs["timestamp"] = extended.timestamp() + else: attrs["timestamp"] = self._current_datetime.timestamp() @@ -354,13 +362,35 @@ class InputDatetime(RestoreEntity): return self._config[CONF_ID] @callback - def async_set_datetime(self, date_val, time_val): + def async_set_datetime(self, date=None, time=None, datetime=None, timestamp=None): """Set a new date / time.""" - if not date_val: - date_val = self._current_datetime.date() - if not time_val: - time_val = self._current_datetime.time() - self._current_datetime = datetime.datetime.combine(date_val, time_val) + if timestamp: + datetime = dt_util.as_local(dt_util.utc_from_timestamp(timestamp)).replace( + tzinfo=None + ) + + if datetime: + date = datetime.date() + time = datetime.time() + + if not self.has_date: + date = None + + if not self.has_time: + time = None + + if not date and not time: + raise vol.Invalid("Nothing to set") + + if not date: + date = self._current_datetime.date() + + if not time: + time = self._current_datetime.time() + + self._current_datetime = py_datetime.datetime.combine(date, time).replace( + tzinfo=dt_util.DEFAULT_TIME_ZONE + ) self.async_write_ha_state() async def async_update_config(self, config: typing.Dict) -> None: diff --git a/homeassistant/components/input_datetime/reproduce_state.py b/homeassistant/components/input_datetime/reproduce_state.py index b9eb9800adf..cc906ac50b3 100644 --- a/homeassistant/components/input_datetime/reproduce_state.py +++ b/homeassistant/components/input_datetime/reproduce_state.py @@ -8,15 +8,7 @@ from homeassistant.core import Context, State from homeassistant.helpers.typing import HomeAssistantType from homeassistant.util import dt as dt_util -from . import ( - ATTR_DATE, - ATTR_DATETIME, - ATTR_TIME, - CONF_HAS_DATE, - CONF_HAS_TIME, - DOMAIN, - SERVICE_SET_DATETIME, -) +from . import ATTR_DATE, ATTR_DATETIME, ATTR_TIME, CONF_HAS_DATE, CONF_HAS_TIME, DOMAIN _LOGGER = logging.getLogger(__name__) @@ -53,22 +45,13 @@ async def _async_reproduce_state( _LOGGER.warning("Unable to find entity %s", state.entity_id) return + has_time = cur_state.attributes.get(CONF_HAS_TIME) + has_date = cur_state.attributes.get(CONF_HAS_DATE) + if not ( - ( - is_valid_datetime(state.state) - and cur_state.attributes.get(CONF_HAS_DATE) - and cur_state.attributes.get(CONF_HAS_TIME) - ) - or ( - is_valid_date(state.state) - and cur_state.attributes.get(CONF_HAS_DATE) - and not cur_state.attributes.get(CONF_HAS_TIME) - ) - or ( - is_valid_time(state.state) - and cur_state.attributes.get(CONF_HAS_TIME) - and not cur_state.attributes.get(CONF_HAS_DATE) - ) + (is_valid_datetime(state.state) and has_date and has_time) + or (is_valid_date(state.state) and has_date and not has_time) + or (is_valid_time(state.state) and has_time and not has_date) ): _LOGGER.warning( "Invalid state specified for %s: %s", state.entity_id, state.state @@ -79,24 +62,17 @@ async def _async_reproduce_state( if cur_state.state == state.state: return - service = SERVICE_SET_DATETIME service_data = {ATTR_ENTITY_ID: state.entity_id} - has_time = cur_state.attributes.get(CONF_HAS_TIME) - has_date = cur_state.attributes.get(CONF_HAS_DATE) - if has_time and has_date: service_data[ATTR_DATETIME] = state.state elif has_time: service_data[ATTR_TIME] = state.state elif has_date: service_data[ATTR_DATE] = state.state - else: - _LOGGER.warning("input_datetime needs either has_date or has_time or both") - return await hass.services.async_call( - DOMAIN, service, service_data, context=context, blocking=True + DOMAIN, "set_datetime", service_data, context=context, blocking=True ) diff --git a/homeassistant/core.py b/homeassistant/core.py index 68f0b9a30b7..9eeaf6fccca 100644 --- a/homeassistant/core.py +++ b/homeassistant/core.py @@ -419,7 +419,9 @@ class HomeAssistant: self._track_task = False @callback - def async_run_hass_job(self, hassjob: HassJob, *args: Any) -> None: + def async_run_hass_job( + self, hassjob: HassJob, *args: Any + ) -> Optional[asyncio.Future]: """Run a HassJob from within the event loop. This method must be run in the event loop. @@ -429,13 +431,14 @@ class HomeAssistant: """ if hassjob.job_type == HassJobType.Callback: hassjob.target(*args) - else: - self.async_add_hass_job(hassjob, *args) + return None + + return self.async_add_hass_job(hassjob, *args) @callback def async_run_job( self, target: Callable[..., Union[None, Awaitable]], *args: Any - ) -> None: + ) -> Optional[asyncio.Future]: """Run a job from within the event loop. This method must be run in the event loop. @@ -444,10 +447,9 @@ class HomeAssistant: args: parameters for method to call. """ if asyncio.iscoroutine(target): - self.async_create_task(cast(Coroutine, target)) - return + return self.async_create_task(cast(Coroutine, target)) - self.async_run_hass_job(HassJob(target), *args) + return self.async_run_hass_job(HassJob(target), *args) def block_till_done(self) -> None: """Block until all pending work is done.""" diff --git a/homeassistant/helpers/entity_component.py b/homeassistant/helpers/entity_component.py index b9d073dbe2e..0f1f04e3aec 100644 --- a/homeassistant/helpers/entity_component.py +++ b/homeassistant/helpers/entity_component.py @@ -192,7 +192,7 @@ class EntityComponent: self, name: str, schema: Union[Dict[str, Any], vol.Schema], - func: str, + func: Union[str, Callable[..., Any]], required_features: Optional[List[int]] = None, ) -> None: """Register an entity service.""" diff --git a/homeassistant/helpers/service.py b/homeassistant/helpers/service.py index 06d0ae46ae3..6a290a77b08 100644 --- a/homeassistant/helpers/service.py +++ b/homeassistant/helpers/service.py @@ -527,9 +527,9 @@ async def _handle_entity_call( entity.async_set_context(context) if isinstance(func, str): - result = hass.async_add_job(partial(getattr(entity, func), **data)) # type: ignore + result = hass.async_run_job(partial(getattr(entity, func), **data)) # type: ignore else: - result = hass.async_add_job(func, entity, data) + result = hass.async_run_job(func, entity, data) # Guard because callback functions do not return a task when passed to async_add_job. if result is not None: diff --git a/homeassistant/util/dt.py b/homeassistant/util/dt.py index 8b52170f0e4..a4d5fd81c4f 100644 --- a/homeassistant/util/dt.py +++ b/homeassistant/util/dt.py @@ -108,6 +108,9 @@ def start_of_local_day( date: dt.date = now().date() elif isinstance(dt_or_d, dt.datetime): date = dt_or_d.date() + else: + date = dt_or_d + return DEFAULT_TIME_ZONE.localize( # type: ignore dt.datetime.combine(date, dt.time()) ) diff --git a/tests/components/input_datetime/test_init.py b/tests/components/input_datetime/test_init.py index 70f0b69d3ef..53914a83ba2 100644 --- a/tests/components/input_datetime/test_init.py +++ b/tests/components/input_datetime/test_init.py @@ -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) diff --git a/tests/components/input_datetime/test_reproduce_state.py b/tests/components/input_datetime/test_reproduce_state.py index 87d737dfb4f..f2d9dd4d445 100644 --- a/tests/components/input_datetime/test_reproduce_state.py +++ b/tests/components/input_datetime/test_reproduce_state.py @@ -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"), ], )