From 3bf99087899748426619783221b8b8112e5e1266 Mon Sep 17 00:00:00 2001 From: Petro31 <35082313+Petro31@users.noreply.github.com> Date: Thu, 15 May 2025 09:46:00 -0400 Subject: [PATCH] Add template vacuum modern style (#144843) * Add template vacuum modern style * address comments and add tests for coverage * address comments * update vacuum and sort domains --- homeassistant/components/template/config.py | 116 +- homeassistant/components/template/vacuum.py | 143 +- tests/components/template/test_vacuum.py | 1314 +++++++++++-------- 3 files changed, 908 insertions(+), 665 deletions(-) diff --git a/homeassistant/components/template/config.py b/homeassistant/components/template/config.py index 9e684e89f62..f1b58ebffa0 100644 --- a/homeassistant/components/template/config.py +++ b/homeassistant/components/template/config.py @@ -8,24 +8,25 @@ from typing import Any import voluptuous as vol from homeassistant.components.alarm_control_panel import ( - DOMAIN as ALARM_CONTROL_PANEL_DOMAIN, + DOMAIN as DOMAIN_ALARM_CONTROL_PANEL, ) -from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN +from homeassistant.components.binary_sensor import DOMAIN as DOMAIN_BINARY_SENSOR from homeassistant.components.blueprint import ( is_blueprint_instance_config, schemas as blueprint_schemas, ) -from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN -from homeassistant.components.cover import DOMAIN as COVER_DOMAIN -from homeassistant.components.fan import DOMAIN as FAN_DOMAIN -from homeassistant.components.image import DOMAIN as IMAGE_DOMAIN -from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN -from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN -from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN -from homeassistant.components.select import DOMAIN as SELECT_DOMAIN -from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN -from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN -from homeassistant.components.weather import DOMAIN as WEATHER_DOMAIN +from homeassistant.components.button import DOMAIN as DOMAIN_BUTTON +from homeassistant.components.cover import DOMAIN as DOMAIN_COVER +from homeassistant.components.fan import DOMAIN as DOMAIN_FAN +from homeassistant.components.image import DOMAIN as DOMAIN_IMAGE +from homeassistant.components.light import DOMAIN as DOMAIN_LIGHT +from homeassistant.components.lock import DOMAIN as DOMAIN_LOCK +from homeassistant.components.number import DOMAIN as DOMAIN_NUMBER +from homeassistant.components.select import DOMAIN as DOMAIN_SELECT +from homeassistant.components.sensor import DOMAIN as DOMAIN_SENSOR +from homeassistant.components.switch import DOMAIN as DOMAIN_SWITCH +from homeassistant.components.vacuum import DOMAIN as DOMAIN_VACUUM +from homeassistant.components.weather import DOMAIN as DOMAIN_WEATHER from homeassistant.config import async_log_schema_error, config_without_domain from homeassistant.const import ( CONF_ACTION, @@ -60,6 +61,7 @@ from . import ( select as select_platform, sensor as sensor_platform, switch as switch_platform, + vacuum as vacuum_platform, weather as weather_platform, ) from .const import DOMAIN, PLATFORMS, TemplateConfig @@ -98,61 +100,69 @@ CONFIG_SECTION_SCHEMA = vol.All( _backward_compat_schema, vol.Schema( { - vol.Optional(CONF_UNIQUE_ID): cv.string, - vol.Optional(CONF_TRIGGERS): cv.TRIGGER_SCHEMA, - vol.Optional(CONF_CONDITIONS): cv.CONDITIONS_SCHEMA, vol.Optional(CONF_ACTIONS): cv.SCRIPT_SCHEMA, - vol.Optional(CONF_VARIABLES): cv.SCRIPT_VARIABLES_SCHEMA, - vol.Optional(NUMBER_DOMAIN): vol.All( - cv.ensure_list, [number_platform.NUMBER_SCHEMA] - ), - vol.Optional(SENSOR_DOMAIN): vol.All( - cv.ensure_list, [sensor_platform.SENSOR_SCHEMA] - ), - vol.Optional(CONF_SENSORS): cv.schema_with_slug_keys( - sensor_platform.LEGACY_SENSOR_SCHEMA - ), - vol.Optional(BINARY_SENSOR_DOMAIN): vol.All( - cv.ensure_list, [binary_sensor_platform.BINARY_SENSOR_SCHEMA] - ), vol.Optional(CONF_BINARY_SENSORS): cv.schema_with_slug_keys( binary_sensor_platform.LEGACY_BINARY_SENSOR_SCHEMA ), - vol.Optional(ALARM_CONTROL_PANEL_DOMAIN): vol.All( + vol.Optional(CONF_CONDITIONS): cv.CONDITIONS_SCHEMA, + vol.Optional(CONF_SENSORS): cv.schema_with_slug_keys( + sensor_platform.LEGACY_SENSOR_SCHEMA + ), + vol.Optional(CONF_TRIGGERS): cv.TRIGGER_SCHEMA, + vol.Optional(CONF_UNIQUE_ID): cv.string, + vol.Optional(CONF_VARIABLES): cv.SCRIPT_VARIABLES_SCHEMA, + vol.Optional(DOMAIN_ALARM_CONTROL_PANEL): vol.All( cv.ensure_list, [alarm_control_panel_platform.ALARM_CONTROL_PANEL_SCHEMA], ), - vol.Optional(SELECT_DOMAIN): vol.All( - cv.ensure_list, [select_platform.SELECT_SCHEMA] + vol.Optional(DOMAIN_BINARY_SENSOR): vol.All( + cv.ensure_list, [binary_sensor_platform.BINARY_SENSOR_SCHEMA] ), - vol.Optional(BUTTON_DOMAIN): vol.All( + vol.Optional(DOMAIN_BUTTON): vol.All( cv.ensure_list, [button_platform.BUTTON_SCHEMA] ), - vol.Optional(IMAGE_DOMAIN): vol.All( - cv.ensure_list, [image_platform.IMAGE_SCHEMA] - ), - vol.Optional(LIGHT_DOMAIN): vol.All( - cv.ensure_list, [light_platform.LIGHT_SCHEMA] - ), - vol.Optional(LOCK_DOMAIN): vol.All( - cv.ensure_list, [lock_platform.LOCK_SCHEMA] - ), - vol.Optional(WEATHER_DOMAIN): vol.All( - cv.ensure_list, [weather_platform.WEATHER_SCHEMA] - ), - vol.Optional(SWITCH_DOMAIN): vol.All( - cv.ensure_list, [switch_platform.SWITCH_SCHEMA] - ), - vol.Optional(COVER_DOMAIN): vol.All( + vol.Optional(DOMAIN_COVER): vol.All( cv.ensure_list, [cover_platform.COVER_SCHEMA] ), - vol.Optional(FAN_DOMAIN): vol.All( + vol.Optional(DOMAIN_FAN): vol.All( cv.ensure_list, [fan_platform.FAN_SCHEMA] ), + vol.Optional(DOMAIN_IMAGE): vol.All( + cv.ensure_list, [image_platform.IMAGE_SCHEMA] + ), + vol.Optional(DOMAIN_LIGHT): vol.All( + cv.ensure_list, [light_platform.LIGHT_SCHEMA] + ), + vol.Optional(DOMAIN_LOCK): vol.All( + cv.ensure_list, [lock_platform.LOCK_SCHEMA] + ), + vol.Optional(DOMAIN_NUMBER): vol.All( + cv.ensure_list, [number_platform.NUMBER_SCHEMA] + ), + vol.Optional(DOMAIN_SELECT): vol.All( + cv.ensure_list, [select_platform.SELECT_SCHEMA] + ), + vol.Optional(DOMAIN_SENSOR): vol.All( + cv.ensure_list, [sensor_platform.SENSOR_SCHEMA] + ), + vol.Optional(DOMAIN_SWITCH): vol.All( + cv.ensure_list, [switch_platform.SWITCH_SCHEMA] + ), + vol.Optional(DOMAIN_VACUUM): vol.All( + cv.ensure_list, [vacuum_platform.VACUUM_SCHEMA] + ), + vol.Optional(DOMAIN_WEATHER): vol.All( + cv.ensure_list, [weather_platform.WEATHER_SCHEMA] + ), }, ), ensure_domains_do_not_have_trigger_or_action( - ALARM_CONTROL_PANEL_DOMAIN, BUTTON_DOMAIN, COVER_DOMAIN, FAN_DOMAIN, LOCK_DOMAIN + DOMAIN_ALARM_CONTROL_PANEL, + DOMAIN_BUTTON, + DOMAIN_COVER, + DOMAIN_FAN, + DOMAIN_LOCK, + DOMAIN_VACUUM, ), ) @@ -247,12 +257,12 @@ async def async_validate_config(hass: HomeAssistant, config: ConfigType) -> Conf for old_key, new_key, transform in ( ( CONF_SENSORS, - SENSOR_DOMAIN, + DOMAIN_SENSOR, sensor_platform.rewrite_legacy_to_modern_conf, ), ( CONF_BINARY_SENSORS, - BINARY_SENSOR_DOMAIN, + DOMAIN_BINARY_SENSOR, binary_sensor_platform.rewrite_legacy_to_modern_conf, ), ): diff --git a/homeassistant/components/template/vacuum.py b/homeassistant/components/template/vacuum.py index 1e18b06436a..462f7d672ff 100644 --- a/homeassistant/components/template/vacuum.py +++ b/homeassistant/components/template/vacuum.py @@ -24,21 +24,27 @@ from homeassistant.components.vacuum import ( from homeassistant.const import ( CONF_ENTITY_ID, CONF_FRIENDLY_NAME, + CONF_NAME, + CONF_STATE, CONF_UNIQUE_ID, CONF_VALUE_TEMPLATE, STATE_UNKNOWN, ) from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import TemplateError -from homeassistant.helpers import config_validation as cv +from homeassistant.helpers import config_validation as cv, template from homeassistant.helpers.entity import async_generate_entity_id from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType -from .const import DOMAIN +from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN from .template_entity import ( + LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS, + TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA, TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA_LEGACY, + TEMPLATE_ENTITY_AVAILABILITY_SCHEMA, TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY, + TEMPLATE_ENTITY_ICON_SCHEMA, TemplateEntity, rewrite_common_legacy_to_modern_conf, ) @@ -46,8 +52,10 @@ from .template_entity import ( _LOGGER = logging.getLogger(__name__) CONF_VACUUMS = "vacuums" +CONF_BATTERY_LEVEL = "battery_level" CONF_BATTERY_LEVEL_TEMPLATE = "battery_level_template" CONF_FAN_SPEED_LIST = "fan_speeds" +CONF_FAN_SPEED = "fan_speed" CONF_FAN_SPEED_TEMPLATE = "fan_speed_template" ENTITY_ID_FORMAT = VACUUM_DOMAIN + ".{}" @@ -60,24 +68,55 @@ _VALID_STATES = [ VacuumActivity.ERROR, ] +LEGACY_FIELDS = TEMPLATE_ENTITY_LEGACY_FIELDS | { + CONF_BATTERY_LEVEL_TEMPLATE: CONF_BATTERY_LEVEL, + CONF_FAN_SPEED_TEMPLATE: CONF_FAN_SPEED, + CONF_VALUE_TEMPLATE: CONF_STATE, +} + VACUUM_SCHEMA = vol.All( + vol.Schema( + { + vol.Optional(CONF_BATTERY_LEVEL): cv.template, + vol.Optional(CONF_ENTITY_ID): cv.entity_ids, + vol.Optional(CONF_FAN_SPEED_LIST, default=[]): cv.ensure_list, + vol.Optional(CONF_FAN_SPEED): cv.template, + vol.Optional(CONF_NAME): cv.template, + vol.Optional(CONF_PICTURE): cv.template, + vol.Optional(CONF_STATE): cv.template, + vol.Optional(CONF_UNIQUE_ID): cv.string, + vol.Optional(SERVICE_CLEAN_SPOT): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_LOCATE): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_PAUSE): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_RETURN_TO_BASE): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_SET_FAN_SPEED): cv.SCRIPT_SCHEMA, + vol.Required(SERVICE_START): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_STOP): cv.SCRIPT_SCHEMA, + } + ) + .extend(TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA.schema) + .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema) + .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema), +) + +LEGACY_VACUUM_SCHEMA = vol.All( cv.deprecated(CONF_ENTITY_ID), vol.Schema( { - vol.Optional(CONF_FRIENDLY_NAME): cv.string, - vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_BATTERY_LEVEL_TEMPLATE): cv.template, + vol.Optional(CONF_ENTITY_ID): cv.entity_ids, + vol.Optional(CONF_FAN_SPEED_LIST, default=[]): cv.ensure_list, vol.Optional(CONF_FAN_SPEED_TEMPLATE): cv.template, - vol.Required(SERVICE_START): cv.SCRIPT_SCHEMA, - vol.Optional(SERVICE_PAUSE): cv.SCRIPT_SCHEMA, - vol.Optional(SERVICE_STOP): cv.SCRIPT_SCHEMA, - vol.Optional(SERVICE_RETURN_TO_BASE): cv.SCRIPT_SCHEMA, + vol.Optional(CONF_FRIENDLY_NAME): cv.string, + vol.Optional(CONF_UNIQUE_ID): cv.string, + vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(SERVICE_CLEAN_SPOT): cv.SCRIPT_SCHEMA, vol.Optional(SERVICE_LOCATE): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_PAUSE): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_RETURN_TO_BASE): cv.SCRIPT_SCHEMA, vol.Optional(SERVICE_SET_FAN_SPEED): cv.SCRIPT_SCHEMA, - vol.Optional(CONF_FAN_SPEED_LIST, default=[]): cv.ensure_list, - vol.Optional(CONF_ENTITY_ID): cv.entity_ids, - vol.Optional(CONF_UNIQUE_ID): cv.string, + vol.Required(SERVICE_START): cv.SCRIPT_SCHEMA, + vol.Optional(SERVICE_STOP): cv.SCRIPT_SCHEMA, } ) .extend(TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA_LEGACY.schema) @@ -85,28 +124,56 @@ VACUUM_SCHEMA = vol.All( ) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend( - {vol.Required(CONF_VACUUMS): vol.Schema({cv.slug: VACUUM_SCHEMA})} + {vol.Required(CONF_VACUUMS): cv.schema_with_slug_keys(LEGACY_VACUUM_SCHEMA)} ) -async def _async_create_entities(hass: HomeAssistant, config: ConfigType): - """Create the Template Vacuums.""" +def rewrite_legacy_to_modern_conf( + hass: HomeAssistant, config: dict[str, dict] +) -> list[dict]: + """Rewrite legacy switch configuration definitions to modern ones.""" vacuums = [] - for object_id, entity_config in config[CONF_VACUUMS].items(): - entity_config = rewrite_common_legacy_to_modern_conf(hass, entity_config) - unique_id = entity_config.get(CONF_UNIQUE_ID) + for object_id, entity_conf in config.items(): + entity_conf = {**entity_conf, CONF_OBJECT_ID: object_id} + + entity_conf = rewrite_common_legacy_to_modern_conf( + hass, entity_conf, LEGACY_FIELDS + ) + + if CONF_NAME not in entity_conf: + entity_conf[CONF_NAME] = template.Template(object_id, hass) + + vacuums.append(entity_conf) + + return vacuums + + +@callback +def _async_create_template_tracking_entities( + async_add_entities: AddEntitiesCallback, + hass: HomeAssistant, + definitions: list[dict], + unique_id_prefix: str | None, +) -> None: + """Create the template switches.""" + vacuums = [] + + for entity_conf in definitions: + unique_id = entity_conf.get(CONF_UNIQUE_ID) + + if unique_id and unique_id_prefix: + unique_id = f"{unique_id_prefix}-{unique_id}" vacuums.append( TemplateVacuum( hass, - object_id, - entity_config, + entity_conf, unique_id, ) ) - return vacuums + async_add_entities(vacuums) async def async_setup_platform( @@ -115,8 +182,22 @@ async def async_setup_platform( async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: - """Set up the template vacuums.""" - async_add_entities(await _async_create_entities(hass, config)) + """Set up the Template cover.""" + if discovery_info is None: + _async_create_template_tracking_entities( + async_add_entities, + hass, + rewrite_legacy_to_modern_conf(hass, config[CONF_VACUUMS]), + None, + ) + return + + _async_create_template_tracking_entities( + async_add_entities, + hass, + discovery_info["entities"], + discovery_info["unique_id"], + ) class TemplateVacuum(TemplateEntity, StateVacuumEntity): @@ -127,24 +208,22 @@ class TemplateVacuum(TemplateEntity, StateVacuumEntity): def __init__( self, hass: HomeAssistant, - object_id, config: ConfigType, unique_id, ) -> None: """Initialize the vacuum.""" - super().__init__( - hass, config=config, fallback_name=object_id, unique_id=unique_id - ) - self.entity_id = async_generate_entity_id( - ENTITY_ID_FORMAT, object_id, hass=hass - ) + super().__init__(hass, config=config, fallback_name=None, unique_id=unique_id) + if (object_id := config.get(CONF_OBJECT_ID)) is not None: + self.entity_id = async_generate_entity_id( + ENTITY_ID_FORMAT, object_id, hass=hass + ) name = self._attr_name if TYPE_CHECKING: assert name is not None - self._template = config.get(CONF_VALUE_TEMPLATE) - self._battery_level_template = config.get(CONF_BATTERY_LEVEL_TEMPLATE) - self._fan_speed_template = config.get(CONF_FAN_SPEED_TEMPLATE) + self._template = config.get(CONF_STATE) + self._battery_level_template = config.get(CONF_BATTERY_LEVEL) + self._fan_speed_template = config.get(CONF_FAN_SPEED) self._attr_supported_features = ( VacuumEntityFeature.START | VacuumEntityFeature.STATE ) diff --git a/tests/components/template/test_vacuum.py b/tests/components/template/test_vacuum.py index cc5bc9b39e3..90ca0b56afb 100644 --- a/tests/components/template/test_vacuum.py +++ b/tests/components/template/test_vacuum.py @@ -4,16 +4,17 @@ from typing import Any import pytest -from homeassistant import setup -from homeassistant.components import vacuum +from homeassistant.components import template, vacuum from homeassistant.components.vacuum import ( ATTR_BATTERY_LEVEL, + ATTR_FAN_SPEED, VacuumActivity, VacuumEntityFeature, ) from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.exceptions import HomeAssistantError +from homeassistant.helpers import entity_registry as er from homeassistant.helpers.entity_component import async_update_entity from homeassistant.setup import async_setup_component @@ -22,19 +23,91 @@ from .conftest import ConfigurationStyle from tests.common import assert_setup_component from tests.components.vacuum import common -_TEST_OBJECT_ID = "test_vacuum" -_TEST_VACUUM = f"vacuum.{_TEST_OBJECT_ID}" -_STATE_INPUT_SELECT = "input_select.state" -_SPOT_CLEANING_INPUT_BOOLEAN = "input_boolean.spot_cleaning" -_LOCATING_INPUT_BOOLEAN = "input_boolean.locating" -_FAN_SPEED_INPUT_SELECT = "input_select.fan_speed" -_BATTERY_LEVEL_INPUT_NUMBER = "input_number.battery_level" +TEST_OBJECT_ID = "test_vacuum" +TEST_ENTITY_ID = f"vacuum.{TEST_OBJECT_ID}" + +STATE_INPUT_SELECT = "input_select.state" +BATTERY_LEVEL_INPUT_NUMBER = "input_number.battery_level" + +START_ACTION = { + "start": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "start", + }, + }, +} + + +TEMPLATE_VACUUM_ACTIONS = { + **START_ACTION, + "pause": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "pause", + }, + }, + "stop": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "stop", + }, + }, + "return_to_base": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "return_to_base", + }, + }, + "clean_spot": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "clean_spot", + }, + }, + "locate": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "locate", + }, + }, + "set_fan_speed": { + "service": "test.automation", + "data": { + "caller": "{{ this.entity_id }}", + "action": "set_fan_speed", + "fan_speed": "{{ fan_speed }}", + }, + }, +} + +UNIQUE_ID_CONFIG = {"unique_id": "not-so-unique-anymore", **TEMPLATE_VACUUM_ACTIONS} + + +def _verify( + hass: HomeAssistant, + expected_state: str, + expected_battery_level: int | None = None, + expected_fan_speed: int | None = None, +) -> None: + """Verify vacuum's state and speed.""" + state = hass.states.get(TEST_ENTITY_ID) + attributes = state.attributes + assert state.state == expected_state + assert attributes.get(ATTR_BATTERY_LEVEL) == expected_battery_level + assert attributes.get(ATTR_FAN_SPEED) == expected_fan_speed async def async_setup_legacy_format( hass: HomeAssistant, count: int, vacuum_config: dict[str, Any] ) -> None: - """Do setup of number integration via new format.""" + """Do setup of vacuum integration via new format.""" config = {"vacuum": {"platform": "template", "vacuums": vacuum_config}} with assert_setup_component(count, vacuum.DOMAIN): @@ -49,6 +122,24 @@ async def async_setup_legacy_format( await hass.async_block_till_done() +async def async_setup_modern_format( + hass: HomeAssistant, count: int, vacuum_config: dict[str, Any] +) -> None: + """Do setup of vacuum integration via modern format.""" + config = {"template": {"vacuum": vacuum_config}} + + with assert_setup_component(count, template.DOMAIN): + assert await async_setup_component( + hass, + template.DOMAIN, + config, + ) + + await hass.async_block_till_done() + await hass.async_start() + await hass.async_block_till_done() + + @pytest.fixture async def setup_vacuum( hass: HomeAssistant, @@ -59,6 +150,8 @@ async def setup_vacuum( """Do setup of number integration.""" if style == ConfigurationStyle.LEGACY: await async_setup_legacy_format(hass, count, vacuum_config) + elif style == ConfigurationStyle.MODERN: + await async_setup_modern_format(hass, count, vacuum_config) @pytest.fixture @@ -70,160 +163,406 @@ async def setup_test_vacuum_with_extra_config( extra_config: dict[str, Any], ) -> None: """Do setup of number integration.""" - config = {_TEST_OBJECT_ID: {**vacuum_config, **extra_config}} if style == ConfigurationStyle.LEGACY: - await async_setup_legacy_format(hass, count, config) + await async_setup_legacy_format( + hass, count, {TEST_OBJECT_ID: {**vacuum_config, **extra_config}} + ) + elif style == ConfigurationStyle.MODERN: + await async_setup_modern_format( + hass, count, {"name": TEST_OBJECT_ID, **vacuum_config, **extra_config} + ) -@pytest.mark.parametrize(("count", "domain"), [(1, "vacuum")]) +@pytest.fixture +async def setup_state_vacuum( + hass: HomeAssistant, + count: int, + style: ConfigurationStyle, + state_template: str, +): + """Do setup of vacuum integration using a state template.""" + if style == ConfigurationStyle.LEGACY: + await async_setup_legacy_format( + hass, + count, + { + TEST_OBJECT_ID: { + "value_template": state_template, + **TEMPLATE_VACUUM_ACTIONS, + } + }, + ) + elif style == ConfigurationStyle.MODERN: + await async_setup_modern_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + "state": state_template, + **TEMPLATE_VACUUM_ACTIONS, + }, + ) + + +@pytest.fixture +async def setup_base_vacuum( + hass: HomeAssistant, + count: int, + style: ConfigurationStyle, + state_template: str | None, + extra_config: dict, +): + """Do setup of vacuum integration using a state template.""" + if style == ConfigurationStyle.LEGACY: + state_config = {"value_template": state_template} if state_template else {} + await async_setup_legacy_format( + hass, + count, + { + TEST_OBJECT_ID: { + **state_config, + **extra_config, + } + }, + ) + elif style == ConfigurationStyle.MODERN: + state_config = {"state": state_template} if state_template else {} + await async_setup_modern_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **state_config, + **extra_config, + }, + ) + + +@pytest.fixture +async def setup_single_attribute_state_vacuum( + hass: HomeAssistant, + count: int, + style: ConfigurationStyle, + state_template: str | None, + attribute: str, + attribute_template: str, + extra_config: dict, +) -> None: + """Do setup of vacuum integration testing a single attribute.""" + extra = {attribute: attribute_template} if attribute and attribute_template else {} + if style == ConfigurationStyle.LEGACY: + state_config = {"value_template": state_template} if state_template else {} + await async_setup_legacy_format( + hass, + count, + { + TEST_OBJECT_ID: { + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + **extra, + **extra_config, + } + }, + ) + elif style == ConfigurationStyle.MODERN: + state_config = {"state": state_template} if state_template else {} + await async_setup_modern_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + **extra, + **extra_config, + }, + ) + + +@pytest.fixture +async def setup_attributes_state_vacuum( + hass: HomeAssistant, + count: int, + style: ConfigurationStyle, + state_template: str | None, + attributes: dict, +) -> None: + """Do setup of vacuum integration testing a single attribute.""" + if style == ConfigurationStyle.LEGACY: + state_config = {"value_template": state_template} if state_template else {} + await async_setup_legacy_format( + hass, + count, + { + TEST_OBJECT_ID: { + "attribute_templates": attributes, + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + } + }, + ) + elif style == ConfigurationStyle.MODERN: + state_config = {"state": state_template} if state_template else {} + await async_setup_modern_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + "attributes": attributes, + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + }, + ) + + +@pytest.mark.parametrize("count", [1]) @pytest.mark.parametrize( - ("parm1", "parm2", "config"), + ("style", "state_template", "extra_config", "parm1", "parm2"), [ ( + ConfigurationStyle.LEGACY, + None, + {"start": {"service": "script.vacuum_start"}}, STATE_UNKNOWN, None, - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": {"start": {"service": "script.vacuum_start"}} - }, - } - }, ), ( + ConfigurationStyle.MODERN, + None, + {"start": {"service": "script.vacuum_start"}}, + STATE_UNKNOWN, + None, + ), + ( + ConfigurationStyle.LEGACY, + "{{ 'cleaning' }}", + { + "battery_level_template": "{{ 100 }}", + "start": {"service": "script.vacuum_start"}, + }, VacuumActivity.CLEANING, 100, - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": { - "value_template": "{{ 'cleaning' }}", - "battery_level_template": "{{ 100 }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } - }, ), ( - STATE_UNKNOWN, - None, + ConfigurationStyle.MODERN, + "{{ 'cleaning' }}", { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": { - "value_template": "{{ 'abc' }}", - "battery_level_template": "{{ 101 }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } + "battery_level": "{{ 100 }}", + "start": {"service": "script.vacuum_start"}, }, + VacuumActivity.CLEANING, + 100, ), ( + ConfigurationStyle.LEGACY, + "{{ 'abc' }}", + { + "battery_level_template": "{{ 101 }}", + "start": {"service": "script.vacuum_start"}, + }, STATE_UNKNOWN, None, + ), + ( + ConfigurationStyle.MODERN, + "{{ 'abc' }}", { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": { - "value_template": "{{ this_function_does_not_exist() }}", - "battery_level_template": "{{ this_function_does_not_exist() }}", - "fan_speed_template": "{{ this_function_does_not_exist() }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } + "battery_level": "{{ 101 }}", + "start": {"service": "script.vacuum_start"}, }, + STATE_UNKNOWN, + None, + ), + ( + ConfigurationStyle.LEGACY, + "{{ this_function_does_not_exist() }}", + { + "battery_level_template": "{{ this_function_does_not_exist() }}", + "fan_speed_template": "{{ this_function_does_not_exist() }}", + "start": {"service": "script.vacuum_start"}, + }, + STATE_UNKNOWN, + None, + ), + ( + ConfigurationStyle.MODERN, + "{{ this_function_does_not_exist() }}", + { + "battery_level": "{{ this_function_does_not_exist() }}", + "fan_speed": "{{ this_function_does_not_exist() }}", + "start": {"service": "script.vacuum_start"}, + }, + STATE_UNKNOWN, + None, ), ], ) -@pytest.mark.usefixtures("start_ha") -async def test_valid_configs(hass: HomeAssistant, count, parm1, parm2) -> None: +@pytest.mark.usefixtures("setup_base_vacuum") +async def test_valid_legacy_configs(hass: HomeAssistant, count, parm1, parm2) -> None: """Test: configs.""" assert len(hass.states.async_all("vacuum")) == count _verify(hass, parm1, parm2) -@pytest.mark.parametrize(("count", "domain"), [(0, "vacuum")]) +@pytest.mark.parametrize("count", [0]) @pytest.mark.parametrize( - "config", + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) +@pytest.mark.parametrize( + ("state_template", "extra_config"), [ - { - "vacuum": { - "platform": "template", - "vacuums": {"test_vacuum": {"value_template": "{{ 'on' }}"}}, - } - }, - { - "platform": "template", - "vacuums": {"test_vacuum": {"start": {"service": "script.vacuum_start"}}}, - }, + ("{{ 'on' }}", {}), + (None, {"nothingburger": {"service": "script.vacuum_start"}}), ], ) -@pytest.mark.usefixtures("start_ha") +@pytest.mark.usefixtures("setup_base_vacuum") async def test_invalid_configs(hass: HomeAssistant, count) -> None: """Test: configs.""" assert len(hass.states.async_all("vacuum")) == count @pytest.mark.parametrize( - ("count", "domain", "config"), + ("count", "state_template", "extra_config"), + [(1, "{{ states('input_select.state') }}", {})], +) +@pytest.mark.parametrize( + ("style", "attribute"), [ - ( - 1, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": { - "value_template": "{{ states('input_select.state') }}", - "battery_level_template": "{{ states('input_number.battery_level') }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } - }, - ) + (ConfigurationStyle.LEGACY, "battery_level_template"), + (ConfigurationStyle.MODERN, "battery_level"), ], ) -@pytest.mark.usefixtures("start_ha") -async def test_templates_with_entities(hass: HomeAssistant) -> None: +@pytest.mark.parametrize( + ("attribute_template", "expected"), + [ + ("{{ '0' }}", 0), + ("{{ 100 }}", 100), + ("{{ 101 }}", None), + ("{{ -1 }}", None), + ("{{ 'foo' }}", None), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_battery_level_template( + hass: HomeAssistant, expected: int | None +) -> None: """Test templates with values from other entities.""" - _verify(hass, STATE_UNKNOWN, None) - - hass.states.async_set(_STATE_INPUT_SELECT, VacuumActivity.CLEANING) - hass.states.async_set(_BATTERY_LEVEL_INPUT_NUMBER, 100) - await hass.async_block_till_done() - _verify(hass, VacuumActivity.CLEANING, 100) + _verify(hass, STATE_UNKNOWN, expected) @pytest.mark.parametrize( - ("count", "domain", "config"), + ("count", "state_template", "extra_config"), [ ( 1, - "vacuum", + "{{ states('input_select.state') }}", { - "vacuum": { - "platform": "template", - "vacuums": { - "test_template_vacuum": { - "availability_template": "{{ is_state('availability_state.state', 'on') }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } + "fan_speeds": ["low", "medium", "high"], }, ) ], ) -@pytest.mark.usefixtures("start_ha") +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.LEGACY, "fan_speed_template"), + (ConfigurationStyle.MODERN, "fan_speed"), + ], +) +@pytest.mark.parametrize( + ("attribute_template", "expected"), + [ + ("{{ 'low' }}", "low"), + ("{{ 'medium' }}", "medium"), + ("{{ 'high' }}", "high"), + ("{{ 'invalid' }}", None), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_fan_speed_template(hass: HomeAssistant, expected: str | None) -> None: + """Test templates with values from other entities.""" + _verify(hass, STATE_UNKNOWN, None, expected) + + +@pytest.mark.parametrize( + ("count", "state_template", "attribute_template", "extra_config"), + [ + ( + 1, + "{{ 'on' }}", + "{% if states.switch.test_state.state %}mdi:check{% endif %}", + {}, + ) + ], +) +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.MODERN, "icon"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_icon_template(hass: HomeAssistant) -> None: + """Test icon template.""" + state = hass.states.get(TEST_ENTITY_ID) + assert state.attributes.get("icon") in ("", None) + + hass.states.async_set("switch.test_state", STATE_ON) + await hass.async_block_till_done() + + state = hass.states.get(TEST_ENTITY_ID) + assert state.attributes["icon"] == "mdi:check" + + +@pytest.mark.parametrize( + ("count", "state_template", "attribute_template", "extra_config"), + [ + ( + 1, + "{{ 'on' }}", + "{% if states.switch.test_state.state %}local/vacuum.png{% endif %}", + {}, + ) + ], +) +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.MODERN, "picture"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_picture_template(hass: HomeAssistant) -> None: + """Test picture template.""" + state = hass.states.get(TEST_ENTITY_ID) + assert state.attributes.get("entity_picture") in ("", None) + + hass.states.async_set("switch.test_state", STATE_ON) + await hass.async_block_till_done() + + state = hass.states.get(TEST_ENTITY_ID) + assert state.attributes["entity_picture"] == "local/vacuum.png" + + +@pytest.mark.parametrize("extra_config", [{}]) +@pytest.mark.parametrize( + ("count", "state_template", "attribute_template"), + [ + ( + 1, + None, + "{{ is_state('availability_state.state', 'on') }}", + ) + ], +) +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.LEGACY, "availability_template"), + (ConfigurationStyle.MODERN, "availability"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") async def test_available_template_with_entities(hass: HomeAssistant) -> None: """Test availability templates with values from other entities.""" @@ -232,105 +571,83 @@ async def test_available_template_with_entities(hass: HomeAssistant) -> None: await hass.async_block_till_done() # Device State should not be unavailable - assert hass.states.get("vacuum.test_template_vacuum").state != STATE_UNAVAILABLE + assert hass.states.get(TEST_ENTITY_ID).state != STATE_UNAVAILABLE # When Availability template returns false hass.states.async_set("availability_state.state", STATE_OFF) await hass.async_block_till_done() # device state should be unavailable - assert hass.states.get("vacuum.test_template_vacuum").state == STATE_UNAVAILABLE + assert hass.states.get(TEST_ENTITY_ID).state == STATE_UNAVAILABLE +@pytest.mark.parametrize("extra_config", [{}]) @pytest.mark.parametrize( - ("count", "domain", "config"), + ("count", "state_template", "attribute_template"), [ ( 1, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_template_vacuum": { - "availability_template": "{{ x - 12 }}", - "start": {"service": "script.vacuum_start"}, - } - }, - } - }, + None, + "{{ x - 12 }}", ) ], ) -@pytest.mark.usefixtures("start_ha") +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.LEGACY, "availability_template"), + (ConfigurationStyle.MODERN, "availability"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") async def test_invalid_availability_template_keeps_component_available( hass: HomeAssistant, caplog_setup_text ) -> None: """Test that an invalid availability keeps the device available.""" - assert hass.states.get("vacuum.test_template_vacuum") != STATE_UNAVAILABLE + assert hass.states.get(TEST_ENTITY_ID) != STATE_UNAVAILABLE assert "UndefinedError: 'x' is undefined" in caplog_setup_text @pytest.mark.parametrize( - ("count", "domain", "config"), + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) +@pytest.mark.parametrize( + ("count", "state_template", "attributes"), [ ( 1, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_template_vacuum": { - "value_template": "{{ 'cleaning' }}", - "start": {"service": "script.vacuum_start"}, - "attribute_templates": { - "test_attribute": "It {{ states.sensor.test_state.state }}." - }, - } - }, - } - }, + "{{ 'cleaning' }}", + {"test_attribute": "It {{ states.sensor.test_state.state }}."}, ) ], ) -@pytest.mark.usefixtures("start_ha") +@pytest.mark.usefixtures("setup_attributes_state_vacuum") async def test_attribute_templates(hass: HomeAssistant) -> None: """Test attribute_templates template.""" - state = hass.states.get("vacuum.test_template_vacuum") + state = hass.states.get(TEST_ENTITY_ID) assert state.attributes["test_attribute"] == "It ." hass.states.async_set("sensor.test_state", "Works") await hass.async_block_till_done() - await async_update_entity(hass, "vacuum.test_template_vacuum") - state = hass.states.get("vacuum.test_template_vacuum") + await async_update_entity(hass, TEST_ENTITY_ID) + state = hass.states.get(TEST_ENTITY_ID) assert state.attributes["test_attribute"] == "It Works." @pytest.mark.parametrize( - ("count", "domain", "config"), + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) +@pytest.mark.parametrize( + ("count", "state_template", "attributes"), [ ( 1, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "invalid_template": { - "value_template": "{{ states('input_select.state') }}", - "start": {"service": "script.vacuum_start"}, - "attribute_templates": { - "test_attribute": "{{ this_function_does_not_exist() }}" - }, - } - }, - } - }, + "{{ states('input_select.state') }}", + {"test_attribute": "{{ this_function_does_not_exist() }}"}, ) ], ) -@pytest.mark.usefixtures("start_ha") +@pytest.mark.usefixtures("setup_attributes_state_vacuum") async def test_invalid_attribute_template( hass: HomeAssistant, caplog_setup_text ) -> None: @@ -340,420 +657,6 @@ async def test_invalid_attribute_template( assert "TemplateError" in caplog_setup_text -@pytest.mark.parametrize( - ("count", "domain", "config"), - [ - ( - 1, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_template_vacuum_01": { - "unique_id": "not-so-unique-anymore", - "value_template": "{{ true }}", - "start": {"service": "script.vacuum_start"}, - }, - "test_template_vacuum_02": { - "unique_id": "not-so-unique-anymore", - "value_template": "{{ false }}", - "start": {"service": "script.vacuum_start"}, - }, - }, - } - }, - ), - ], -) -@pytest.mark.usefixtures("start_ha") -async def test_unique_id(hass: HomeAssistant) -> None: - """Test unique_id option only creates one vacuum per id.""" - assert len(hass.states.async_all("vacuum")) == 1 - - -async def test_unused_services(hass: HomeAssistant) -> None: - """Test calling unused services raises.""" - await _register_basic_vacuum(hass) - - # Pause vacuum - with pytest.raises(HomeAssistantError): - await common.async_pause(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # Stop vacuum - with pytest.raises(HomeAssistantError): - await common.async_stop(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # Return vacuum to base - with pytest.raises(HomeAssistantError): - await common.async_return_to_base(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # Spot cleaning - with pytest.raises(HomeAssistantError): - await common.async_clean_spot(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # Locate vacuum - with pytest.raises(HomeAssistantError): - await common.async_locate(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # Set fan's speed - with pytest.raises(HomeAssistantError): - await common.async_set_fan_speed(hass, "medium", _TEST_VACUUM) - await hass.async_block_till_done() - - _verify(hass, STATE_UNKNOWN, None) - - -async def test_state_services(hass: HomeAssistant, calls: list[ServiceCall]) -> None: - """Test state services.""" - await _register_components(hass) - - # Start vacuum - await common.async_start(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_STATE_INPUT_SELECT).state == VacuumActivity.CLEANING - _verify(hass, VacuumActivity.CLEANING, None) - assert len(calls) == 1 - assert calls[-1].data["action"] == "start" - assert calls[-1].data["caller"] == _TEST_VACUUM - - # Pause vacuum - await common.async_pause(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_STATE_INPUT_SELECT).state == VacuumActivity.PAUSED - _verify(hass, VacuumActivity.PAUSED, None) - assert len(calls) == 2 - assert calls[-1].data["action"] == "pause" - assert calls[-1].data["caller"] == _TEST_VACUUM - - # Stop vacuum - await common.async_stop(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_STATE_INPUT_SELECT).state == VacuumActivity.IDLE - _verify(hass, VacuumActivity.IDLE, None) - assert len(calls) == 3 - assert calls[-1].data["action"] == "stop" - assert calls[-1].data["caller"] == _TEST_VACUUM - - # Return vacuum to base - await common.async_return_to_base(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_STATE_INPUT_SELECT).state == VacuumActivity.RETURNING - _verify(hass, VacuumActivity.RETURNING, None) - assert len(calls) == 4 - assert calls[-1].data["action"] == "return_to_base" - assert calls[-1].data["caller"] == _TEST_VACUUM - - -async def test_clean_spot_service( - hass: HomeAssistant, calls: list[ServiceCall] -) -> None: - """Test clean spot service.""" - await _register_components(hass) - - # Clean spot - await common.async_clean_spot(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_SPOT_CLEANING_INPUT_BOOLEAN).state == STATE_ON - assert len(calls) == 1 - assert calls[-1].data["action"] == "clean_spot" - assert calls[-1].data["caller"] == _TEST_VACUUM - - -async def test_locate_service(hass: HomeAssistant, calls: list[ServiceCall]) -> None: - """Test locate service.""" - await _register_components(hass) - - # Locate vacuum - await common.async_locate(hass, _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_LOCATING_INPUT_BOOLEAN).state == STATE_ON - assert len(calls) == 1 - assert calls[-1].data["action"] == "locate" - assert calls[-1].data["caller"] == _TEST_VACUUM - - -async def test_set_fan_speed(hass: HomeAssistant, calls: list[ServiceCall]) -> None: - """Test set valid fan speed.""" - await _register_components(hass) - - # Set vacuum's fan speed to high - await common.async_set_fan_speed(hass, "high", _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_FAN_SPEED_INPUT_SELECT).state == "high" - assert len(calls) == 1 - assert calls[-1].data["action"] == "set_fan_speed" - assert calls[-1].data["caller"] == _TEST_VACUUM - assert calls[-1].data["option"] == "high" - - # Set fan's speed to medium - await common.async_set_fan_speed(hass, "medium", _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_FAN_SPEED_INPUT_SELECT).state == "medium" - assert len(calls) == 2 - assert calls[-1].data["action"] == "set_fan_speed" - assert calls[-1].data["caller"] == _TEST_VACUUM - assert calls[-1].data["option"] == "medium" - - -async def test_set_invalid_fan_speed( - hass: HomeAssistant, calls: list[ServiceCall] -) -> None: - """Test set invalid fan speed when fan has valid speed.""" - await _register_components(hass) - - # Set vacuum's fan speed to high - await common.async_set_fan_speed(hass, "high", _TEST_VACUUM) - await hass.async_block_till_done() - - # verify - assert hass.states.get(_FAN_SPEED_INPUT_SELECT).state == "high" - - # Set vacuum's fan speed to 'invalid' - await common.async_set_fan_speed(hass, "invalid", _TEST_VACUUM) - await hass.async_block_till_done() - - # verify fan speed is unchanged - assert hass.states.get(_FAN_SPEED_INPUT_SELECT).state == "high" - - -def _verify( - hass: HomeAssistant, expected_state: str, expected_battery_level: int -) -> None: - """Verify vacuum's state and speed.""" - state = hass.states.get(_TEST_VACUUM) - attributes = state.attributes - assert state.state == expected_state - assert attributes.get(ATTR_BATTERY_LEVEL) == expected_battery_level - - -async def _register_basic_vacuum(hass: HomeAssistant) -> None: - """Register basic vacuum with only required options for testing.""" - with assert_setup_component(1, "input_select"): - assert await setup.async_setup_component( - hass, - "input_select", - { - "input_select": { - "state": {"name": "State", "options": [VacuumActivity.CLEANING]} - } - }, - ) - - with assert_setup_component(1, "vacuum"): - assert await setup.async_setup_component( - hass, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": { - "test_vacuum": { - "start": { - "service": "input_select.select_option", - "data": { - "entity_id": _STATE_INPUT_SELECT, - "option": VacuumActivity.CLEANING, - }, - } - } - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - -async def _register_components(hass: HomeAssistant) -> None: - """Register basic components for testing.""" - with assert_setup_component(2, "input_boolean"): - assert await setup.async_setup_component( - hass, - "input_boolean", - {"input_boolean": {"spot_cleaning": None, "locating": None}}, - ) - - with assert_setup_component(2, "input_select"): - assert await setup.async_setup_component( - hass, - "input_select", - { - "input_select": { - "state": { - "name": "State", - "options": [ - VacuumActivity.CLEANING, - VacuumActivity.DOCKED, - VacuumActivity.IDLE, - VacuumActivity.PAUSED, - VacuumActivity.RETURNING, - ], - }, - "fan_speed": { - "name": "Fan speed", - "options": ["", "low", "medium", "high"], - }, - } - }, - ) - - with assert_setup_component(1, "vacuum"): - test_vacuum_config = { - "value_template": "{{ states('input_select.state') }}", - "fan_speed_template": "{{ states('input_select.fan_speed') }}", - "start": [ - { - "service": "input_select.select_option", - "data": { - "entity_id": _STATE_INPUT_SELECT, - "option": VacuumActivity.CLEANING, - }, - }, - { - "service": "test.automation", - "data_template": { - "action": "start", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "pause": [ - { - "service": "input_select.select_option", - "data": { - "entity_id": _STATE_INPUT_SELECT, - "option": VacuumActivity.PAUSED, - }, - }, - { - "service": "test.automation", - "data_template": { - "action": "pause", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "stop": [ - { - "service": "input_select.select_option", - "data": { - "entity_id": _STATE_INPUT_SELECT, - "option": VacuumActivity.IDLE, - }, - }, - { - "service": "test.automation", - "data_template": { - "action": "stop", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "return_to_base": [ - { - "service": "input_select.select_option", - "data": { - "entity_id": _STATE_INPUT_SELECT, - "option": VacuumActivity.RETURNING, - }, - }, - { - "service": "test.automation", - "data_template": { - "action": "return_to_base", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "clean_spot": [ - { - "service": "input_boolean.turn_on", - "entity_id": _SPOT_CLEANING_INPUT_BOOLEAN, - }, - { - "service": "test.automation", - "data_template": { - "action": "clean_spot", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "locate": [ - { - "service": "input_boolean.turn_on", - "entity_id": _LOCATING_INPUT_BOOLEAN, - }, - { - "service": "test.automation", - "data_template": { - "action": "locate", - "caller": "{{ this.entity_id }}", - }, - }, - ], - "set_fan_speed": [ - { - "service": "input_select.select_option", - "data_template": { - "entity_id": _FAN_SPEED_INPUT_SELECT, - "option": "{{ fan_speed }}", - }, - }, - { - "service": "test.automation", - "data_template": { - "action": "set_fan_speed", - "caller": "{{ this.entity_id }}", - "option": "{{ fan_speed }}", - }, - }, - ], - "fan_speeds": ["low", "medium", "high"], - "attribute_templates": { - "test_attribute": "It {{ states.sensor.test_state.state }}." - }, - } - - assert await setup.async_setup_component( - hass, - "vacuum", - { - "vacuum": { - "platform": "template", - "vacuums": {"test_vacuum": test_vacuum_config}, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - @pytest.mark.parametrize("count", [1]) @pytest.mark.parametrize( ("style", "vacuum_config"), @@ -761,11 +664,262 @@ async def _register_components(hass: HomeAssistant) -> None: ( ConfigurationStyle.LEGACY, { - "start": [], + "test_template_vacuum_01": { + "value_template": "{{ true }}", + **UNIQUE_ID_CONFIG, + }, + "test_template_vacuum_02": { + "value_template": "{{ false }}", + **UNIQUE_ID_CONFIG, + }, }, ), + ( + ConfigurationStyle.MODERN, + [ + { + "name": "test_template_vacuum_01", + "state": "{{ true }}", + **UNIQUE_ID_CONFIG, + }, + { + "name": "test_template_vacuum_02", + "state": "{{ false }}", + **UNIQUE_ID_CONFIG, + }, + ], + ), ], ) +@pytest.mark.usefixtures("setup_vacuum") +async def test_unique_id(hass: HomeAssistant) -> None: + """Test unique_id option only creates one vacuum per id.""" + assert len(hass.states.async_all("vacuum")) == 1 + + +@pytest.mark.parametrize( + ("count", "state_template", "extra_config"), [(1, None, START_ACTION)] +) +@pytest.mark.parametrize( + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) +@pytest.mark.usefixtures("setup_base_vacuum") +async def test_unused_services(hass: HomeAssistant) -> None: + """Test calling unused services raises.""" + # Pause vacuum + with pytest.raises(HomeAssistantError): + await common.async_pause(hass, TEST_ENTITY_ID) + await hass.async_block_till_done() + + # Stop vacuum + with pytest.raises(HomeAssistantError): + await common.async_stop(hass, TEST_ENTITY_ID) + await hass.async_block_till_done() + + # Return vacuum to base + with pytest.raises(HomeAssistantError): + await common.async_return_to_base(hass, TEST_ENTITY_ID) + await hass.async_block_till_done() + + # Spot cleaning + with pytest.raises(HomeAssistantError): + await common.async_clean_spot(hass, TEST_ENTITY_ID) + await hass.async_block_till_done() + + # Locate vacuum + with pytest.raises(HomeAssistantError): + await common.async_locate(hass, TEST_ENTITY_ID) + await hass.async_block_till_done() + + # Set fan's speed + with pytest.raises(HomeAssistantError): + await common.async_set_fan_speed(hass, "medium", TEST_ENTITY_ID) + await hass.async_block_till_done() + + _verify(hass, STATE_UNKNOWN, None) + + +@pytest.mark.parametrize( + ("count", "state_template"), + [(1, "{{ states('input_select.state') }}")], +) +@pytest.mark.parametrize( + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) +@pytest.mark.parametrize( + "action", + [ + "start", + "pause", + "stop", + "clean_spot", + "return_to_base", + "locate", + ], +) +@pytest.mark.usefixtures("setup_state_vacuum") +async def test_state_services( + hass: HomeAssistant, action: str, calls: list[ServiceCall] +) -> None: + """Test locate service.""" + + await hass.services.async_call( + "vacuum", + action, + {"entity_id": TEST_ENTITY_ID}, + blocking=True, + ) + await hass.async_block_till_done() + + # verify + assert len(calls) == 1 + assert calls[-1].data["action"] == action + assert calls[-1].data["caller"] == TEST_ENTITY_ID + + +@pytest.mark.parametrize( + ("count", "state_template", "attribute_template", "extra_config"), + [ + ( + 1, + "{{ states('input_select.state') }}", + "{{ states('input_select.fan_speed') }}", + { + "fan_speeds": ["low", "medium", "high"], + }, + ) + ], +) +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.LEGACY, "fan_speed_template"), + (ConfigurationStyle.MODERN, "fan_speed"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_set_fan_speed(hass: HomeAssistant, calls: list[ServiceCall]) -> None: + """Test set valid fan speed.""" + + # Set vacuum's fan speed to high + await common.async_set_fan_speed(hass, "high", TEST_ENTITY_ID) + await hass.async_block_till_done() + + # verify + assert len(calls) == 1 + assert calls[-1].data["action"] == "set_fan_speed" + assert calls[-1].data["caller"] == TEST_ENTITY_ID + assert calls[-1].data["fan_speed"] == "high" + + # Set fan's speed to medium + await common.async_set_fan_speed(hass, "medium", TEST_ENTITY_ID) + await hass.async_block_till_done() + + # verify + assert len(calls) == 2 + assert calls[-1].data["action"] == "set_fan_speed" + assert calls[-1].data["caller"] == TEST_ENTITY_ID + assert calls[-1].data["fan_speed"] == "medium" + + +@pytest.mark.parametrize( + "extra_config", + [ + { + "fan_speeds": ["low", "medium", "high"], + } + ], +) +@pytest.mark.parametrize( + ("count", "state_template", "attribute_template"), + [ + ( + 1, + "{{ states('input_select.state') }}", + "{{ states('input_select.fan_speed') }}", + ) + ], +) +@pytest.mark.parametrize( + ("style", "attribute"), + [ + (ConfigurationStyle.LEGACY, "fan_speed_template"), + (ConfigurationStyle.MODERN, "fan_speed"), + ], +) +@pytest.mark.usefixtures("setup_single_attribute_state_vacuum") +async def test_set_invalid_fan_speed( + hass: HomeAssistant, calls: list[ServiceCall] +) -> None: + """Test set invalid fan speed when fan has valid speed.""" + + # Set vacuum's fan speed to high + await common.async_set_fan_speed(hass, "high", TEST_ENTITY_ID) + await hass.async_block_till_done() + + # verify + assert len(calls) == 1 + assert calls[-1].data["action"] == "set_fan_speed" + assert calls[-1].data["caller"] == TEST_ENTITY_ID + assert calls[-1].data["fan_speed"] == "high" + + # Set vacuum's fan speed to 'invalid' + await common.async_set_fan_speed(hass, "invalid", TEST_ENTITY_ID) + await hass.async_block_till_done() + + # verify fan speed is unchanged + assert len(calls) == 1 + assert calls[-1].data["action"] == "set_fan_speed" + assert calls[-1].data["caller"] == TEST_ENTITY_ID + assert calls[-1].data["fan_speed"] == "high" + + +async def test_nested_unique_id( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: + """Test a template unique_id propagates to switch unique_ids.""" + with assert_setup_component(1, template.DOMAIN): + assert await async_setup_component( + hass, + template.DOMAIN, + { + "template": { + "unique_id": "x", + "vacuum": [ + { + **TEMPLATE_VACUUM_ACTIONS, + "name": "test_a", + "unique_id": "a", + }, + { + **TEMPLATE_VACUUM_ACTIONS, + "name": "test_b", + "unique_id": "b", + }, + ], + }, + }, + ) + + await hass.async_block_till_done() + await hass.async_start() + await hass.async_block_till_done() + + assert len(hass.states.async_all("vacuum")) == 2 + + entry = entity_registry.async_get("vacuum.test_a") + assert entry + assert entry.unique_id == "x-a" + + entry = entity_registry.async_get("vacuum.test_b") + assert entry + assert entry.unique_id == "x-b" + + +@pytest.mark.parametrize(("count", "vacuum_config"), [(1, {"start": []})]) +@pytest.mark.parametrize( + "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] +) @pytest.mark.parametrize( ("extra_config", "supported_features"), [ @@ -813,10 +967,10 @@ async def test_empty_action_config( setup_test_vacuum_with_extra_config, ) -> None: """Test configuration with empty script.""" - await common.async_start(hass, _TEST_VACUUM) + await common.async_start(hass, TEST_ENTITY_ID) await hass.async_block_till_done() - state = hass.states.get(_TEST_VACUUM) + state = hass.states.get(TEST_ENTITY_ID) assert state.attributes["supported_features"] == ( VacuumEntityFeature.STATE | VacuumEntityFeature.START | supported_features )