1476 lines
51 KiB
Python
1476 lines
51 KiB
Python
"""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
|