home-assistant/core
1
0
Fork 1
mirror of https://github.com/home-assistant/core.git synced 2025-09-03 11:51:40 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add update platform to template integration (#150277)

Browse Source
This commit is contained in:
Petro31
2025-08-25 08:43:23 -04:00
committed by GitHub
parent ca37bc1506
commit 58d4fd0b75
9 changed files with 1765 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
homeassistant/components/template/config.py
View File

@@ -26,6 +26,7 @@ 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.update import DOMAIN as DOMAIN_UPDATE
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
@@ -63,6 +64,7 @@ from . import (
select as select_platform,
sensor as sensor_platform,
switch as switch_platform,
update as update_platform,
vacuum as vacuum_platform,
weather as weather_platform,
)
@@ -153,6 +155,9 @@ CONFIG_SECTION_SCHEMA = vol.All(
vol.Optional(DOMAIN_SWITCH): vol.All(
cv.ensure_list, [switch_platform.SWITCH_YAML_SCHEMA]
),
vol.Optional(DOMAIN_UPDATE): vol.All(
cv.ensure_list, [update_platform.UPDATE_YAML_SCHEMA]
),
vol.Optional(DOMAIN_VACUUM): vol.All(
cv.ensure_list, [vacuum_platform.VACUUM_YAML_SCHEMA]
),

51
homeassistant/components/template/config_flow.py
View File

@@ -20,6 +20,7 @@ from homeassistant.components.sensor import (
SensorDeviceClass,
SensorStateClass,
)
from homeassistant.components.update import UpdateDeviceClass
from homeassistant.const import (
CONF_DEVICE_CLASS,
CONF_DEVICE_ID,
@@ -106,6 +107,19 @@ from .select import CONF_OPTIONS, CONF_SELECT_OPTION, async_create_preview_selec
from .sensor import async_create_preview_sensor
from .switch import async_create_preview_switch
from .template_entity import TemplateEntity
from .update import (
CONF_BACKUP,
CONF_IN_PROGRESS,
CONF_INSTALL,
CONF_INSTALLED_VERSION,
CONF_LATEST_VERSION,
CONF_RELEASE_SUMMARY,
CONF_RELEASE_URL,
CONF_SPECIFIC_VERSION,
CONF_TITLE,
CONF_UPDATE_PERCENTAGE,
async_create_preview_update,
)
from .vacuum import (
CONF_FAN_SPEED,
CONF_FAN_SPEED_LIST,
@@ -335,6 +349,31 @@ def generate_schema(domain: str, flow_type: str) -> vol.Schema:
vol.Optional(CONF_TURN_OFF): selector.ActionSelector(),
}
if domain == Platform.UPDATE:
schema |= {
vol.Optional(CONF_INSTALLED_VERSION): selector.TemplateSelector(),
vol.Optional(CONF_LATEST_VERSION): selector.TemplateSelector(),
vol.Optional(CONF_INSTALL): selector.ActionSelector(),
vol.Optional(CONF_IN_PROGRESS): selector.TemplateSelector(),
vol.Optional(CONF_RELEASE_SUMMARY): selector.TemplateSelector(),
vol.Optional(CONF_RELEASE_URL): selector.TemplateSelector(),
vol.Optional(CONF_TITLE): selector.TemplateSelector(),
vol.Optional(CONF_UPDATE_PERCENTAGE): selector.TemplateSelector(),
vol.Optional(CONF_BACKUP): selector.BooleanSelector(),
vol.Optional(CONF_SPECIFIC_VERSION): selector.BooleanSelector(),
}
if flow_type == "config":
schema |= {
vol.Optional(CONF_DEVICE_CLASS): selector.SelectSelector(
selector.SelectSelectorConfig(
options=[cls.value for cls in UpdateDeviceClass],
mode=selector.SelectSelectorMode.DROPDOWN,
translation_key="update_device_class",
sort=True,
),
),
}
if domain == Platform.VACUUM:
schema |= _SCHEMA_STATE | {
vol.Required(SERVICE_START): selector.ActionSelector(),
@@ -470,6 +509,7 @@ TEMPLATE_TYPES = [
Platform.SELECT,
Platform.SENSOR,
Platform.SWITCH,
Platform.UPDATE,
Platform.VACUUM,
]
@@ -539,6 +579,11 @@ CONFIG_FLOW = {
preview="template",
validate_user_input=validate_user_input(Platform.SWITCH),
),
Platform.UPDATE: SchemaFlowFormStep(
config_schema(Platform.UPDATE),
preview="template",
validate_user_input=validate_user_input(Platform.UPDATE),
),
Platform.VACUUM: SchemaFlowFormStep(
config_schema(Platform.VACUUM),
preview="template",
@@ -613,6 +658,11 @@ OPTIONS_FLOW = {
preview="template",
validate_user_input=validate_user_input(Platform.SWITCH),
),
Platform.UPDATE: SchemaFlowFormStep(
options_schema(Platform.UPDATE),
preview="template",
validate_user_input=validate_user_input(Platform.UPDATE),
),
Platform.VACUUM: SchemaFlowFormStep(
options_schema(Platform.VACUUM),
preview="template",
@@ -635,6 +685,7 @@ CREATE_PREVIEW_ENTITY: dict[
Platform.SELECT: async_create_preview_select,
Platform.SENSOR: async_create_preview_sensor,
Platform.SWITCH: async_create_preview_switch,
Platform.UPDATE: async_create_preview_update,
Platform.VACUUM: async_create_preview_vacuum,
}

1
homeassistant/components/template/const.py
View File

@@ -47,6 +47,7 @@ PLATFORMS = [
Platform.SELECT,
Platform.SENSOR,
Platform.SWITCH,
Platform.UPDATE,
Platform.VACUUM,
Platform.WEATHER,
]

90
homeassistant/components/template/strings.json
View File

@@ -393,6 +393,7 @@
"select": "Template a select",
"sensor": "Template a sensor",
"switch": "Template a switch",
"update": "Template an update",
"vacuum": "Template a vacuum"
},
"title": "Template helper"
@@ -424,6 +425,48 @@
},
"title": "Template switch"
},
"update": {
"data": {
"device_id": "[%key:common::config_flow::data::device%]",
"device_class": "[%key:component::template::common::device_class%]",
"name": "[%key:common::config_flow::data::name%]",
"installed_version": "[%key:component::update::entity_component::_::state_attributes::installed_version::name%]",
"latest_version": "[%key:component::update::entity_component::_::state_attributes::latest_version::name%]",
"install": "Actions on install",
"in_progress": "[%key:component::update::entity_component::_::state_attributes::in_progress::name%]",
"release_summary": "[%key:component::update::entity_component::_::state_attributes::release_summary::name%]",
"release_url": "[%key:component::update::entity_component::_::state_attributes::release_url::name%]",
"title": "[%key:component::update::entity_component::_::state_attributes::title::name%]",
"backup": "Backup",
"specific_version": "Specific version",
"update_percent": "Update percentage"
},
"data_description": {
"device_id": "[%key:component::template::common::device_id_description%]",
"installed_version": "Defines a template to get the installed version.",
"latest_version": "Defines a template to get the latest version.",
"install": "Defines actions to run when the update is installed. Receives variables `specific_version` and `backup` when enabled.",
"in_progress": "Defines a template to get the in-progress state.",
"release_summary": "Defines a template to get the release summary.",
"release_url": "Defines a template to get the release URL.",
"title": "Defines a template to get the update title.",
"backup": "Enable or disable the `automatic backup before update` option in the update repair. When disabled, the `backup` variable will always provide `False` during the `install` action and it will not accept the `backup` option.",
"specific_version": "Enable or disable using the `version` variable with the `install` action. When disabled, the `specific_version` variable will always provide `None` in the `install` actions",
"update_percent": "Defines a template to get the update completion percentage."
},
"sections": {
"advanced_options": {
"name": "[%key:component::template::common::advanced_options%]",
"data": {
"availability": "[%key:component::template::common::availability%]"
},
"data_description": {
"availability": "[%key:component::template::common::availability_description%]"
}
}
},
"title": "Template update"
},
"vacuum": {
"data": {
"device_id": "[%key:common::config_flow::data::device%]",
@@ -853,6 +896,48 @@
},
"title": "[%key:component::template::config::step::switch::title%]"
},
"update": {
"data": {
"device_id": "[%key:common::config_flow::data::device%]",
"device_class": "[%key:component::template::common::device_class%]",
"name": "[%key:common::config_flow::data::name%]",
"installed_version": "[%key:component::update::entity_component::_::state_attributes::installed_version::name%]",
"latest_version": "[%key:component::update::entity_component::_::state_attributes::latest_version::name%]",
"install": "[%key:component::template::config::step::update::data::install%]",
"in_progress": "[%key:component::update::entity_component::_::state_attributes::in_progress::name%]",
"release_summary": "[%key:component::update::entity_component::_::state_attributes::release_summary::name%]",
"release_url": "[%key:component::update::entity_component::_::state_attributes::release_url::name%]",
"title": "[%key:component::update::entity_component::_::state_attributes::title::name%]",
"backup": "[%key:component::template::config::step::update::data::backup%]",
"specific_version": "[%key:component::template::config::step::update::data::specific_version%]",
"update_percent": "[%key:component::template::config::step::update::data::update_percent%]"
},
"data_description": {
"device_id": "[%key:component::template::common::device_id_description%]",
"installed_version": "[%key:component::template::config::step::update::data_description::installed_version%]",
"latest_version": "[%key:component::template::config::step::update::data_description::latest_version%]",
"install": "[%key:component::template::config::step::update::data_description::install%]",
"in_progress": "[%key:component::template::config::step::update::data_description::in_progress%]",
"release_summary": "[%key:component::template::config::step::update::data_description::release_summary%]",
"release_url": "[%key:component::template::config::step::update::data_description::release_url%]",
"title": "[%key:component::template::config::step::update::data_description::title%]",
"backup": "[%key:component::template::config::step::update::data_description::backup%]",
"specific_version": "[%key:component::template::config::step::update::data_description::specific_version%]",
"update_percent": "[%key:component::template::config::step::update::data_description::update_percent%]"
},
"sections": {
"advanced_options": {
"name": "[%key:component::template::common::advanced_options%]",
"data": {
"availability": "[%key:component::template::common::availability%]"
},
"data_description": {
"availability": "[%key:component::template::common::availability_description%]"
}
}
},
"title": "Template update"
},
"vacuum": {
"data": {
"device_id": "[%key:common::config_flow::data::device%]",
@@ -1037,6 +1122,11 @@
"options": {
"none": "No unit of measurement"
}
},
"update_device_class": {
"options": {
"firmware": "[%key:component::update::entity_component::firmware::name%]"
}
}
},
"services": {

463
homeassistant/components/template/update.py Normal file
View File

@@ -0,0 +1,463 @@
"""Support for updates which integrates with other components."""
from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Any
import voluptuous as vol
from homeassistant.components.update import (
ATTR_INSTALLED_VERSION,
ATTR_LATEST_VERSION,
DEVICE_CLASSES_SCHEMA,
DOMAIN as UPDATE_DOMAIN,
ENTITY_ID_FORMAT,
UpdateEntity,
UpdateEntityFeature,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_DEVICE_CLASS,
CONF_NAME,
STATE_UNAVAILABLE,
STATE_UNKNOWN,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import config_validation as cv, template
from homeassistant.helpers.entity_platform import (
AddConfigEntryEntitiesCallback,
AddEntitiesCallback,
)
from homeassistant.helpers.template import _SENTINEL
from homeassistant.helpers.trigger_template_entity import CONF_PICTURE
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from . import TriggerUpdateCoordinator
from .const import DOMAIN
from .entity import AbstractTemplateEntity
from .helpers import (
async_setup_template_entry,
async_setup_template_platform,
async_setup_template_preview,
)
from .template_entity import (
TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
TemplateEntity,
make_template_entity_common_modern_schema,
)
from .trigger_entity import TriggerEntity
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Template Update"
ATTR_BACKUP = "backup"
ATTR_SPECIFIC_VERSION = "specific_version"
CONF_BACKUP = "backup"
CONF_IN_PROGRESS = "in_progress"
CONF_INSTALL = "install"
CONF_INSTALLED_VERSION = "installed_version"
CONF_LATEST_VERSION = "latest_version"
CONF_RELEASE_SUMMARY = "release_summary"
CONF_RELEASE_URL = "release_url"
CONF_SPECIFIC_VERSION = "specific_version"
CONF_TITLE = "title"
CONF_UPDATE_PERCENTAGE = "update_percentage"
UPDATE_COMMON_SCHEMA = vol.Schema(
{
vol.Optional(CONF_BACKUP, default=False): cv.boolean,
vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_IN_PROGRESS): cv.template,
vol.Optional(CONF_INSTALL): cv.SCRIPT_SCHEMA,
vol.Required(CONF_INSTALLED_VERSION): cv.template,
vol.Required(CONF_LATEST_VERSION): cv.template,
vol.Optional(CONF_RELEASE_SUMMARY): cv.template,
vol.Optional(CONF_RELEASE_URL): cv.template,
vol.Optional(CONF_SPECIFIC_VERSION, default=False): cv.boolean,
vol.Optional(CONF_TITLE): cv.template,
vol.Optional(CONF_UPDATE_PERCENTAGE): cv.template,
}
)
UPDATE_YAML_SCHEMA = UPDATE_COMMON_SCHEMA.extend(
make_template_entity_common_modern_schema(DEFAULT_NAME).schema
)
UPDATE_CONFIG_ENTRY_SCHEMA = UPDATE_COMMON_SCHEMA.extend(
TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA.schema
)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the Template update."""
await async_setup_template_platform(
hass,
UPDATE_DOMAIN,
config,
StateUpdateEntity,
TriggerUpdateEntity,
async_add_entities,
discovery_info,
)
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
"""Initialize config entry."""
await async_setup_template_entry(
hass,
config_entry,
async_add_entities,
StateUpdateEntity,
UPDATE_CONFIG_ENTRY_SCHEMA,
)
@callback
def async_create_preview_update(
hass: HomeAssistant, name: str, config: dict[str, Any]
) -> StateUpdateEntity:
"""Create a preview."""
return async_setup_template_preview(
hass,
name,
config,
StateUpdateEntity,
UPDATE_CONFIG_ENTRY_SCHEMA,
)
class AbstractTemplateUpdate(AbstractTemplateEntity, UpdateEntity):
"""Representation of a template update features."""
_entity_id_format = ENTITY_ID_FORMAT
# The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
# This ensures that the __init__ on AbstractTemplateEntity is not called twice.
def __init__(self, config: dict[str, Any]) -> None: # pylint: disable=super-init-not-called
"""Initialize the features."""
self._installed_version_template = config[CONF_INSTALLED_VERSION]
self._latest_version_template = config[CONF_LATEST_VERSION]
self._attr_device_class = config.get(CONF_DEVICE_CLASS)
self._in_progress_template = config.get(CONF_IN_PROGRESS)
self._release_summary_template = config.get(CONF_RELEASE_SUMMARY)
self._release_url_template = config.get(CONF_RELEASE_URL)
self._title_template = config.get(CONF_TITLE)
self._update_percentage_template = config.get(CONF_UPDATE_PERCENTAGE)
self._attr_supported_features = UpdateEntityFeature(0)
if config[CONF_BACKUP]:
self._attr_supported_features |= UpdateEntityFeature.BACKUP
if config[CONF_SPECIFIC_VERSION]:
self._attr_supported_features |= UpdateEntityFeature.SPECIFIC_VERSION
if (
self._in_progress_template is not None
or self._update_percentage_template is not None
):
self._attr_supported_features |= UpdateEntityFeature.PROGRESS
self._optimistic_in_process = (
self._in_progress_template is None
and self._update_percentage_template is not None
)
@callback
def _update_installed_version(self, result: Any) -> None:
if result is None:
self._attr_installed_version = None
return
self._attr_installed_version = cv.string(result)
@callback
def _update_latest_version(self, result: Any) -> None:
if result is None:
self._attr_latest_version = None
return
self._attr_latest_version = cv.string(result)
@callback
def _update_in_process(self, result: Any) -> None:
try:
self._attr_in_progress = cv.boolean(result)
except vol.Invalid:
_LOGGER.error(
"Received invalid in_process value: %s for entity %s. Expected: True, False",
result,
self.entity_id,
)
self._attr_in_progress = False
@callback
def _update_release_summary(self, result: Any) -> None:
if result is None:
self._attr_release_summary = None
return
self._attr_release_summary = cv.string(result)
@callback
def _update_release_url(self, result: Any) -> None:
if result is None:
self._attr_release_url = None
return
try:
self._attr_release_url = cv.url(result)
except vol.Invalid:
_LOGGER.error(
"Received invalid release_url: %s for entity %s",
result,
self.entity_id,
)
self._attr_release_url = None
@callback
def _update_title(self, result: Any) -> None:
if result is None:
self._attr_title = None
return
self._attr_title = cv.string(result)
@callback
def _update_update_percentage(self, result: Any) -> None:
if result is None:
if self._optimistic_in_process:
self._attr_in_progress = False
self._attr_update_percentage = None
return
try:
percentage = vol.All(
vol.Coerce(float),
vol.Range(0, 100, min_included=True, max_included=True),
)(result)
if self._optimistic_in_process:
self._attr_in_progress = True
self._attr_update_percentage = percentage
except vol.Invalid:
_LOGGER.error(
"Received invalid update_percentage: %s for entity %s",
result,
self.entity_id,
)
self._attr_update_percentage = None
async def async_install(
self, version: str | None, backup: bool, **kwargs: Any
) -> None:
"""Install an update."""
await self.async_run_script(
self._action_scripts[CONF_INSTALL],
run_variables={ATTR_SPECIFIC_VERSION: version, ATTR_BACKUP: backup},
context=self._context,
)
class StateUpdateEntity(TemplateEntity, AbstractTemplateUpdate):
"""Representation of a Template update."""
_attr_should_poll = False
def __init__(
self,
hass: HomeAssistant,
config: ConfigType,
unique_id: str | None,
) -> None:
"""Initialize the Template update."""
TemplateEntity.__init__(self, hass, config, unique_id)
AbstractTemplateUpdate.__init__(self, config)
name = self._attr_name
if TYPE_CHECKING:
assert name is not None
# Scripts can be an empty list, therefore we need to check for None
if (install_action := config.get(CONF_INSTALL)) is not None:
self.add_script(CONF_INSTALL, install_action, name, DOMAIN)
self._attr_supported_features |= UpdateEntityFeature.INSTALL
@property
def entity_picture(self) -> str | None:
"""Return the entity picture to use in the frontend."""
# This is needed to override the base update entity functionality
if self._attr_entity_picture is None:
# The default picture for update entities would use `self.platform.platform_name` in
# place of `template`. This does not work when creating an entity preview because
# the platform does not exist for that entity, therefore this is hardcoded as `template`.
return "https://brands.home-assistant.io/_/template/icon.png"
return self._attr_entity_picture
@callback
def _async_setup_templates(self) -> None:
"""Set up templates."""
self.add_template_attribute(
"_attr_installed_version",
self._installed_version_template,
None,
self._update_installed_version,
none_on_template_error=True,
)
self.add_template_attribute(
"_attr_latest_version",
self._latest_version_template,
None,
self._update_latest_version,
none_on_template_error=True,
)
if self._in_progress_template is not None:
self.add_template_attribute(
"_attr_in_progress",
self._in_progress_template,
None,
self._update_in_process,
none_on_template_error=True,
)
if self._release_summary_template is not None:
self.add_template_attribute(
"_attr_release_summary",
self._release_summary_template,
None,
self._update_release_summary,
none_on_template_error=True,
)
if self._release_url_template is not None:
self.add_template_attribute(
"_attr_release_url",
self._release_url_template,
None,
self._update_release_url,
none_on_template_error=True,
)
if self._title_template is not None:
self.add_template_attribute(
"_attr_title",
self._title_template,
None,
self._update_title,
none_on_template_error=True,
)
if self._update_percentage_template is not None:
self.add_template_attribute(
"_attr_update_percentage",
self._update_percentage_template,
None,
self._update_update_percentage,
none_on_template_error=True,
)
super()._async_setup_templates()
class TriggerUpdateEntity(TriggerEntity, AbstractTemplateUpdate):
"""Update entity based on trigger data."""
domain = UPDATE_DOMAIN
def __init__(
self,
hass: HomeAssistant,
coordinator: TriggerUpdateCoordinator,
config: ConfigType,
) -> None:
"""Initialize the entity."""
TriggerEntity.__init__(self, hass, coordinator, config)
AbstractTemplateUpdate.__init__(self, config)
for key in (
CONF_INSTALLED_VERSION,
CONF_LATEST_VERSION,
):
self._to_render_simple.append(key)
self._parse_result.add(key)
# Scripts can be an empty list, therefore we need to check for None
if (install_action := config.get(CONF_INSTALL)) is not None:
self.add_script(
CONF_INSTALL,
install_action,
self._rendered.get(CONF_NAME, DEFAULT_NAME),
DOMAIN,
)
self._attr_supported_features |= UpdateEntityFeature.INSTALL
for key in (
CONF_IN_PROGRESS,
CONF_RELEASE_SUMMARY,
CONF_RELEASE_URL,
CONF_TITLE,
CONF_UPDATE_PERCENTAGE,
):
if isinstance(config.get(key), template.Template):
self._to_render_simple.append(key)
self._parse_result.add(key)
# Ensure the entity picture can resolve None to produce the default picture.
if CONF_PICTURE in config:
self._parse_result.add(CONF_PICTURE)
async def async_added_to_hass(self) -> None:
"""Restore last state."""
await super().async_added_to_hass()
if (
(last_state := await self.async_get_last_state()) is not None
and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
and self._attr_installed_version is None
and self._attr_latest_version is None
):
self._attr_installed_version = last_state.attributes[ATTR_INSTALLED_VERSION]
self._attr_latest_version = last_state.attributes[ATTR_LATEST_VERSION]
self.restore_attributes(last_state)
@property
def entity_picture(self) -> str | None:
"""Return entity picture."""
if (picture := self._rendered.get(CONF_PICTURE)) is None:
return UpdateEntity.entity_picture.fget(self) # type: ignore[attr-defined]
return picture
@callback
def _handle_coordinator_update(self) -> None:
"""Handle update of the data."""
self._process_data()
if not self.available:
self.async_write_ha_state()
return
write_ha_state = False
for key, updater in (
(CONF_INSTALLED_VERSION, self._update_installed_version),
(CONF_LATEST_VERSION, self._update_latest_version),
(CONF_IN_PROGRESS, self._update_in_process),
(CONF_RELEASE_SUMMARY, self._update_release_summary),
(CONF_RELEASE_URL, self._update_release_url),
(CONF_TITLE, self._update_title),
(CONF_UPDATE_PERCENTAGE, self._update_update_percentage),
):
if (rendered := self._rendered.get(key, _SENTINEL)) is not _SENTINEL:
updater(rendered)
write_ha_state = True
if len(self._rendered) > 0:
# In case any non optimistic template
write_ha_state = True
if write_ha_state:
self.async_write_ha_state()

26
tests/components/template/snapshots/test_update.ambr Normal file
View File

@@ -0,0 +1,26 @@
# serializer version: 1
# name: test_setup_config_entry
StateSnapshot({
'attributes': ReadOnlyDict({
'auto_update': False,
'display_precision': 0,
'entity_picture': 'https://brands.home-assistant.io/_/template/icon.png',
'friendly_name': 'template_update',
'in_progress': False,
'installed_version': '1.0',
'latest_version': '2.0',
'release_summary': None,
'release_url': None,
'skipped_version': None,
'supported_features': <UpdateEntityFeature: 0>,
'title': None,
'update_percentage': None,
}),
'context': <ANY>,
'entity_id': 'update.template_update',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

32
tests/components/template/test_config_flow.py
View File

@@ -249,6 +249,16 @@ BINARY_SENSOR_OPTIONS = {
{},
{},
),
(
"update",
{"installed_version": "{{ states('update.one') }}"},
"off",
{"one": "2.0", "two": "1.0"},
{},
{"latest_version": "{{ '2.0' }}"},
{"latest_version": "{{ '2.0' }}"},
{},
),
(
"vacuum",
{"state": "{{ states('vacuum.one') }}"},
@@ -440,6 +450,12 @@ async def test_config_flow(
{"options": "{{ ['off', 'on', 'auto'] }}"},
{"options": "{{ ['off', 'on', 'auto'] }}"},
),
(
"update",
{"installed_version": "{{ states('update.one') }}"},
{"latest_version": "{{ '2.0' }}"},
{"latest_version": "{{ '2.0' }}"},
),
(
"vacuum",
{"state": "{{ states('vacuum.one') }}"},
@@ -715,6 +731,16 @@ async def test_config_flow_device(
{},
"value_template",
),
(
"update",
{"installed_version": "{{ states('update.one') }}"},
{"installed_version": "{{ states('update.two') }}"},
["off", "on"],
{"one": "2.0", "two": "1.0"},
{"latest_version": "{{ '2.0' }}"},
{"latest_version": "{{ '2.0' }}"},
"installed_version",
),
(
"vacuum",
{"state": "{{ states('vacuum.one') }}"},
@@ -1570,6 +1596,12 @@ async def test_option_flow_sensor_preview_config_entry_removed(
{},
{},
),
(
"update",
{"installed_version": "{{ states('update.one') }}"},
{"latest_version": "{{ '2.0' }}"},
{"latest_version": "{{ '2.0' }}"},
),
(
"vacuum",
{"state": "{{ states('vacuum.one') }}"},

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

@@ -376,6 +376,18 @@ async def async_yaml_patch_helper(hass: HomeAssistant, filename: str) -> None:
"event_types": "{{ ['single', 'double'] }}",
},
),
(
{
"template_type": "update",
"name": "My template",
"latest_version": "{{ '1.0' }}",
"installed_version": "{{ '1.0' }}",
},
{
"latest_version": "{{ '1.0' }}",
"installed_version": "{{ '1.0' }}",
},
),
],
)
async def test_change_device(

1085
tests/components/template/test_update.py Normal file
View File

File diff suppressed because it is too large Load Diff