"""The tests for the Template light platform.""" import logging import pytest import homeassistant.components.light as light from homeassistant.components.light import ( ATTR_BRIGHTNESS, ATTR_COLOR_TEMP, ATTR_EFFECT, ATTR_HS_COLOR, ATTR_TRANSITION, ATTR_WHITE_VALUE, SUPPORT_TRANSITION, ) from homeassistant.const import ( ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, STATE_OFF, STATE_ON, STATE_UNAVAILABLE, ) _LOGGER = logging.getLogger(__name__) # Represent for light's availability _STATE_AVAILABILITY_BOOLEAN = "availability_boolean.state" @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{states.test['big.fat...']}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_template_state_invalid(hass, start_ha): """Test template state with render error.""" assert hass.states.get("light.test_template_light").state == STATE_OFF @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{ states.light.test_state.state }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_template_state_text(hass, start_ha): """Test the state text of a template.""" for set_state in [STATE_ON, STATE_OFF]: hass.states.async_set("light.test_state", set_state) await hass.async_block_till_done() assert hass.states.get("light.test_template_light").state == set_state @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config_addon,expected_state", [ ({"replace1": '"{{ 1 == 1 }}"'}, STATE_ON), ({"replace1": '"{{ 1 == 2 }}"'}, STATE_OFF), ], ) @pytest.mark.parametrize( "config", [ """{ "light": { "platform": "template", "lights": { "test_template_light": { "value_template": replace1, "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state" }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state" }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}" } } } } } }""", ], ) async def test_templatex_state_boolean(hass, expected_state, start_ha): """Test the setting of the state with boolean on.""" assert hass.states.get("light.test_template_light").state == expected_state @pytest.mark.parametrize("count,domain", [(0, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{%- if false -%}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, { "light": { "platform": "template", "lights": { "bad name here": { "value_template": "{{ 1== 1}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, { "light": { "platform": "template", "switches": {"test_template_light": "Invalid"}, } }, ], ) async def test_template_syntax_error(hass, start_ha): """Test templating syntax error.""" assert hass.states.async_all("light") == [] SET_VAL1 = '"value_template": "{{ 1== 1}}",' SET_VAL2 = '"turn_on": {"service": "light.turn_on","entity_id": "light.test_state"},' SET_VAL3 = '"turn_off": {"service": "light.turn_off","entity_id": "light.test_state"},' @pytest.mark.parametrize("domain", [light.DOMAIN]) @pytest.mark.parametrize( "config_addon, count", [ ({"replace2": f"{SET_VAL2}{SET_VAL3}"}, 1), ({"replace2": f"{SET_VAL1}{SET_VAL2}"}, 0), ({"replace2": f"{SET_VAL2}{SET_VAL3}"}, 1), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template", "lights": { "light_one": { replace2 "set_level": {"service": "light.turn_on", "data_template": {"entity_id": "light.test_state","brightness": "{{brightness}}" }}}}}}""" ], ) async def test_missing_key(hass, count, start_ha): """Test missing template.""" if count: assert hass.states.async_all("light") != [] else: assert hass.states.async_all("light") == [] @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{states.light.test_state.state}}", "turn_on": {"service": "test.automation"}, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_on_action(hass, start_ha, calls): """Test on action.""" hass.states.async_set("light.test_state", STATE_OFF) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.state == STATE_OFF await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light"}, blocking=True, ) assert len(calls) == 1 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{states.light.test_state.state}}", "turn_on": { "service": "test.automation", "data_template": { "transition": "{{transition}}", }, }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "supports_transition_template": "{{true}}", "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", "transition": "{{transition}}", }, }, } }, } }, ], ) async def test_on_action_with_transition(hass, start_ha, calls): """Test on action with transition.""" hass.states.async_set("light.test_state", STATE_OFF) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.state == STATE_OFF await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_TRANSITION: 5}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["transition"] == 5 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "turn_on": {"service": "test.automation"}, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_on_action_optimistic(hass, start_ha, calls): """Test on action with optimistic state.""" hass.states.async_set("light.test_state", STATE_OFF) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.state == STATE_OFF await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light"}, blocking=True, ) state = hass.states.get("light.test_template_light") assert len(calls) == 1 assert state.state == STATE_ON @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{states.light.test_state.state}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "test.automation", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_off_action(hass, start_ha, calls): """Test off action.""" hass.states.async_set("light.test_state", STATE_ON) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.state == STATE_ON await hass.services.async_call( light.DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: "light.test_template_light"}, blocking=True, ) assert len(calls) == 1 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{states.light.test_state.state}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "test.automation", "data_template": { "transition": "{{transition}}", }, }, "supports_transition_template": "{{true}}", "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", "transition": "{{transition}}", }, }, } }, } }, ], ) async def test_off_action_with_transition(hass, start_ha, calls): """Test off action with transition.""" hass.states.async_set("light.test_state", STATE_ON) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.state == STATE_ON await hass.services.async_call( light.DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_TRANSITION: 2}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["transition"] == 2 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": {"service": "test.automation"}, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_off_action_optimistic(hass, start_ha, calls): """Test off action with optimistic state.""" state = hass.states.get("light.test_template_light") assert state.state == STATE_OFF await hass.services.async_call( light.DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: "light.test_template_light"}, blocking=True, ) assert len(calls) == 1 state = hass.states.get("light.test_template_light") assert state.state == STATE_OFF @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{1 == 1}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_white_value": { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "white_value": "{{white_value}}", }, }, } }, } }, ], ) async def test_white_value_action_no_template(hass, start_ha, calls): """Test setting white value with optimistic template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("white_value") is None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_WHITE_VALUE: 124}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["white_value"] == 124 state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("white_value") == 124 @pytest.mark.parametrize( "expected_white_value,config_addon", [ (255, {"replace3": "{{255}}"}), (None, {"replace3": "{{256}}"}), (None, {"replace3": "{{x - 12}}"}), (None, {"replace3": "{{ none }}"}), (None, {"replace3": ""}), ], ) @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ """{ "light": {"platform": "template","lights": { "test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_white_value": {"service": "light.turn_on", "data_template": {"entity_id": "light.test_state", "white_value": "{{white_value}}"}}, "white_value_template": "replace3" }}}}""", ], ) async def test_white_value_template(hass, expected_white_value, start_ha): """Test the template for the white value.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("white_value") == expected_white_value @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{1 == 1}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_level_action_no_template(hass, start_ha, calls): """Test setting brightness with optimistic template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("brightness") is None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_BRIGHTNESS: 124}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["brightness"] == 124 state = hass.states.get("light.test_template_light") _LOGGER.info(str(state.attributes)) assert state is not None assert state.attributes.get("brightness") == 124 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_level,config_addon", [ (255, {"replace4": '"{{255}}"'}), (None, {"replace4": '"{{256}}"'}), (None, {"replace4": '"{{x - 12}}"'}), (None, {"replace4": '"{{ none }}"'}), (None, {"replace4": '""'}), (None, {"replace4": "\"{{ state_attr('light.nolight', 'brightness') }}\""}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template", "lights": { "test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_level": {"service": "light.turn_on","data_template": { "entity_id": "light.test_state","brightness": "{{brightness}}"}}, "level_template": replace4 }}}}""", ], ) async def test_level_template(hass, expected_level, start_ha): """Test the template for the level.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("brightness") == expected_level @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_temp,config_addon", [ (500, {"replace5": '"{{500}}"'}), (None, {"replace5": '"{{501}}"'}), (None, {"replace5": '"{{x - 12}}"'}), (None, {"replace5": '"None"'}), (None, {"replace5": '"{{ none }}"'}), (None, {"replace5": '""'}), ], ) @pytest.mark.parametrize( "config", [ """{ "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state" }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state" }, "set_temperature": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "color_temp": "{{color_temp}}" } }, "temperature_template": replace5 } } } }""" ], ) async def test_temperature_template(hass, expected_temp, start_ha): """Test the template for the temperature.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("color_temp") == expected_temp @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{1 == 1}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_temperature": { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "color_temp": "{{color_temp}}", }, }, } }, } }, ], ) async def test_temperature_action_no_template(hass, start_ha, calls): """Test setting temperature with optimistic template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("color_template") is None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_COLOR_TEMP: 345}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["color_temp"] == 345 state = hass.states.get("light.test_template_light") _LOGGER.info(str(state.attributes)) assert state is not None assert state.attributes.get("color_temp") == 345 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "friendly_name": "Template light", "value_template": "{{ 1 == 1 }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_friendly_name(hass, start_ha): """Test the accessibility of the friendly_name attribute.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("friendly_name") == "Template light" @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "friendly_name": "Template light", "value_template": "{{ 1 == 1 }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, "icon_template": "{% if states.light.test_state.state %}" "mdi:check" "{% endif %}", } }, } }, ], ) async def test_icon_template(hass, start_ha): """Test icon template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("icon") == "" state = hass.states.async_set("light.test_state", STATE_ON) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.attributes["icon"] == "mdi:check" @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "friendly_name": "Template light", "value_template": "{{ 1 == 1 }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, "entity_picture_template": "{% if states.light.test_state.state %}" "/local/light.png" "{% endif %}", } }, } }, ], ) async def test_entity_picture_template(hass, start_ha): """Test entity_picture template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("entity_picture") == "" state = hass.states.async_set("light.test_state", STATE_ON) await hass.async_block_till_done() state = hass.states.get("light.test_template_light") assert state.attributes["entity_picture"] == "/local/light.png" @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{1 == 1}}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_color": [ { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "h": "{{h}}", "s": "{{s}}", }, }, { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "s": "{{s}}", "h": "{{h}}", }, }, ], } }, } }, ], ) async def test_color_action_no_template(hass, start_ha, calls): """Test setting color with optimistic template.""" state = hass.states.get("light.test_template_light") assert state.attributes.get("hs_color") is None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_HS_COLOR: (40, 50)}, blocking=True, ) assert len(calls) == 2 assert calls[0].data["h"] == 40 assert calls[0].data["s"] == 50 assert calls[1].data["h"] == 40 assert calls[1].data["s"] == 50 state = hass.states.get("light.test_template_light") _LOGGER.info(str(state.attributes)) assert state is not None assert calls[0].data["h"] == 40 assert calls[0].data["s"] == 50 assert calls[1].data["h"] == 40 assert calls[1].data["s"] == 50 @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_hs,config_addon", [ ((360, 100), {"replace6": '"{{(360, 100)}}"'}), ((359.9, 99.9), {"replace6": '"{{(359.9, 99.9)}}"'}), (None, {"replace6": '"{{(361, 100)}}"'}), (None, {"replace6": '"{{(360, 101)}}"'}), (None, {"replace6": '"{{x - 12}}"'}), (None, {"replace6": '""'}), (None, {"replace6": '"{{ none }}"'}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_color": [{"service": "input_number.set_value", "data_template": {"entity_id": "input_number.h","color_temp": "{{h}}" }}], "color_template": replace6 }}}}""" ], ) async def test_color_template(hass, expected_hs, start_ha): """Test the template for the color.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("hs_color") == expected_hs @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{true}}", "turn_on": {"service": "test.automation"}, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, "set_effect": { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "effect": "{{effect}}", }, }, "effect_list_template": "{{ ['Disco', 'Police'] }}", "effect_template": "{{ 'Disco' }}", } }, } }, ], ) async def test_effect_action_valid_effect(hass, start_ha, calls): """Test setting valid effect with template.""" state = hass.states.get("light.test_template_light") assert state is not None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_EFFECT: "Disco"}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["effect"] == "Disco" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("effect") == "Disco" @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "value_template": "{{true}}", "turn_on": {"service": "test.automation"}, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, "set_effect": { "service": "test.automation", "data_template": { "entity_id": "test.test_state", "effect": "{{effect}}", }, }, "effect_list_template": "{{ ['Disco', 'Police'] }}", "effect_template": "{{ None }}", } }, } }, ], ) async def test_effect_action_invalid_effect(hass, start_ha, calls): """Test setting invalid effect with template.""" state = hass.states.get("light.test_template_light") assert state is not None await hass.services.async_call( light.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: "light.test_template_light", ATTR_EFFECT: "RGB"}, blocking=True, ) assert len(calls) == 1 assert calls[0].data["effect"] == "RGB" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("effect") is None @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_effect_list,config_addon", [ ( ["Strobe color", "Police", "Christmas", "RGB", "Random Loop"], { "replace7": "\"{{ ['Strobe color', 'Police', 'Christmas', 'RGB', 'Random Loop'] }}\"" }, ), ( ["Police", "RGB", "Random Loop"], {"replace7": "\"{{ ['Police', 'RGB', 'Random Loop'] }}\""}, ), (None, {"replace7": '"{{ [] }}"'}), (None, {"replace7": "\"{{ '[]' }}\""}), (None, {"replace7": '"{{ 124 }}"'}), (None, {"replace7": "\"{{ '124' }}\""}), (None, {"replace7": '"{{ none }}"'}), (None, {"replace7": '""'}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_effect": {"service": "test.automation", "data_template": {"entity_id": "test.test_state","effect": "{{effect}}"}}, "effect_template": "{{ None }}", "effect_list_template": replace7 }}}}""", ], ) async def test_effect_list_template(hass, expected_effect_list, start_ha): """Test the template for the effect list.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("effect_list") == expected_effect_list @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_effect,config_addon", [ (None, {"replace8": '"Disco"'}), (None, {"replace8": '"None"'}), (None, {"replace8": '"{{ None }}"'}), ("Police", {"replace8": '"Police"'}), ("Strobe color", {"replace8": "\"{{ 'Strobe color' }}\""}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_effect": {"service": "test.automation","data_template": { "entity_id": "test.test_state","effect": "{{effect}}"}}, "effect_list_template": "{{ ['Strobe color', 'Police', 'Christmas', 'RGB', 'Random Loop'] }}", "effect_template": replace8 }}}}""", ], ) async def test_effect_template(hass, expected_effect, start_ha): """Test the template for the effect.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("effect") == expected_effect @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_min_mireds,config_addon", [ (118, {"replace9": '"{{118}}"'}), (153, {"replace9": '"{{x - 12}}"'}), (153, {"replace9": '"None"'}), (153, {"replace9": '"{{ none }}"'}), (153, {"replace9": '""'}), (153, {"replace9": "\"{{ 'a' }}\""}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_temperature": {"service": "light.turn_on","data_template": { "entity_id": "light.test_state","color_temp": "{{color_temp}}"}}, "temperature_template": "{{200}}", "min_mireds_template": replace9 }}}}""", ], ) async def test_min_mireds_template(hass, expected_min_mireds, start_ha): """Test the template for the min mireds.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("min_mireds") == expected_min_mireds @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_max_mireds,config_addon", [ (488, {"template1": '"{{488}}"'}), (500, {"template1": '"{{x - 12}}"'}), (500, {"template1": '"None"'}), (500, {"template1": '"{{ none }}"'}), (500, {"template1": '""'}), (500, {"template1": "\"{{ 'a' }}\""}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_temperature": {"service": "light.turn_on","data_template": { "entity_id": "light.test_state","color_temp": "{{color_temp}}"}}, "temperature_template": "{{200}}", "max_mireds_template": template1 }}}}""", ], ) async def test_max_mireds_template(hass, expected_max_mireds, start_ha): """Test the template for the max mireds.""" state = hass.states.get("light.test_template_light") assert state is not None assert state.attributes.get("max_mireds") == expected_max_mireds @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "expected_supports_transition,config_addon", [ (True, {"template2": '"{{true}}"'}), (True, {"template2": '"{{1 == 1}}"'}), (False, {"template2": '"{{false}}"'}), (False, {"template2": '"{{ none }}"'}), (False, {"template2": '""'}), (False, {"template2": '"None"'}), ], ) @pytest.mark.parametrize( "config", [ """{"light": {"platform": "template","lights": {"test_template_light": { "value_template": "{{ 1 == 1 }}", "turn_on": {"service": "light.turn_on","entity_id": "light.test_state"}, "turn_off": {"service": "light.turn_off","entity_id": "light.test_state"}, "set_temperature": {"service": "light.turn_on","data_template": { "entity_id": "light.test_state","color_temp": "{{color_temp}}"}}, "supports_transition_template": template2 }}}}""", ], ) async def test_supports_transition_template( hass, expected_supports_transition, start_ha ): """Test the template for the supports transition.""" state = hass.states.get("light.test_template_light") expected_value = 1 if expected_supports_transition is True: expected_value = 0 assert state is not None assert ( int(state.attributes.get("supported_features")) & SUPPORT_TRANSITION ) != expected_value @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "availability_template": "{{ is_state('availability_boolean.state', 'on') }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_available_template_with_entities(hass, start_ha): """Test availability templates with values from other entities.""" # When template returns true.. hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, STATE_ON) await hass.async_block_till_done() # Device State should not be unavailable assert hass.states.get("light.test_template_light").state != STATE_UNAVAILABLE # When Availability template returns false hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, STATE_OFF) await hass.async_block_till_done() # device state should be unavailable assert hass.states.get("light.test_template_light").state == STATE_UNAVAILABLE @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light": { "availability_template": "{{ x - 12 }}", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, "set_level": { "service": "light.turn_on", "data_template": { "entity_id": "light.test_state", "brightness": "{{brightness}}", }, }, } }, } }, ], ) async def test_invalid_availability_template_keeps_component_available( hass, start_ha, caplog_setup_text ): """Test that an invalid availability keeps the device available.""" assert hass.states.get("light.test_template_light").state != STATE_UNAVAILABLE assert ("UndefinedError: 'x' is undefined") in caplog_setup_text @pytest.mark.parametrize("count,domain", [(1, light.DOMAIN)]) @pytest.mark.parametrize( "config", [ { "light": { "platform": "template", "lights": { "test_template_light_01": { "unique_id": "not-so-unique-anymore", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, }, "test_template_light_02": { "unique_id": "not-so-unique-anymore", "turn_on": { "service": "light.turn_on", "entity_id": "light.test_state", }, "turn_off": { "service": "light.turn_off", "entity_id": "light.test_state", }, }, }, } }, ], ) async def test_unique_id(hass, start_ha): """Test unique_id option only creates one light per id.""" assert len(hass.states.async_all("light")) == 1