core/tests/components/template/test_light.py

"""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