jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-21 04:07:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use pytest.mark.usefixtures for start_ha in template tests (#126805)

Browse Source
This commit is contained in:
epenet 2024-09-26 14:00:52 +02:00 committed by GitHub
parent c1b24e6ba2
commit 5fb9537d6d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 279 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tests/components/template/conftest.py
View File

@ -3,6 +3,7 @@
import pytest import pytest
from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.helpers.typing import ConfigType
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from tests.common import assert_setup_component, async_mock_service from tests.common import assert_setup_component, async_mock_service
@ -16,8 +17,8 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]:
@pytest.fixture @pytest.fixture
async def start_ha( async def start_ha(
hass: HomeAssistant, count, domain, config, caplog: pytest.LogCaptureFixture hass: HomeAssistant, count: int, domain: str, config: ConfigType
): ) -> None:
"""Do setup of integration.""" """Do setup of integration."""
with assert_setup_component(count, domain): with assert_setup_component(count, domain):
assert await async_setup_component( assert await async_setup_component(

23
tests/components/template/test_alarm_control_panel.py
View File

@ -107,7 +107,8 @@ TEMPLATE_ALARM_CONFIG = {
}, },
], ],
) )
async def test_template_state_text(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state_text(hass: HomeAssistant) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
for set_state in ( for set_state in (
@ -179,7 +180,8 @@ async def test_setup_config_entry(
}, },
], ],
) )
async def test_optimistic_states(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_optimistic_states(hass: HomeAssistant) -> None:
"""Test the optimistic state.""" """Test the optimistic state."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
@ -269,8 +271,9 @@ async def test_optimistic_states(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_syntax_error( async def test_template_syntax_error(
hass: HomeAssistant, msg, start_ha, caplog_setup_text hass: HomeAssistant, msg, caplog_setup_text
) -> None: ) -> None:
"""Test templating syntax error.""" """Test templating syntax error."""
assert len(hass.states.async_all("alarm_control_panel")) == 0 assert len(hass.states.async_all("alarm_control_panel")) == 0
@ -295,7 +298,8 @@ async def test_template_syntax_error(
}, },
], ],
) )
async def test_name(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_name(hass: HomeAssistant) -> None:
"""Test the accessibility of the name attribute.""" """Test the accessibility of the name attribute."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
assert state is not None assert state is not None
@ -326,8 +330,9 @@ async def test_name(hass: HomeAssistant, start_ha) -> None:
"alarm_trigger", "alarm_trigger",
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_actions( async def test_actions(
hass: HomeAssistant, service, start_ha, call_service_events: list[Event] hass: HomeAssistant, service, call_service_events: list[Event]
) -> None: ) -> None:
"""Test alarm actions.""" """Test alarm actions."""
await hass.services.async_call( await hass.services.async_call(
@ -363,7 +368,8 @@ async def test_actions(
}, },
], ],
) )
async def test_unique_id(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_unique_id(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one alarm control panel per id.""" """Test unique_id option only creates one alarm control panel per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -435,9 +441,8 @@ async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
async def test_code_config( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, code_format, code_arm_required, start_ha async def test_code_config(hass: HomeAssistant, code_format, code_arm_required) -> None:
) -> None:
"""Test configuration options related to alarm code.""" """Test configuration options related to alarm code."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
assert state.attributes.get("code_format") == code_format assert state.attributes.get("code_format") == code_format

62
tests/components/template/test_binary_sensor.py
View File

@ -72,9 +72,8 @@ OFF = "off"
), ),
], ],
) )
async def test_setup_minimal( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_id, name, attributes async def test_setup_minimal(hass: HomeAssistant, entity_id, name, attributes) -> None:
) -> None:
"""Test the setup.""" """Test the setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state is not None assert state is not None
@ -118,7 +117,8 @@ async def test_setup_minimal(
), ),
], ],
) )
async def test_setup(hass: HomeAssistant, start_ha, entity_id) -> None: @pytest.mark.usefixtures("start_ha")
async def test_setup(hass: HomeAssistant, entity_id) -> None:
"""Test the setup.""" """Test the setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state is not None assert state is not None
@ -234,7 +234,8 @@ async def test_setup_config_entry(
), ),
], ],
) )
async def test_setup_invalid_sensors(hass: HomeAssistant, count, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_setup_invalid_sensors(hass: HomeAssistant, count) -> None:
"""Test setup with no sensors.""" """Test setup with no sensors."""
assert len(hass.states.async_entity_ids("binary_sensor")) == count assert len(hass.states.async_entity_ids("binary_sensor")) == count
@ -280,7 +281,8 @@ async def test_setup_invalid_sensors(hass: HomeAssistant, count, start_ha) -> No
), ),
], ],
) )
async def test_icon_template(hass: HomeAssistant, start_ha, entity_id) -> None: @pytest.mark.usefixtures("start_ha")
async def test_icon_template(hass: HomeAssistant, entity_id) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("icon") == "" assert state.attributes.get("icon") == ""
@ -332,9 +334,8 @@ async def test_icon_template(hass: HomeAssistant, start_ha, entity_id) -> None:
), ),
], ],
) )
async def test_entity_picture_template( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_id async def test_entity_picture_template(hass: HomeAssistant, entity_id) -> None:
) -> None:
"""Test entity_picture template.""" """Test entity_picture template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("entity_picture") == "" assert state.attributes.get("entity_picture") == ""
@ -382,7 +383,8 @@ async def test_entity_picture_template(
), ),
], ],
) )
async def test_attribute_templates(hass: HomeAssistant, start_ha, entity_id) -> None: @pytest.mark.usefixtures("start_ha")
async def test_attribute_templates(hass: HomeAssistant, entity_id) -> None:
"""Test attribute_templates template.""" """Test attribute_templates template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("test_attribute") == "It ." assert state.attributes.get("test_attribute") == "It ."
@ -426,7 +428,8 @@ async def setup_mock():
}, },
], ],
) )
async def test_match_all(hass: HomeAssistant, setup_mock, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_match_all(hass: HomeAssistant, setup_mock) -> None:
"""Test template that is rerendered on any state lifecycle.""" """Test template that is rerendered on any state lifecycle."""
init_calls = len(setup_mock.mock_calls) init_calls = len(setup_mock.mock_calls)
@ -453,7 +456,8 @@ async def test_match_all(hass: HomeAssistant, setup_mock, start_ha) -> None:
}, },
], ],
) )
async def test_event(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_event(hass: HomeAssistant) -> None:
"""Test the event.""" """Test the event."""
state = hass.states.get("binary_sensor.test") state = hass.states.get("binary_sensor.test")
assert state.state == OFF assert state.state == OFF
@ -563,7 +567,8 @@ async def test_event(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
async def test_template_delay_on_off(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_delay_on_off(hass: HomeAssistant) -> None:
"""Test binary sensor template delay on.""" """Test binary sensor template delay on."""
# Ensure the initial state is not on # Ensure the initial state is not on
assert hass.states.get("binary_sensor.test_on").state != ON assert hass.states.get("binary_sensor.test_on").state != ON
@ -641,8 +646,9 @@ async def test_template_delay_on_off(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_available_without_availability_template( async def test_available_without_availability_template(
hass: HomeAssistant, start_ha, entity_id hass: HomeAssistant, entity_id
) -> None: ) -> None:
"""Ensure availability is true without an availability_template.""" """Ensure availability is true without an availability_template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
@ -690,7 +696,8 @@ async def test_available_without_availability_template(
), ),
], ],
) )
async def test_availability_template(hass: HomeAssistant, start_ha, entity_id) -> None: @pytest.mark.usefixtures("start_ha")
async def test_availability_template(hass: HomeAssistant, entity_id) -> None:
"""Test availability template.""" """Test availability template."""
hass.states.async_set("sensor.test_state", STATE_OFF) hass.states.async_set("sensor.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -725,8 +732,9 @@ async def test_availability_template(hass: HomeAssistant, start_ha, entity_id) -
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_attribute_template( async def test_invalid_attribute_template(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
hass.states.async_set("binary_sensor.test_sensor", "true") hass.states.async_set("binary_sensor.test_sensor", "true")
@ -752,8 +760,9 @@ async def test_invalid_attribute_template(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
@ -858,8 +867,9 @@ async def test_no_update_template_match_all(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_unique_id( async def test_unique_id(
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry hass: HomeAssistant, entity_registry: er.EntityRegistry
) -> None: ) -> None:
"""Test unique_id option only creates one binary sensor per id.""" """Test unique_id option only creates one binary sensor per id."""
assert len(hass.states.async_all()) == 2 assert len(hass.states.async_all()) == 2
@ -893,8 +903,9 @@ async def test_unique_id(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_validation_error( async def test_template_validation_error(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, start_ha hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None: ) -> None:
"""Test binary sensor template delay on.""" """Test binary sensor template delay on."""
caplog.set_level(logging.ERROR) caplog.set_level(logging.ERROR)
@ -957,9 +968,8 @@ async def test_template_validation_error(
), ),
], ],
) )
async def test_availability_icon_picture( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_id async def test_availability_icon_picture(hass: HomeAssistant, entity_id) -> None:
) -> None:
"""Test name, icon and picture templates are rendered at setup.""" """Test name, icon and picture templates are rendered at setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == "unavailable" assert state.state == "unavailable"
@ -1116,8 +1126,9 @@ async def test_restore_state(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_entity( async def test_trigger_entity(
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry hass: HomeAssistant, entity_registry: er.EntityRegistry
) -> None: ) -> None:
"""Test trigger entity works.""" """Test trigger entity works."""
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1186,9 +1197,8 @@ async def test_trigger_entity(
}, },
], ],
) )
async def test_template_with_trigger_templated_delay_on( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha async def test_template_with_trigger_templated_delay_on(hass: HomeAssistant) -> None:
) -> None:
"""Test binary sensor template with template delay on.""" """Test binary sensor template with template delay on."""
state = hass.states.get("binary_sensor.test") state = hass.states.get("binary_sensor.test")
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN

80
tests/components/template/test_cover.py
View File

@ -139,8 +139,9 @@ OPEN_CLOSE_COVER_CONFIG = {
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_state_text( async def test_template_state_text(
hass: HomeAssistant, states, start_ha, caplog: pytest.LogCaptureFixture hass: HomeAssistant, states, caplog: pytest.LogCaptureFixture
) -> None: ) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
@ -202,13 +203,13 @@ async def test_template_state_text(
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_state_text_ignored_if_none_or_empty( async def test_template_state_text_ignored_if_none_or_empty(
hass: HomeAssistant, hass: HomeAssistant,
entity: str, entity: str,
set_state: str, set_state: str,
test_state: str, test_state: str,
attr: dict[str, Any], attr: dict[str, Any],
start_ha,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
) -> None: ) -> None:
"""Test ignoring an empty state text of a template.""" """Test ignoring an empty state text of a template."""
@ -239,7 +240,8 @@ async def test_template_state_text_ignored_if_none_or_empty(
}, },
], ],
) )
async def test_template_state_boolean(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state_boolean(hass: HomeAssistant) -> None:
"""Test the value_template attribute.""" """Test the value_template attribute."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_OPEN assert state.state == STATE_OPEN
@ -264,8 +266,9 @@ async def test_template_state_boolean(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_position( async def test_template_position(
hass: HomeAssistant, start_ha, caplog: pytest.LogCaptureFixture hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None: ) -> None:
"""Test the position_template attribute.""" """Test the position_template attribute."""
hass.states.async_set("cover.test", STATE_OPEN) hass.states.async_set("cover.test", STATE_OPEN)
@ -302,7 +305,8 @@ async def test_template_position(
}, },
], ],
) )
async def test_template_not_optimistic(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_not_optimistic(hass: HomeAssistant) -> None:
"""Test the is_closed attribute.""" """Test the is_closed attribute."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
@ -344,9 +348,8 @@ async def test_template_not_optimistic(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
async def test_template_tilt( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, tilt_position: float | None, start_ha async def test_template_tilt(hass: HomeAssistant, tilt_position: float | None) -> None:
) -> None:
"""Test the tilt_template attribute.""" """Test the tilt_template attribute."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_tilt_position") == tilt_position assert state.attributes.get("current_tilt_position") == tilt_position
@ -388,7 +391,8 @@ async def test_template_tilt(
}, },
], ],
) )
async def test_template_out_of_bounds(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_out_of_bounds(hass: HomeAssistant) -> None:
"""Test template out-of-bounds condition.""" """Test template out-of-bounds condition."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_tilt_position") is None assert state.attributes.get("current_tilt_position") is None
@ -424,8 +428,9 @@ async def test_template_out_of_bounds(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_template_open_or_position( async def test_template_open_or_position(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that at least one of open_cover or set_position is used.""" """Test that at least one of open_cover or set_position is used."""
assert hass.states.async_all("cover") == [] assert hass.states.async_all("cover") == []
@ -449,9 +454,8 @@ async def test_template_open_or_position(
}, },
], ],
) )
async def test_open_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_open_action(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test the open_cover command.""" """Test the open_cover command."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_CLOSED assert state.state == STATE_CLOSED
@ -490,9 +494,8 @@ async def test_open_action(
}, },
], ],
) )
async def test_close_stop_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_close_stop_action(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test the close-cover and stop_cover commands.""" """Test the close-cover and stop_cover commands."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_OPEN assert state.state == STATE_OPEN
@ -521,9 +524,8 @@ async def test_close_stop_action(
{"input_number": {"test": {"min": "0", "max": "100", "initial": "42"}}}, {"input_number": {"test": {"min": "0", "max": "100", "initial": "42"}}},
], ],
) )
async def test_set_position( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_set_position(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test the set_position command.""" """Test the set_position command."""
with assert_setup_component(1, "cover"): with assert_setup_component(1, "cover"):
assert await setup.async_setup_component( assert await setup.async_setup_component(
@ -652,11 +654,11 @@ async def test_set_position(
(SERVICE_CLOSE_COVER_TILT, {ATTR_ENTITY_ID: ENTITY_COVER}, 0), (SERVICE_CLOSE_COVER_TILT, {ATTR_ENTITY_ID: ENTITY_COVER}, 0),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_set_tilt_position( async def test_set_tilt_position(
hass: HomeAssistant, hass: HomeAssistant,
service, service,
attr, attr,
start_ha,
calls: list[ServiceCall], calls: list[ServiceCall],
tilt_position, tilt_position,
) -> None: ) -> None:
@ -691,8 +693,9 @@ async def test_set_tilt_position(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_set_position_optimistic( async def test_set_position_optimistic(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test optimistic position mode.""" """Test optimistic position mode."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
@ -740,8 +743,9 @@ async def test_set_position_optimistic(
}, },
], ],
) )
@pytest.mark.usefixtures("calls", "start_ha")
async def test_set_tilt_position_optimistic( async def test_set_tilt_position_optimistic(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test the optimistic tilt_position mode.""" """Test the optimistic tilt_position mode."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
@ -791,7 +795,8 @@ async def test_set_tilt_position_optimistic(
}, },
], ],
) )
async def test_icon_template(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_icon_template(hass: HomeAssistant) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("icon") == "" assert state.attributes.get("icon") == ""
@ -826,7 +831,8 @@ async def test_icon_template(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_entity_picture_template(hass: HomeAssistant) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("entity_picture") == "" assert state.attributes.get("entity_picture") == ""
@ -859,7 +865,8 @@ async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_availability_template(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_availability_template(hass: HomeAssistant) -> None:
"""Test availability template.""" """Test availability template."""
hass.states.async_set("availability_state.state", STATE_OFF) hass.states.async_set("availability_state.state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -889,9 +896,8 @@ async def test_availability_template(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_availability_without_availability_template( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha async def test_availability_without_availability_template(hass: HomeAssistant) -> None:
) -> None:
"""Test that component is available if there is no.""" """Test that component is available if there is no."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state != STATE_UNAVAILABLE assert state.state != STATE_UNAVAILABLE
@ -915,8 +921,9 @@ async def test_availability_without_availability_template(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("cover.test_template_cover") != STATE_UNAVAILABLE assert hass.states.get("cover.test_template_cover") != STATE_UNAVAILABLE
@ -941,7 +948,8 @@ async def test_invalid_availability_template_keeps_component_available(
}, },
], ],
) )
async def test_device_class(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_device_class(hass: HomeAssistant) -> None:
"""Test device class.""" """Test device class."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("device_class") == "door" assert state.attributes.get("device_class") == "door"
@ -965,7 +973,8 @@ async def test_device_class(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_invalid_device_class(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_invalid_device_class(hass: HomeAssistant) -> None:
"""Test device class.""" """Test device class."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert not state assert not state
@ -994,7 +1003,8 @@ async def test_invalid_device_class(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_unique_id(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_unique_id(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one cover per id.""" """Test unique_id option only creates one cover per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -1019,7 +1029,8 @@ async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_state_gets_lowercased(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_state_gets_lowercased(hass: HomeAssistant) -> None:
"""Test True/False is lowercased.""" """Test True/False is lowercased."""
hass.states.async_set("binary_sensor.garage_door_sensor", "off") hass.states.async_set("binary_sensor.garage_door_sensor", "off")
@ -1065,8 +1076,9 @@ async def test_state_gets_lowercased(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_self_referencing_icon_with_no_template_is_not_a_loop( async def test_self_referencing_icon_with_no_template_is_not_a_loop(
hass: HomeAssistant, start_ha, caplog: pytest.LogCaptureFixture hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None: ) -> None:
"""Test a self referencing icon with no value template is not a loop.""" """Test a self referencing icon with no value template is not a loop."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1

33
tests/components/template/test_fan.py
View File

@ -54,7 +54,8 @@ _DIRECTION_INPUT_SELECT = "input_select.direction"
}, },
], ],
) )
async def test_missing_optional_config(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_missing_optional_config(hass: HomeAssistant) -> None:
"""Test: missing optional template is ok.""" """Test: missing optional template is ok."""
_verify(hass, STATE_ON, None, None, None, None) _verify(hass, STATE_ON, None, None, None, None)
@ -107,7 +108,8 @@ async def test_missing_optional_config(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_wrong_template_config(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_wrong_template_config(hass: HomeAssistant) -> None:
"""Test: missing 'value_template' will fail.""" """Test: missing 'value_template' will fail."""
assert hass.states.async_all("fan") == [] assert hass.states.async_all("fan") == []
@ -149,7 +151,8 @@ async def test_wrong_template_config(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_templates_with_entities(hass: HomeAssistant) -> None:
"""Test tempalates with values from other entities.""" """Test tempalates with values from other entities."""
_verify(hass, STATE_OFF, 0, None, None, None) _verify(hass, STATE_OFF, 0, None, None, None)
@ -229,9 +232,8 @@ async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
async def test_templates_with_entities2( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, entity, tests, start_ha async def test_templates_with_entities2(hass: HomeAssistant, entity, tests) -> None:
) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
for set_percentage, test_percentage, test_type in tests: for set_percentage, test_percentage, test_type in tests:
hass.states.async_set(entity, set_percentage) hass.states.async_set(entity, set_percentage)
@ -262,9 +264,8 @@ async def test_templates_with_entities2(
}, },
], ],
) )
async def test_availability_template_with_entities( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha async def test_availability_template_with_entities(hass: HomeAssistant) -> None:
) -> None:
"""Test availability tempalates with values from other entities.""" """Test availability tempalates with values from other entities."""
for state, test_assert in ((STATE_ON, True), (STATE_OFF, False)): for state, test_assert in ((STATE_ON, True), (STATE_OFF, False)):
hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, state) hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, state)
@ -347,9 +348,8 @@ async def test_availability_template_with_entities(
), ),
], ],
) )
async def test_template_with_unavailable_entities( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, states, start_ha async def test_template_with_unavailable_entities(hass: HomeAssistant, states) -> None:
) -> None:
"""Test unavailability with value_template.""" """Test unavailability with value_template."""
_verify(hass, states[0], states[1], states[2], states[3], None) _verify(hass, states[0], states[1], states[2], states[3], None)
@ -378,8 +378,9 @@ async def test_template_with_unavailable_entities(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("fan.test_fan").state != STATE_UNAVAILABLE assert hass.states.get("fan.test_fan").state != STATE_UNAVAILABLE
@ -940,7 +941,8 @@ async def _register_components(
}, },
], ],
) )
async def test_unique_id(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_unique_id(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one fan per id.""" """Test unique_id option only creates one fan per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -1082,7 +1084,8 @@ async def test_implemented_percentage(
}, },
], ],
) )
async def test_implemented_preset_mode(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_implemented_preset_mode(hass: HomeAssistant) -> None:
"""Test a fan that implements preset_mode.""" """Test a fan that implements preset_mode."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1

22
tests/components/template/test_init.py
View File

@ -51,7 +51,8 @@ from tests.common import MockConfigEntry, async_fire_time_changed, get_fixture_p
}, },
], ],
) )
async def test_reloadable(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_reloadable(hass: HomeAssistant) -> None:
"""Test that we can reload.""" """Test that we can reload."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -102,7 +103,8 @@ async def test_reloadable(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_reloadable_can_remove(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_reloadable_can_remove(hass: HomeAssistant) -> None:
"""Test that we can reload and remove all template sensors.""" """Test that we can reload and remove all template sensors."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -132,9 +134,8 @@ async def test_reloadable_can_remove(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_reloadable_stops_on_invalid_config( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha async def test_reloadable_stops_on_invalid_config(hass: HomeAssistant) -> None:
) -> None:
"""Test we stop the reload if configuration.yaml is completely broken.""" """Test we stop the reload if configuration.yaml is completely broken."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -162,9 +163,8 @@ async def test_reloadable_stops_on_invalid_config(
}, },
], ],
) )
async def test_reloadable_handles_partial_valid_config( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha async def test_reloadable_handles_partial_valid_config(hass: HomeAssistant) -> None:
) -> None:
"""Test we can still setup valid sensors when configuration.yaml has a broken entry.""" """Test we can still setup valid sensors when configuration.yaml has a broken entry."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -195,7 +195,8 @@ async def test_reloadable_handles_partial_valid_config(
}, },
], ],
) )
async def test_reloadable_multiple_platforms(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_reloadable_multiple_platforms(hass: HomeAssistant) -> None:
"""Test that we can reload.""" """Test that we can reload."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await async_setup_component( await async_setup_component(
@ -239,8 +240,9 @@ async def test_reloadable_multiple_platforms(hass: HomeAssistant, start_ha) -> N
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_reload_sensors_that_reference_other_template_sensors( async def test_reload_sensors_that_reference_other_template_sensors(
hass: HomeAssistant, start_ha hass: HomeAssistant,
) -> None: ) -> None:
"""Test that we can reload sensor that reference other template sensors.""" """Test that we can reload sensor that reference other template sensors."""
await async_yaml_patch_helper(hass, "ref_configuration.yaml") await async_yaml_patch_helper(hass, "ref_configuration.yaml")

55
tests/components/template/test_lock.py
View File

@ -66,7 +66,8 @@ OPTIMISTIC_CODED_LOCK_CONFIG = {
}, },
], ],
) )
async def test_template_state(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state(hass: HomeAssistant) -> None:
"""Test template.""" """Test template."""
hass.states.async_set("switch.test_state", STATE_ON) hass.states.async_set("switch.test_state", STATE_ON)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -93,7 +94,8 @@ async def test_template_state(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state_boolean_on(hass: HomeAssistant) -> None:
"""Test the setting of the state with boolean on.""" """Test the setting of the state with boolean on."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == LockState.LOCKED assert state.state == LockState.LOCKED
@ -111,7 +113,8 @@ async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_template_state_boolean_off(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state_boolean_off(hass: HomeAssistant) -> None:
"""Test the setting of the state with off.""" """Test the setting of the state with off."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == LockState.UNLOCKED assert state.state == LockState.UNLOCKED
@ -181,7 +184,8 @@ async def test_template_state_boolean_off(hass: HomeAssistant, start_ha) -> None
}, },
], ],
) )
async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_syntax_error(hass: HomeAssistant) -> None:
"""Test templating syntax errors don't create entities.""" """Test templating syntax errors don't create entities."""
assert hass.states.async_all("lock") == [] assert hass.states.async_all("lock") == []
@ -198,7 +202,8 @@ async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_template_static(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_static(hass: HomeAssistant) -> None:
"""Test that we allow static templates.""" """Test that we allow static templates."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == LockState.UNLOCKED assert state.state == LockState.UNLOCKED
@ -221,9 +226,8 @@ async def test_template_static(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_lock_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_lock_action(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test lock action.""" """Test lock action."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
hass.states.async_set("switch.test_state", STATE_OFF) hass.states.async_set("switch.test_state", STATE_OFF)
@ -256,9 +260,8 @@ async def test_lock_action(
}, },
], ],
) )
async def test_unlock_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_unlock_action(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test unlock action.""" """Test unlock action."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
hass.states.async_set("switch.test_state", STATE_ON) hass.states.async_set("switch.test_state", STATE_ON)
@ -292,8 +295,9 @@ async def test_unlock_action(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_lock_action_with_code( async def test_lock_action_with_code(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test lock action with defined code format and supplied lock code.""" """Test lock action with defined code format and supplied lock code."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
@ -329,8 +333,9 @@ async def test_lock_action_with_code(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_unlock_action_with_code( async def test_unlock_action_with_code(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test unlock action with code format and supplied unlock code.""" """Test unlock action with code format and supplied unlock code."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
@ -373,8 +378,9 @@ async def test_unlock_action_with_code(
lock.SERVICE_UNLOCK, lock.SERVICE_UNLOCK,
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_lock_actions_fail_with_invalid_code( async def test_lock_actions_fail_with_invalid_code(
hass: HomeAssistant, start_ha, calls: list[ServiceCall], test_action hass: HomeAssistant, calls: list[ServiceCall], test_action
) -> None: ) -> None:
"""Test invalid lock codes.""" """Test invalid lock codes."""
await hass.services.async_call( await hass.services.async_call(
@ -405,8 +411,9 @@ async def test_lock_actions_fail_with_invalid_code(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_lock_actions_dont_execute_with_code_template_rendering_error( async def test_lock_actions_dont_execute_with_code_template_rendering_error(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test lock code format rendering fails block lock/unlock actions.""" """Test lock code format rendering fails block lock/unlock actions."""
await hass.services.async_call( await hass.services.async_call(
@ -438,8 +445,9 @@ async def test_lock_actions_dont_execute_with_code_template_rendering_error(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_actions_with_none_as_codeformat_ignores_code( async def test_actions_with_none_as_codeformat_ignores_code(
hass: HomeAssistant, action, start_ha, calls: list[ServiceCall] hass: HomeAssistant, action, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test lock actions with supplied lock code.""" """Test lock actions with supplied lock code."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
@ -476,8 +484,9 @@ async def test_actions_with_none_as_codeformat_ignores_code(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_actions_with_invalid_regexp_as_codeformat_never_execute( async def test_actions_with_invalid_regexp_as_codeformat_never_execute(
hass: HomeAssistant, action, start_ha, calls: list[ServiceCall] hass: HomeAssistant, action, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test lock actions don't execute with invalid regexp.""" """Test lock actions don't execute with invalid regexp."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
@ -522,7 +531,8 @@ async def test_actions_with_invalid_regexp_as_codeformat_never_execute(
@pytest.mark.parametrize( @pytest.mark.parametrize(
"test_state", [LockState.UNLOCKING, LockState.LOCKING, LockState.JAMMED] "test_state", [LockState.UNLOCKING, LockState.LOCKING, LockState.JAMMED]
) )
async def test_lock_state(hass: HomeAssistant, test_state, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_lock_state(hass: HomeAssistant, test_state) -> None:
"""Test value template.""" """Test value template."""
hass.states.async_set("input_select.test_state", test_state) hass.states.async_set("input_select.test_state", test_state)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -544,7 +554,8 @@ async def test_lock_state(hass: HomeAssistant, test_state, start_ha) -> None:
}, },
], ],
) )
async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_available_template_with_entities(hass: HomeAssistant) -> None:
"""Test availability templates with values from other entities.""" """Test availability templates with values from other entities."""
# When template returns true.. # When template returns true..
hass.states.async_set("availability_state.state", STATE_ON) hass.states.async_set("availability_state.state", STATE_ON)
@ -574,8 +585,9 @@ async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("lock.template_lock").state != STATE_UNAVAILABLE assert hass.states.get("lock.template_lock").state != STATE_UNAVAILABLE
@ -596,7 +608,8 @@ async def test_invalid_availability_template_keeps_component_available(
}, },
], ],
) )
async def test_unique_id(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_unique_id(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one lock per id.""" """Test unique_id option only creates one lock per id."""
await setup.async_setup_component( await setup.async_setup_component(
hass, hass,

90
tests/components/template/test_sensor.py
View File

@ -106,7 +106,8 @@ async def test_setup_config_entry(
}, },
], ],
) )
async def test_template_legacy(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_legacy(hass: HomeAssistant) -> None:
"""Test template.""" """Test template."""
assert hass.states.get(TEST_NAME).state == "It ." assert hass.states.get(TEST_NAME).state == "It ."
@ -135,7 +136,8 @@ async def test_template_legacy(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_icon_template(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_icon_template(hass: HomeAssistant) -> None:
"""Test icon template.""" """Test icon template."""
assert hass.states.get(TEST_NAME).attributes.get("icon") == "" assert hass.states.get(TEST_NAME).attributes.get("icon") == ""
@ -164,7 +166,8 @@ async def test_icon_template(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_entity_picture_template(hass: HomeAssistant) -> None:
"""Test entity_picture template.""" """Test entity_picture template."""
assert hass.states.get(TEST_NAME).attributes.get("entity_picture") == "" assert hass.states.get(TEST_NAME).attributes.get("entity_picture") == ""
@ -243,9 +246,8 @@ async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None:
), ),
], ],
) )
async def test_friendly_name_template( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, attribute, expected, start_ha async def test_friendly_name_template(hass: HomeAssistant, attribute, expected) -> None:
) -> None:
"""Test friendly_name template with an unknown value_template.""" """Test friendly_name template with an unknown value_template."""
assert hass.states.get(TEST_NAME).attributes.get(attribute) == expected[0] assert hass.states.get(TEST_NAME).attributes.get(attribute) == expected[0]
@ -314,7 +316,8 @@ async def test_friendly_name_template(
}, },
], ],
) )
async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_syntax_error(hass: HomeAssistant) -> None:
"""Test setup with invalid device_class.""" """Test setup with invalid device_class."""
assert hass.states.async_all("sensor") == [] assert hass.states.async_all("sensor") == []
@ -336,7 +339,8 @@ async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
async def test_template_attribute_missing(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_attribute_missing(hass: HomeAssistant) -> None:
"""Test missing attribute template.""" """Test missing attribute template."""
assert hass.states.get(TEST_NAME).state == STATE_UNAVAILABLE assert hass.states.get(TEST_NAME).state == STATE_UNAVAILABLE
@ -362,7 +366,8 @@ async def test_template_attribute_missing(hass: HomeAssistant, start_ha) -> None
}, },
], ],
) )
async def test_setup_valid_device_class(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_setup_valid_device_class(hass: HomeAssistant) -> None:
"""Test setup with valid device_class.""" """Test setup with valid device_class."""
hass.states.async_set("sensor.test_sensor", "75") hass.states.async_set("sensor.test_sensor", "75")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -434,7 +439,8 @@ async def test_creating_sensor_loads_group(hass: HomeAssistant) -> None:
}, },
], ],
) )
async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_available_template_with_entities(hass: HomeAssistant) -> None:
"""Test availability tempalates with values from other entities.""" """Test availability tempalates with values from other entities."""
hass.states.async_set("sensor.availability_sensor", STATE_OFF) hass.states.async_set("sensor.availability_sensor", STATE_OFF)
@ -472,8 +478,9 @@ async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_attribute_template( async def test_invalid_attribute_template(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, start_ha, caplog_setup_text hass: HomeAssistant, caplog: pytest.LogCaptureFixture, caplog_setup_text
) -> None: ) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
hass.states.async_set("sensor.test_sensor", "startup") hass.states.async_set("sensor.test_sensor", "startup")
@ -508,8 +515,9 @@ async def test_invalid_attribute_template(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("sensor.my_sensor").state != STATE_UNAVAILABLE assert hass.states.get("sensor.my_sensor").state != STATE_UNAVAILABLE
@ -625,8 +633,9 @@ async def test_no_template_match_all(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_unique_id( async def test_unique_id(
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry hass: HomeAssistant, entity_registry: er.EntityRegistry
) -> None: ) -> None:
"""Test unique_id option only creates one sensor per id.""" """Test unique_id option only creates one sensor per id."""
assert len(hass.states.async_all()) == 2 assert len(hass.states.async_all()) == 2
@ -661,7 +670,8 @@ async def test_unique_id(
}, },
], ],
) )
async def test_sun_renders_once_per_sensor(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_sun_renders_once_per_sensor(hass: HomeAssistant) -> None:
"""Test sun change renders the template only once per sensor.""" """Test sun change renders the template only once per sensor."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -730,7 +740,8 @@ async def test_sun_renders_once_per_sensor(hass: HomeAssistant, start_ha) -> Non
}, },
], ],
) )
async def test_this_variable(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_this_variable(hass: HomeAssistant) -> None:
"""Test template.""" """Test template."""
assert hass.states.get(TEST_NAME).state == "It: " + TEST_NAME assert hass.states.get(TEST_NAME).state == "It: " + TEST_NAME
@ -875,8 +886,9 @@ async def test_this_variable_early_hass_running(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_self_referencing_sensor_loop( async def test_self_referencing_sensor_loop(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test a self referencing sensor does not loop forever.""" """Test a self referencing sensor does not loop forever."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -905,8 +917,9 @@ async def test_self_referencing_sensor_loop(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_self_referencing_sensor_with_icon_loop( async def test_self_referencing_sensor_with_icon_loop(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test a self referencing sensor loops forever with a valid self referencing icon.""" """Test a self referencing sensor loops forever with a valid self referencing icon."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -940,8 +953,9 @@ async def test_self_referencing_sensor_with_icon_loop(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_self_referencing_sensor_with_icon_and_picture_entity_loop( async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test a self referencing sensor loop forevers with a valid self referencing icon.""" """Test a self referencing sensor loop forevers with a valid self referencing icon."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -975,8 +989,9 @@ async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_self_referencing_entity_picture_loop( async def test_self_referencing_entity_picture_loop(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test a self referencing sensor does not loop forever with a looping self referencing entity picture.""" """Test a self referencing sensor does not loop forever with a looping self referencing entity picture."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -1092,7 +1107,8 @@ async def test_self_referencing_icon_with_no_loop(
}, },
], ],
) )
async def test_duplicate_templates(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_duplicate_templates(hass: HomeAssistant) -> None:
"""Test template entity where the value and friendly name as the same template.""" """Test template entity where the value and friendly name as the same template."""
hass.states.async_set("sensor.test_state", "Abc") hass.states.async_set("sensor.test_state", "Abc")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1161,8 +1177,9 @@ async def test_duplicate_templates(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_entity( async def test_trigger_entity(
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry hass: HomeAssistant, entity_registry: er.EntityRegistry
) -> None: ) -> None:
"""Test trigger entity works.""" """Test trigger entity works."""
state = hass.states.get("sensor.hello_name") state = hass.states.get("sensor.hello_name")
@ -1234,7 +1251,8 @@ async def test_trigger_entity(
}, },
], ],
) )
async def test_trigger_conditional_entity(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_trigger_conditional_entity(hass: HomeAssistant) -> None:
"""Test conditional trigger entity works.""" """Test conditional trigger entity works."""
state = hass.states.get("sensor.enough_name") state = hass.states.get("sensor.enough_name")
assert state is not None assert state is not None
@ -1280,8 +1298,9 @@ async def test_trigger_conditional_entity(hass: HomeAssistant, start_ha) -> None
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_conditional_entity_evaluation_error( async def test_trigger_conditional_entity_evaluation_error(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, start_ha hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None: ) -> None:
"""Test trigger entity is not updated when condition evaluation fails.""" """Test trigger entity is not updated when condition evaluation fails."""
hass.bus.async_fire("test_event", {"beer": 1}) hass.bus.async_fire("test_event", {"beer": 1})
@ -1317,8 +1336,9 @@ async def test_trigger_conditional_entity_evaluation_error(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_conditional_entity_invalid_condition( async def test_trigger_conditional_entity_invalid_condition(
hass: HomeAssistant, start_ha hass: HomeAssistant,
) -> None: ) -> None:
"""Test trigger entity is not created when condition is invalid.""" """Test trigger entity is not created when condition is invalid."""
state = hass.states.get("sensor.will_not_exist_name") state = hass.states.get("sensor.will_not_exist_name")
@ -1350,9 +1370,8 @@ async def test_trigger_conditional_entity_invalid_condition(
}, },
], ],
) )
async def test_trigger_entity_runs_once( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry async def test_trigger_entity_runs_once(hass: HomeAssistant) -> None:
) -> None:
"""Test trigger entity handles a trigger once.""" """Test trigger entity handles a trigger once."""
state = hass.states.get("sensor.hello_name") state = hass.states.get("sensor.hello_name")
assert state is not None assert state is not None
@ -1385,8 +1404,9 @@ async def test_trigger_entity_runs_once(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_entity_render_error( async def test_trigger_entity_render_error(
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry hass: HomeAssistant, entity_registry: er.EntityRegistry
) -> None: ) -> None:
"""Test trigger entity handles render error.""" """Test trigger entity handles render error."""
state = hass.states.get("sensor.hello") state = hass.states.get("sensor.hello")
@ -1422,8 +1442,9 @@ async def test_trigger_entity_render_error(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_trigger_not_allowed_platform_config( async def test_trigger_not_allowed_platform_config(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test we throw a helpful warning if a trigger is configured in platform config.""" """Test we throw a helpful warning if a trigger is configured in platform config."""
state = hass.states.get(TEST_NAME) state = hass.states.get(TEST_NAME)
@ -1451,7 +1472,8 @@ async def test_trigger_not_allowed_platform_config(
}, },
], ],
) )
async def test_config_top_level(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_config_top_level(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one sensor per id.""" """Test unique_id option only creates one sensor per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
state = hass.states.get("sensor.top_level") state = hass.states.get("sensor.top_level")
@ -1997,9 +2019,8 @@ async def test_trigger_entity_restore_state(
}, },
], ],
) )
async def test_trigger_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry async def test_trigger_action(hass: HomeAssistant) -> None:
) -> None:
"""Test trigger entity with an action works.""" """Test trigger entity with an action works."""
event = "test_event2" event = "test_event2"
context = Context() context = Context()
@ -2050,7 +2071,8 @@ async def test_trigger_action(
}, },
], ],
) )
async def test_trigger_conditional_action(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_trigger_conditional_action(hass: HomeAssistant) -> None:
"""Test conditional trigger entity with an action works.""" """Test conditional trigger entity with an action works."""
event = "test_event_by_action" event = "test_event_by_action"

50
tests/components/template/test_trigger.py
View File

@ -48,8 +48,9 @@ def setup_comp(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_bool( async def test_if_fires_on_change_bool(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on boolean change.""" """Test for firing on boolean change."""
assert len(calls) == 0 assert len(calls) == 0
@ -271,8 +272,9 @@ async def test_if_fires_on_change_bool(
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_general( async def test_general(
hass: HomeAssistant, call_setup, start_ha, calls: list[ServiceCall] hass: HomeAssistant, call_setup, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change.""" """Test for firing on change."""
assert len(calls) == 0 assert len(calls) == 0
@ -308,8 +310,9 @@ async def test_general(
), ),
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_not_fires_because_fail( async def test_if_not_fires_because_fail(
hass: HomeAssistant, call_setup, start_ha, calls: list[ServiceCall] hass: HomeAssistant, call_setup, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for not firing after TemplateError.""" """Test for not firing after TemplateError."""
assert len(calls) == 0 assert len(calls) == 0
@ -346,8 +349,9 @@ async def test_if_not_fires_because_fail(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_template_advanced( async def test_if_fires_on_change_with_template_advanced(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with template advanced.""" """Test for firing on change with template advanced."""
context = Context() context = Context()
@ -378,9 +382,8 @@ async def test_if_fires_on_change_with_template_advanced(
}, },
], ],
) )
async def test_if_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, calls: list[ServiceCall] async def test_if_action(hass: HomeAssistant, calls: list[ServiceCall]) -> None:
) -> None:
"""Test for firing if action.""" """Test for firing if action."""
# Condition is not true yet # Condition is not true yet
hass.bus.async_fire("test_event") hass.bus.async_fire("test_event")
@ -410,8 +413,9 @@ async def test_if_action(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_bad_template( async def test_if_fires_on_change_with_bad_template(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with bad template.""" """Test for firing on change with bad template."""
assert hass.states.get("automation.automation_0").state == STATE_UNAVAILABLE assert hass.states.get("automation.automation_0").state == STATE_UNAVAILABLE
@ -447,8 +451,9 @@ async def test_if_fires_on_change_with_bad_template(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_wait_template_with_trigger( async def test_wait_template_with_trigger(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test using wait template with 'trigger.entity_id'.""" """Test using wait template with 'trigger.entity_id'."""
await hass.async_block_till_done() await hass.async_block_till_done()
@ -519,8 +524,9 @@ async def test_if_fires_on_change_with_for(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_advanced( async def test_if_fires_on_change_with_for_advanced(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for advanced.""" """Test for firing on change with for advanced."""
context = Context() context = Context()
@ -563,8 +569,9 @@ async def test_if_fires_on_change_with_for_advanced(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_0_advanced( async def test_if_fires_on_change_with_for_0_advanced(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for: 0 advanced.""" """Test for firing on change with for: 0 advanced."""
context = Context() context = Context()
@ -604,8 +611,9 @@ async def test_if_fires_on_change_with_for_0_advanced(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_2( async def test_if_fires_on_change_with_for_2(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
context = Context() context = Context()
@ -635,8 +643,9 @@ async def test_if_fires_on_change_with_for_2(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_not_fires_on_change_with_for( async def test_if_not_fires_on_change_with_for(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -669,8 +678,9 @@ async def test_if_not_fires_on_change_with_for(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_not_fires_when_turned_off_with_for( async def test_if_not_fires_when_turned_off_with_for(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -707,8 +717,9 @@ async def test_if_not_fires_when_turned_off_with_for(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_template_1( async def test_if_fires_on_change_with_for_template_1(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -735,8 +746,9 @@ async def test_if_fires_on_change_with_for_template_1(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_template_2( async def test_if_fires_on_change_with_for_template_2(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -763,8 +775,9 @@ async def test_if_fires_on_change_with_for_template_2(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_if_fires_on_change_with_for_template_3( async def test_if_fires_on_change_with_for_template_3(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -791,8 +804,9 @@ async def test_if_fires_on_change_with_for_template_3(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_for_template_1( async def test_invalid_for_template_1(
hass: HomeAssistant, start_ha, calls: list[ServiceCall] hass: HomeAssistant, calls: list[ServiceCall]
) -> None: ) -> None:
"""Test for invalid for template.""" """Test for invalid for template."""
with mock.patch.object(template_trigger, "_LOGGER") as mock_logger: with mock.patch.object(template_trigger, "_LOGGER") as mock_logger:

26
tests/components/template/test_vacuum.py
View File

@ -94,9 +94,8 @@ _BATTERY_LEVEL_INPUT_NUMBER = "input_number.battery_level"
), ),
], ],
) )
async def test_valid_configs( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, count, parm1, parm2, start_ha async def test_valid_configs(hass: HomeAssistant, count, parm1, parm2) -> None:
) -> None:
"""Test: configs.""" """Test: configs."""
assert len(hass.states.async_all("vacuum")) == count assert len(hass.states.async_all("vacuum")) == count
_verify(hass, parm1, parm2) _verify(hass, parm1, parm2)
@ -118,7 +117,8 @@ async def test_valid_configs(
}, },
], ],
) )
async def test_invalid_configs(hass: HomeAssistant, count, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_invalid_configs(hass: HomeAssistant, count) -> None:
"""Test: configs.""" """Test: configs."""
assert len(hass.states.async_all("vacuum")) == count assert len(hass.states.async_all("vacuum")) == count
@ -144,7 +144,8 @@ async def test_invalid_configs(hass: HomeAssistant, count, start_ha) -> None:
) )
], ],
) )
async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_templates_with_entities(hass: HomeAssistant) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
_verify(hass, STATE_UNKNOWN, None) _verify(hass, STATE_UNKNOWN, None)
@ -174,7 +175,8 @@ async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None:
) )
], ],
) )
async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_available_template_with_entities(hass: HomeAssistant) -> None:
"""Test availability templates with values from other entities.""" """Test availability templates with values from other entities."""
# When template returns true.. # When template returns true..
@ -212,8 +214,9 @@ async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -
) )
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("vacuum.test_template_vacuum") != STATE_UNAVAILABLE assert hass.states.get("vacuum.test_template_vacuum") != STATE_UNAVAILABLE
@ -243,7 +246,8 @@ async def test_invalid_availability_template_keeps_component_available(
) )
], ],
) )
async def test_attribute_templates(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_attribute_templates(hass: HomeAssistant) -> None:
"""Test attribute_templates template.""" """Test attribute_templates template."""
state = hass.states.get("vacuum.test_template_vacuum") state = hass.states.get("vacuum.test_template_vacuum")
assert state.attributes["test_attribute"] == "It ." assert state.attributes["test_attribute"] == "It ."
@ -278,8 +282,9 @@ async def test_attribute_templates(hass: HomeAssistant, start_ha) -> None:
) )
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_invalid_attribute_template( async def test_invalid_attribute_template(
hass: HomeAssistant, start_ha, caplog_setup_text hass: HomeAssistant, caplog_setup_text
) -> None: ) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
assert len(hass.states.async_all("vacuum")) == 1 assert len(hass.states.async_all("vacuum")) == 1
@ -313,7 +318,8 @@ async def test_invalid_attribute_template(
), ),
], ],
) )
async def test_unique_id(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_unique_id(hass: HomeAssistant) -> None:
"""Test unique_id option only creates one vacuum per id.""" """Test unique_id option only creates one vacuum per id."""
assert len(hass.states.async_all("vacuum")) == 1 assert len(hass.states.async_all("vacuum")) == 1

24
tests/components/template/test_weather.py
View File

@ -23,7 +23,6 @@ from homeassistant.components.weather import (
) )
from homeassistant.const import ATTR_ATTRIBUTION, STATE_UNAVAILABLE, STATE_UNKNOWN from homeassistant.const import ATTR_ATTRIBUTION, STATE_UNAVAILABLE, STATE_UNKNOWN
from homeassistant.core import Context, HomeAssistant, State from homeassistant.core import Context, HomeAssistant, State
from homeassistant.helpers import entity_registry as er
from homeassistant.helpers.restore_state import STORAGE_KEY as RESTORE_STATE_KEY from homeassistant.helpers.restore_state import STORAGE_KEY as RESTORE_STATE_KEY
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
@ -65,7 +64,8 @@ ATTR_FORECAST = "forecast"
}, },
], ],
) )
async def test_template_state_text(hass: HomeAssistant, start_ha) -> None: @pytest.mark.usefixtures("start_ha")
async def test_template_state_text(hass: HomeAssistant) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
for attr, v_attr, value in ( for attr, v_attr, value in (
( (
@ -117,8 +117,9 @@ async def test_template_state_text(hass: HomeAssistant, start_ha) -> None:
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_forecasts( async def test_forecasts(
hass: HomeAssistant, start_ha, snapshot: SnapshotAssertion, service: str hass: HomeAssistant, snapshot: SnapshotAssertion, service: str
) -> None: ) -> None:
"""Test forecast service.""" """Test forecast service."""
for attr, _v_attr, value in ( for attr, _v_attr, value in (
@ -241,9 +242,9 @@ async def test_forecasts(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_forecast_invalid( async def test_forecast_invalid(
hass: HomeAssistant, hass: HomeAssistant,
start_ha,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
service: str, service: str,
expected: dict[str, Any], expected: dict[str, Any],
@ -323,9 +324,9 @@ async def test_forecast_invalid(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_forecast_invalid_is_daytime_missing_in_twice_daily( async def test_forecast_invalid_is_daytime_missing_in_twice_daily(
hass: HomeAssistant, hass: HomeAssistant,
start_ha,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
service: str, service: str,
expected: dict[str, Any], expected: dict[str, Any],
@ -391,9 +392,9 @@ async def test_forecast_invalid_is_daytime_missing_in_twice_daily(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_forecast_invalid_datetime_missing( async def test_forecast_invalid_datetime_missing(
hass: HomeAssistant, hass: HomeAssistant,
start_ha,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
service: str, service: str,
expected: dict[str, Any], expected: dict[str, Any],
@ -458,8 +459,9 @@ async def test_forecast_invalid_datetime_missing(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
async def test_forecast_format_error( async def test_forecast_format_error(
hass: HomeAssistant, start_ha, caplog: pytest.LogCaptureFixture, service: str hass: HomeAssistant, caplog: pytest.LogCaptureFixture, service: str
) -> None: ) -> None:
"""Test forecast service invalid on incorrect format.""" """Test forecast service invalid on incorrect format."""
for attr, _v_attr, value in ( for attr, _v_attr, value in (
@ -649,9 +651,8 @@ async def test_trigger_entity_restore_state(
}, },
], ],
) )
async def test_trigger_action( @pytest.mark.usefixtures("start_ha")
hass: HomeAssistant, start_ha, entity_registry: er.EntityRegistry async def test_trigger_action(hass: HomeAssistant) -> None:
) -> None:
"""Test trigger entity with an action works.""" """Test trigger entity with an action works."""
state = hass.states.get("weather.hello_name") state = hass.states.get("weather.hello_name")
assert state is not None assert state is not None
@ -720,11 +721,10 @@ async def test_trigger_action(
}, },
], ],
) )
@pytest.mark.usefixtures("start_ha")
@pytest.mark.freeze_time("2023-10-19 13:50:05") @pytest.mark.freeze_time("2023-10-19 13:50:05")
async def test_trigger_weather_services( async def test_trigger_weather_services(
hass: HomeAssistant, hass: HomeAssistant,
start_ha,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion, snapshot: SnapshotAssertion,
service: str, service: str,
) -> None: ) -> None: