"""Tests for the Input slider component.""" # pylint: disable=protected-access import datetime import pytest import voluptuous as vol from homeassistant.components.input_datetime import ( ATTR_DATE, ATTR_DATETIME, ATTR_EDITABLE, ATTR_TIME, CONF_HAS_DATE, CONF_HAS_TIME, CONF_ID, CONF_INITIAL, CONF_NAME, DEFAULT_TIME, DOMAIN, SERVICE_RELOAD, SERVICE_SET_DATETIME, ) from homeassistant.const import ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME, ATTR_NAME from homeassistant.core import Context, CoreState, State from homeassistant.exceptions import Unauthorized from homeassistant.helpers import entity_registry from homeassistant.setup import async_setup_component from tests.async_mock import patch from tests.common import mock_restore_cache INITIAL_DATE = "2020-01-10" INITIAL_TIME = "23:45:56" INITIAL_DATETIME = f"{INITIAL_DATE} {INITIAL_TIME}" @pytest.fixture def storage_setup(hass, hass_storage): """Storage setup.""" async def _storage(items=None, config=None): if items is None: hass_storage[DOMAIN] = { "key": DOMAIN, "version": 1, "data": { "items": [ { CONF_ID: "from_storage", CONF_NAME: "datetime from storage", CONF_INITIAL: INITIAL_DATETIME, CONF_HAS_DATE: True, CONF_HAS_TIME: True, } ] }, } else: hass_storage[DOMAIN] = { "key": DOMAIN, "version": 1, "data": {"items": items}, } if config is None: config = {DOMAIN: {}} return await async_setup_component(hass, DOMAIN, config) return _storage 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, { ATTR_ENTITY_ID: entity_id, ATTR_DATE: dt_value.date(), ATTR_TIME: dt_value.time(), }, blocking=True, ) 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, {ATTR_ENTITY_ID: entity_id, ATTR_DATETIME: dt_value}, blocking=True, ) async def test_invalid_configs(hass): """Test config.""" invalid_configs = [ 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}) async def test_set_datetime(hass): """Test set_datetime method using date & time.""" await async_setup_component( hass, DOMAIN, {DOMAIN: {"test_datetime": {"has_time": True, "has_date": True}}} ) entity_id = "input_datetime.test_datetime" dt_obj = datetime.datetime(2017, 9, 7, 19, 46, 30) 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.attributes["has_time"] assert state.attributes["has_date"] assert state.attributes["year"] == 2017 assert state.attributes["month"] == 9 assert state.attributes["day"] == 7 assert state.attributes["hour"] == 19 assert state.attributes["minute"] == 46 assert state.attributes["second"] == 30 assert state.attributes["timestamp"] == dt_obj.timestamp() async def test_set_datetime_2(hass): """Test set_datetime method using datetime.""" await async_setup_component( hass, DOMAIN, {DOMAIN: {"test_datetime": {"has_time": True, "has_date": True}}} ) entity_id = "input_datetime.test_datetime" dt_obj = datetime.datetime(2017, 9, 7, 19, 46, 30) await async_set_datetime(hass, entity_id, dt_obj) state = hass.states.get(entity_id) assert state.state == str(dt_obj) assert state.attributes["has_time"] assert state.attributes["has_date"] assert state.attributes["year"] == 2017 assert state.attributes["month"] == 9 assert state.attributes["day"] == 7 assert state.attributes["hour"] == 19 assert state.attributes["minute"] == 46 assert state.attributes["second"] == 30 assert state.attributes["timestamp"] == dt_obj.timestamp() async def test_set_datetime_time(hass): """Test set_datetime method with only time.""" await async_setup_component( hass, DOMAIN, {DOMAIN: {"test_time": {"has_time": True, "has_date": False}}} ) 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.attributes["has_time"] assert not state.attributes["has_date"] assert state.attributes["timestamp"] == (19 * 3600) + (46 * 60) + 30 async def test_set_invalid(hass): """Test set_datetime method with only time.""" initial = "2017-01-01" await async_setup_component( hass, DOMAIN, { DOMAIN: { "test_date": {"has_time": False, "has_date": True, "initial": initial} } }, ) entity_id = "input_datetime.test_date" dt_obj = datetime.datetime(2017, 9, 7, 19, 46) time_portion = dt_obj.time() with pytest.raises(vol.Invalid): await hass.services.async_call( "input_datetime", "set_datetime", {"entity_id": "test_date", "time": time_portion}, ) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state.state == initial async def test_set_invalid_2(hass): """Test set_datetime method with date and datetime.""" initial = "2017-01-01" await async_setup_component( hass, DOMAIN, { DOMAIN: { "test_date": {"has_time": False, "has_date": True, "initial": initial} } }, ) entity_id = "input_datetime.test_date" dt_obj = datetime.datetime(2017, 9, 7, 19, 46) time_portion = dt_obj.time() with pytest.raises(vol.Invalid): await hass.services.async_call( "input_datetime", "set_datetime", {"entity_id": "test_date", "time": time_portion, "datetime": dt_obj}, ) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state.state == initial async def test_set_datetime_date(hass): """Test set_datetime method with only date.""" await async_setup_component( hass, DOMAIN, {DOMAIN: {"test_date": {"has_time": False, "has_date": True}}} ) entity_id = "input_datetime.test_date" dt_obj = datetime.datetime(2017, 9, 7, 19, 46) date_portion = dt_obj.date() await async_set_date_and_time(hass, entity_id, dt_obj) state = hass.states.get(entity_id) assert state.state == str(date_portion) assert not state.attributes["has_time"] assert state.attributes["has_date"] date_dt_obj = datetime.datetime(2017, 9, 7) assert state.attributes["timestamp"] == date_dt_obj.timestamp() async def test_restore_state(hass): """Ensure states are restored on startup.""" mock_restore_cache( hass, ( State("input_datetime.test_time", "19:46:00"), State("input_datetime.test_date", "2017-09-07"), State("input_datetime.test_datetime", "2017-09-07 19:46:00"), State("input_datetime.test_bogus_data", "this is not a date"), State("input_datetime.test_was_time", "19:46:00"), State("input_datetime.test_was_date", "2017-09-07"), ), ) hass.state = CoreState.starting initial = datetime.datetime(2017, 1, 1, 23, 42) default = datetime.datetime(1970, 1, 1, 0, 0) await async_setup_component( hass, DOMAIN, { DOMAIN: { "test_time": {"has_time": True, "has_date": False}, "test_date": {"has_time": False, "has_date": True}, "test_datetime": {"has_time": True, "has_date": True}, "test_bogus_data": { "has_time": True, "has_date": True, "initial": str(initial), }, "test_was_time": {"has_time": False, "has_date": True}, "test_was_date": {"has_time": True, "has_date": False}, } }, ) 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()) state_date = hass.states.get("input_datetime.test_date") assert state_date.state == str(dt_obj.date()) state_datetime = hass.states.get("input_datetime.test_datetime") assert state_datetime.state == str(dt_obj) state_bogus = hass.states.get("input_datetime.test_bogus_data") assert state_bogus.state == str(initial) state_was_time = hass.states.get("input_datetime.test_was_time") assert state_was_time.state == str(default.date()) state_was_date = hass.states.get("input_datetime.test_was_date") assert state_was_date.state == str(default.time()) async def test_default_value(hass): """Test default value if none has been set via initial or restore state.""" await async_setup_component( hass, DOMAIN, { DOMAIN: { "test_time": {"has_time": True, "has_date": False}, "test_date": {"has_time": False, "has_date": True}, "test_datetime": {"has_time": True, "has_date": True}, } }, ) 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.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.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.attributes.get("timestamp") is not None async def test_input_datetime_context(hass, hass_admin_user): """Test that input_datetime context works.""" assert await async_setup_component( hass, "input_datetime", {"input_datetime": {"only_date": {"has_date": True}}} ) state = hass.states.get("input_datetime.only_date") assert state is not None await hass.services.async_call( "input_datetime", "set_datetime", {"entity_id": state.entity_id, "date": "2018-01-02"}, True, Context(user_id=hass_admin_user.id), ) state2 = hass.states.get("input_datetime.only_date") assert state2 is not None assert state.state != state2.state assert state2.context.user_id == hass_admin_user.id async def test_reload(hass, hass_admin_user, hass_read_only_user): """Test reload service.""" count_start = len(hass.states.async_entity_ids()) ent_reg = await entity_registry.async_get_registry(hass) assert await async_setup_component( hass, DOMAIN, { DOMAIN: { "dt1": {"has_time": False, "has_date": True, "initial": "2019-1-1"}, "dt3": {CONF_HAS_TIME: True, CONF_HAS_DATE: True}, } }, ) assert count_start + 2 == len(hass.states.async_entity_ids()) state_1 = hass.states.get("input_datetime.dt1") state_2 = hass.states.get("input_datetime.dt2") state_3 = hass.states.get("input_datetime.dt3") dt_obj = datetime.datetime(2019, 1, 1, 0, 0) 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 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" with patch( "homeassistant.config.load_yaml_config_file", autospec=True, return_value={ DOMAIN: { "dt1": {"has_time": True, "has_date": False, "initial": "23:32"}, "dt2": {"has_time": True, "has_date": True}, } }, ): with pytest.raises(Unauthorized): await hass.services.async_call( DOMAIN, SERVICE_RELOAD, blocking=True, context=Context(user_id=hass_read_only_user.id), ) await hass.services.async_call( DOMAIN, SERVICE_RELOAD, blocking=True, context=Context(user_id=hass_admin_user.id), ) await hass.async_block_till_done() assert count_start + 2 == len(hass.states.async_entity_ids()) state_1 = hass.states.get("input_datetime.dt1") state_2 = hass.states.get("input_datetime.dt2") state_3 = hass.states.get("input_datetime.dt3") 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 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" assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, "dt3") is None async def test_load_from_storage(hass, storage_setup): """Test set up from storage.""" assert await storage_setup() state = hass.states.get(f"{DOMAIN}.datetime_from_storage") assert state.state == INITIAL_DATETIME assert state.attributes.get(ATTR_EDITABLE) async def test_editable_state_attribute(hass, storage_setup): """Test editable attribute.""" assert await storage_setup( config={ DOMAIN: { "from_yaml": { CONF_HAS_DATE: True, CONF_HAS_TIME: True, CONF_NAME: "yaml datetime", CONF_INITIAL: "2001-01-02 12:34:56", } } } ) state = hass.states.get(f"{DOMAIN}.datetime_from_storage") assert state.state == INITIAL_DATETIME assert state.attributes.get(ATTR_EDITABLE) state = hass.states.get(f"{DOMAIN}.from_yaml") assert state.state == "2001-01-02 12:34:56" assert not state.attributes[ATTR_EDITABLE] async def test_ws_list(hass, hass_ws_client, storage_setup): """Test listing via WS.""" assert await storage_setup(config={DOMAIN: {"from_yaml": {CONF_HAS_DATE: True}}}) client = await hass_ws_client(hass) await client.send_json({"id": 6, "type": f"{DOMAIN}/list"}) resp = await client.receive_json() assert resp["success"] storage_ent = "from_storage" yaml_ent = "from_yaml" result = {item["id"]: item for item in resp["result"]} assert len(result) == 1 assert storage_ent in result assert yaml_ent not in result assert result[storage_ent][ATTR_NAME] == "datetime from storage" async def test_ws_delete(hass, hass_ws_client, storage_setup): """Test WS delete cleans up entity registry.""" assert await storage_setup() input_id = "from_storage" input_entity_id = f"{DOMAIN}.datetime_from_storage" ent_reg = await entity_registry.async_get_registry(hass) state = hass.states.get(input_entity_id) assert state is not None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) == input_entity_id client = await hass_ws_client(hass) await client.send_json( {"id": 6, "type": f"{DOMAIN}/delete", f"{DOMAIN}_id": f"{input_id}"} ) resp = await client.receive_json() assert resp["success"] state = hass.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None async def test_update(hass, hass_ws_client, storage_setup): """Test updating min/max updates the state.""" assert await storage_setup() input_id = "from_storage" input_entity_id = f"{DOMAIN}.datetime_from_storage" ent_reg = await entity_registry.async_get_registry(hass) state = hass.states.get(input_entity_id) assert state.attributes[ATTR_FRIENDLY_NAME] == "datetime from storage" assert state.state == INITIAL_DATETIME assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) == input_entity_id client = await hass_ws_client(hass) await client.send_json( { "id": 6, "type": f"{DOMAIN}/update", f"{DOMAIN}_id": f"{input_id}", ATTR_NAME: "even newer name", CONF_HAS_DATE: False, } ) resp = await client.receive_json() assert resp["success"] state = hass.states.get(input_entity_id) assert state.state == INITIAL_TIME assert state.attributes[ATTR_FRIENDLY_NAME] == "even newer name" async def test_ws_create(hass, hass_ws_client, storage_setup): """Test create WS.""" assert await storage_setup(items=[]) input_id = "new_datetime" input_entity_id = f"{DOMAIN}.{input_id}" ent_reg = await entity_registry.async_get_registry(hass) state = hass.states.get(input_entity_id) assert state is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, input_id) is None client = await hass_ws_client(hass) await client.send_json( { "id": 6, "type": f"{DOMAIN}/create", CONF_NAME: "New DateTime", CONF_INITIAL: "1991-01-02 01:02:03", CONF_HAS_DATE: True, CONF_HAS_TIME: True, } ) resp = await client.receive_json() assert resp["success"] state = hass.states.get(input_entity_id) assert state.state == "1991-01-02 01:02:03" assert state.attributes[ATTR_FRIENDLY_NAME] == "New DateTime" assert state.attributes[ATTR_EDITABLE] async def test_setup_no_config(hass, hass_admin_user): """Test component setup with no config.""" count_start = len(hass.states.async_entity_ids()) assert await async_setup_component(hass, DOMAIN, {}) with patch( "homeassistant.config.load_yaml_config_file", autospec=True, return_value={} ): await hass.services.async_call( DOMAIN, SERVICE_RELOAD, blocking=True, context=Context(user_id=hass_admin_user.id), ) await hass.async_block_till_done() assert count_start == len(hass.states.async_entity_ids())