From ba3181d4e77a640df6fb25b3f7e63f219f922af0 Mon Sep 17 00:00:00 2001 From: Franck Nijhof Date: Mon, 12 May 2025 23:52:27 +0200 Subject: [PATCH 01/14] Update pipdeptree to 2.26.1 (#144775) --- requirements_test.txt | 2 +- script/hassfest/docker/Dockerfile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements_test.txt b/requirements_test.txt index 2839d7f7982..aa989cdd0ed 100644 --- a/requirements_test.txt +++ b/requirements_test.txt @@ -18,7 +18,7 @@ pre-commit==4.0.0 pydantic==2.11.3 pylint==3.3.7 pylint-per-file-ignores==1.4.0 -pipdeptree==2.25.1 +pipdeptree==2.26.1 pytest-asyncio==0.26.0 pytest-aiohttp==1.1.0 pytest-cov==6.0.0 diff --git a/script/hassfest/docker/Dockerfile b/script/hassfest/docker/Dockerfile index 306b5901370..71e671ad9ac 100644 --- a/script/hassfest/docker/Dockerfile +++ b/script/hassfest/docker/Dockerfile @@ -24,7 +24,7 @@ RUN --mount=from=ghcr.io/astral-sh/uv:0.7.1,source=/uv,target=/bin/uv \ --no-cache \ -c /usr/src/homeassistant/homeassistant/package_constraints.txt \ -r /usr/src/homeassistant/requirements.txt \ - stdlib-list==0.10.0 pipdeptree==2.25.1 tqdm==4.67.1 ruff==0.11.0 \ + stdlib-list==0.10.0 pipdeptree==2.26.1 tqdm==4.67.1 ruff==0.11.0 \ PyTurboJPEG==1.7.5 go2rtc-client==0.1.2 ha-ffmpeg==3.2.2 hassil==2.2.3 home-assistant-intents==2025.5.7 mutagen==1.47.0 pymicro-vad==1.0.1 pyspeex-noise==1.0.2 LABEL "name"="hassfest" From 0719753be3c42129729c3ded794e75ff6a4b4a42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=85ke=20Strandberg?= Date: Mon, 12 May 2025 23:53:54 +0200 Subject: [PATCH 02/14] Set PARALLEL_UPDATES and update quality_scale for Miele integration (#144770) Set PARALLEL_UPDATES and update quality_scale --- homeassistant/components/miele/binary_sensor.py | 2 ++ homeassistant/components/miele/button.py | 2 ++ homeassistant/components/miele/climate.py | 2 ++ homeassistant/components/miele/fan.py | 2 ++ homeassistant/components/miele/light.py | 2 ++ .../components/miele/quality_scale.yaml | 17 +++++++++++------ homeassistant/components/miele/sensor.py | 2 ++ homeassistant/components/miele/switch.py | 2 ++ homeassistant/components/miele/vacuum.py | 2 ++ 9 files changed, 27 insertions(+), 6 deletions(-) diff --git a/homeassistant/components/miele/binary_sensor.py b/homeassistant/components/miele/binary_sensor.py index 9b0868beed4..b43bd86010e 100644 --- a/homeassistant/components/miele/binary_sensor.py +++ b/homeassistant/components/miele/binary_sensor.py @@ -23,6 +23,8 @@ from .const import MieleAppliance from .coordinator import MieleConfigEntry from .entity import MieleEntity +PARALLEL_UPDATES = 0 + _LOGGER = logging.getLogger(__name__) diff --git a/homeassistant/components/miele/button.py b/homeassistant/components/miele/button.py index b749ce364f0..4086c002743 100644 --- a/homeassistant/components/miele/button.py +++ b/homeassistant/components/miele/button.py @@ -17,6 +17,8 @@ from .const import DOMAIN, PROCESS_ACTION, MieleActions, MieleAppliance from .coordinator import MieleConfigEntry from .entity import MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) diff --git a/homeassistant/components/miele/climate.py b/homeassistant/components/miele/climate.py index 4324444d987..85235322616 100644 --- a/homeassistant/components/miele/climate.py +++ b/homeassistant/components/miele/climate.py @@ -26,6 +26,8 @@ from .const import DEVICE_TYPE_TAGS, DISABLED_TEMP_ENTITIES, DOMAIN, MieleApplia from .coordinator import MieleConfigEntry, MieleDataUpdateCoordinator from .entity import MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) diff --git a/homeassistant/components/miele/fan.py b/homeassistant/components/miele/fan.py index e8bea197f58..5faaa46b33c 100644 --- a/homeassistant/components/miele/fan.py +++ b/homeassistant/components/miele/fan.py @@ -27,6 +27,8 @@ from .const import DOMAIN, POWER_OFF, POWER_ON, VENTILATION_STEP, MieleAppliance from .coordinator import MieleConfigEntry, MieleDataUpdateCoordinator from .entity import MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) SPEED_RANGE = (1, 4) diff --git a/homeassistant/components/miele/light.py b/homeassistant/components/miele/light.py index 678c2f92382..e918b93b12a 100644 --- a/homeassistant/components/miele/light.py +++ b/homeassistant/components/miele/light.py @@ -23,6 +23,8 @@ from .const import AMBIENT_LIGHT, DOMAIN, LIGHT, LIGHT_OFF, LIGHT_ON, MieleAppli from .coordinator import MieleConfigEntry from .entity import MieleDevice, MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) diff --git a/homeassistant/components/miele/quality_scale.yaml b/homeassistant/components/miele/quality_scale.yaml index e9d229c6a1b..d0c3677db40 100644 --- a/homeassistant/components/miele/quality_scale.yaml +++ b/homeassistant/components/miele/quality_scale.yaml @@ -32,18 +32,23 @@ rules: Handled by a setting in manifest.json as there is no account information in API # Silver - action-exceptions: todo + action-exceptions: + status: done + comment: No custom actions are defined config-entry-unloading: done docs-configuration-parameters: status: exempt comment: No configuration parameters - docs-installation-parameters: todo + docs-installation-parameters: + status: exempt + comment: | + Integration uses account linking via Nabu casa so no installation parameters are needed. entity-unavailable: done integration-owner: done - log-when-unavailable: todo - parallel-updates: - status: exempt - comment: Handled by coordinator + log-when-unavailable: + status: done + comment: Handled by DataUpdateCoordinator + parallel-updates: done reauthentication-flow: done test-coverage: todo diff --git a/homeassistant/components/miele/sensor.py b/homeassistant/components/miele/sensor.py index 64948cf7b83..5a0b9212971 100644 --- a/homeassistant/components/miele/sensor.py +++ b/homeassistant/components/miele/sensor.py @@ -39,6 +39,8 @@ from .const import ( from .coordinator import MieleConfigEntry, MieleDataUpdateCoordinator from .entity import MieleEntity +PARALLEL_UPDATES = 0 + _LOGGER = logging.getLogger(__name__) DISABLED_TEMPERATURE = -32768 diff --git a/homeassistant/components/miele/switch.py b/homeassistant/components/miele/switch.py index 4cd237aa724..af46ef2c917 100644 --- a/homeassistant/components/miele/switch.py +++ b/homeassistant/components/miele/switch.py @@ -28,6 +28,8 @@ from .const import ( from .coordinator import MieleConfigEntry from .entity import MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) diff --git a/homeassistant/components/miele/vacuum.py b/homeassistant/components/miele/vacuum.py index 02d85cabdef..1e14d33f461 100644 --- a/homeassistant/components/miele/vacuum.py +++ b/homeassistant/components/miele/vacuum.py @@ -24,6 +24,8 @@ from .const import DOMAIN, PROCESS_ACTION, PROGRAM_ID, MieleActions, MieleApplia from .coordinator import MieleConfigEntry from .entity import MieleEntity +PARALLEL_UPDATES = 1 + _LOGGER = logging.getLogger(__name__) # The following const classes define program speeds and programs for the vacuum cleaner. From e69ca0cf80a658b56789d2197c6dde594728e673 Mon Sep 17 00:00:00 2001 From: David Rapan Date: Tue, 13 May 2025 00:00:17 +0200 Subject: [PATCH 03/14] Bump aiodhcpwatcher to 1.2.0 (#144769) --- homeassistant/components/dhcp/manifest.json | 2 +- homeassistant/package_constraints.txt | 2 +- requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/homeassistant/components/dhcp/manifest.json b/homeassistant/components/dhcp/manifest.json index c425aafdb00..c3b0121ff2b 100644 --- a/homeassistant/components/dhcp/manifest.json +++ b/homeassistant/components/dhcp/manifest.json @@ -14,7 +14,7 @@ ], "quality_scale": "internal", "requirements": [ - "aiodhcpwatcher==1.1.1", + "aiodhcpwatcher==1.2.0", "aiodiscover==2.7.0", "cached-ipaddress==0.10.0" ] diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt index 37618cb3d54..59437b4c2ae 100644 --- a/homeassistant/package_constraints.txt +++ b/homeassistant/package_constraints.txt @@ -1,6 +1,6 @@ # Automatically generated by gen_requirements_all.py, do not edit -aiodhcpwatcher==1.1.1 +aiodhcpwatcher==1.2.0 aiodiscover==2.7.0 aiodns==3.4.0 aiohasupervisor==0.3.1 diff --git a/requirements_all.txt b/requirements_all.txt index 9c1d08febf8..16592ce1d3f 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -214,7 +214,7 @@ aiobotocore==2.21.1 aiocomelit==0.12.1 # homeassistant.components.dhcp -aiodhcpwatcher==1.1.1 +aiodhcpwatcher==1.2.0 # homeassistant.components.dhcp aiodiscover==2.7.0 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index 7d2b09d68f7..8b29082b212 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -202,7 +202,7 @@ aiobotocore==2.21.1 aiocomelit==0.12.1 # homeassistant.components.dhcp -aiodhcpwatcher==1.1.1 +aiodhcpwatcher==1.2.0 # homeassistant.components.dhcp aiodiscover==2.7.0 From 0128d859995a1e5877e135e06ae5d7ebea96ddff Mon Sep 17 00:00:00 2001 From: Erik Montnemery Date: Tue, 13 May 2025 00:03:37 +0200 Subject: [PATCH 04/14] Move sun conditions to the sun integration (#144742) --- homeassistant/components/sun/condition.py | 136 ++ homeassistant/helpers/condition.py | 109 +- homeassistant/helpers/config_validation.py | 30 +- tests/components/sun/test_condition.py | 1235 +++++++++++++++++ .../components/websocket_api/test_commands.py | 5 +- tests/helpers/test_condition.py | 1223 +--------------- tests/helpers/test_config_validation.py | 7 +- 7 files changed, 1405 insertions(+), 1340 deletions(-) create mode 100644 homeassistant/components/sun/condition.py create mode 100644 tests/components/sun/test_condition.py diff --git a/homeassistant/components/sun/condition.py b/homeassistant/components/sun/condition.py new file mode 100644 index 00000000000..c52ada51e06 --- /dev/null +++ b/homeassistant/components/sun/condition.py @@ -0,0 +1,136 @@ +"""Offer sun based automation rules.""" + +from __future__ import annotations + +from datetime import datetime, timedelta +from typing import cast + +import voluptuous as vol + +from homeassistant.const import CONF_CONDITION, SUN_EVENT_SUNRISE, SUN_EVENT_SUNSET +from homeassistant.core import HomeAssistant +from homeassistant.helpers import config_validation as cv +from homeassistant.helpers.condition import ( + ConditionCheckerType, + condition_trace_set_result, + condition_trace_update_result, + trace_condition_function, +) +from homeassistant.helpers.sun import get_astral_event_date +from homeassistant.helpers.typing import ConfigType, TemplateVarsType +from homeassistant.util import dt as dt_util + +CONDITION_SCHEMA = vol.All( + vol.Schema( + { + **cv.CONDITION_BASE_SCHEMA, + vol.Required(CONF_CONDITION): "sun", + vol.Optional("before"): cv.sun_event, + vol.Optional("before_offset"): cv.time_period, + vol.Optional("after"): vol.All( + vol.Lower, vol.Any(SUN_EVENT_SUNSET, SUN_EVENT_SUNRISE) + ), + vol.Optional("after_offset"): cv.time_period, + } + ), + cv.has_at_least_one_key("before", "after"), +) + + +def sun( + hass: HomeAssistant, + before: str | None = None, + after: str | None = None, + before_offset: timedelta | None = None, + after_offset: timedelta | None = None, +) -> bool: + """Test if current time matches sun requirements.""" + utcnow = dt_util.utcnow() + today = dt_util.as_local(utcnow).date() + before_offset = before_offset or timedelta(0) + after_offset = after_offset or timedelta(0) + + sunrise = get_astral_event_date(hass, SUN_EVENT_SUNRISE, today) + sunset = get_astral_event_date(hass, SUN_EVENT_SUNSET, today) + + has_sunrise_condition = SUN_EVENT_SUNRISE in (before, after) + has_sunset_condition = SUN_EVENT_SUNSET in (before, after) + + after_sunrise = today > dt_util.as_local(cast(datetime, sunrise)).date() + if after_sunrise and has_sunrise_condition: + tomorrow = today + timedelta(days=1) + sunrise = get_astral_event_date(hass, SUN_EVENT_SUNRISE, tomorrow) + + after_sunset = today > dt_util.as_local(cast(datetime, sunset)).date() + if after_sunset and has_sunset_condition: + tomorrow = today + timedelta(days=1) + sunset = get_astral_event_date(hass, SUN_EVENT_SUNSET, tomorrow) + + # Special case: before sunrise OR after sunset + # This will handle the very rare case in the polar region when the sun rises/sets + # but does not set/rise. + # However this entire condition does not handle those full days of darkness + # or light, the following should be used instead: + # + # condition: + # condition: state + # entity_id: sun.sun + # state: 'above_horizon' (or 'below_horizon') + # + if before == SUN_EVENT_SUNRISE and after == SUN_EVENT_SUNSET: + wanted_time_before = cast(datetime, sunrise) + before_offset + condition_trace_update_result(wanted_time_before=wanted_time_before) + wanted_time_after = cast(datetime, sunset) + after_offset + condition_trace_update_result(wanted_time_after=wanted_time_after) + return utcnow < wanted_time_before or utcnow > wanted_time_after + + if sunrise is None and has_sunrise_condition: + # There is no sunrise today + condition_trace_set_result(False, message="no sunrise today") + return False + + if sunset is None and has_sunset_condition: + # There is no sunset today + condition_trace_set_result(False, message="no sunset today") + return False + + if before == SUN_EVENT_SUNRISE: + wanted_time_before = cast(datetime, sunrise) + before_offset + condition_trace_update_result(wanted_time_before=wanted_time_before) + if utcnow > wanted_time_before: + return False + + if before == SUN_EVENT_SUNSET: + wanted_time_before = cast(datetime, sunset) + before_offset + condition_trace_update_result(wanted_time_before=wanted_time_before) + if utcnow > wanted_time_before: + return False + + if after == SUN_EVENT_SUNRISE: + wanted_time_after = cast(datetime, sunrise) + after_offset + condition_trace_update_result(wanted_time_after=wanted_time_after) + if utcnow < wanted_time_after: + return False + + if after == SUN_EVENT_SUNSET: + wanted_time_after = cast(datetime, sunset) + after_offset + condition_trace_update_result(wanted_time_after=wanted_time_after) + if utcnow < wanted_time_after: + return False + + return True + + +def async_condition_from_config(config: ConfigType) -> ConditionCheckerType: + """Wrap action method with sun based condition.""" + before = config.get("before") + after = config.get("after") + before_offset = config.get("before_offset") + after_offset = config.get("after_offset") + + @trace_condition_function + def sun_if(hass: HomeAssistant, variables: TemplateVarsType = None) -> bool: + """Validate time based if-condition.""" + return sun(hass, before, after, before_offset, after_offset) + + return sun_if diff --git a/homeassistant/helpers/condition.py b/homeassistant/helpers/condition.py index fa2dd42589b..c1b87dd755a 100644 --- a/homeassistant/helpers/condition.py +++ b/homeassistant/helpers/condition.py @@ -42,8 +42,6 @@ from homeassistant.const import ( ENTITY_MATCH_ANY, STATE_UNAVAILABLE, STATE_UNKNOWN, - SUN_EVENT_SUNRISE, - SUN_EVENT_SUNSET, WEEKDAYS, ) from homeassistant.core import HomeAssistant, State, callback @@ -60,7 +58,6 @@ from homeassistant.util import dt as dt_util from homeassistant.util.async_ import run_callback_threadsafe from . import config_validation as cv, entity_registry as er -from .sun import get_astral_event_date from .template import Template, render_complex from .trace import ( TraceElement, @@ -85,7 +82,6 @@ _PLATFORM_ALIASES = { "numeric_state": None, "or": None, "state": None, - "sun": None, "template": None, "time": None, "trigger": None, @@ -655,105 +651,6 @@ def state_from_config(config: ConfigType) -> ConditionCheckerType: return if_state -def sun( - hass: HomeAssistant, - before: str | None = None, - after: str | None = None, - before_offset: timedelta | None = None, - after_offset: timedelta | None = None, -) -> bool: - """Test if current time matches sun requirements.""" - utcnow = dt_util.utcnow() - today = dt_util.as_local(utcnow).date() - before_offset = before_offset or timedelta(0) - after_offset = after_offset or timedelta(0) - - sunrise = get_astral_event_date(hass, SUN_EVENT_SUNRISE, today) - sunset = get_astral_event_date(hass, SUN_EVENT_SUNSET, today) - - has_sunrise_condition = SUN_EVENT_SUNRISE in (before, after) - has_sunset_condition = SUN_EVENT_SUNSET in (before, after) - - after_sunrise = today > dt_util.as_local(cast(datetime, sunrise)).date() - if after_sunrise and has_sunrise_condition: - tomorrow = today + timedelta(days=1) - sunrise = get_astral_event_date(hass, SUN_EVENT_SUNRISE, tomorrow) - - after_sunset = today > dt_util.as_local(cast(datetime, sunset)).date() - if after_sunset and has_sunset_condition: - tomorrow = today + timedelta(days=1) - sunset = get_astral_event_date(hass, SUN_EVENT_SUNSET, tomorrow) - - # Special case: before sunrise OR after sunset - # This will handle the very rare case in the polar region when the sun rises/sets - # but does not set/rise. - # However this entire condition does not handle those full days of darkness - # or light, the following should be used instead: - # - # condition: - # condition: state - # entity_id: sun.sun - # state: 'above_horizon' (or 'below_horizon') - # - if before == SUN_EVENT_SUNRISE and after == SUN_EVENT_SUNSET: - wanted_time_before = cast(datetime, sunrise) + before_offset - condition_trace_update_result(wanted_time_before=wanted_time_before) - wanted_time_after = cast(datetime, sunset) + after_offset - condition_trace_update_result(wanted_time_after=wanted_time_after) - return utcnow < wanted_time_before or utcnow > wanted_time_after - - if sunrise is None and has_sunrise_condition: - # There is no sunrise today - condition_trace_set_result(False, message="no sunrise today") - return False - - if sunset is None and has_sunset_condition: - # There is no sunset today - condition_trace_set_result(False, message="no sunset today") - return False - - if before == SUN_EVENT_SUNRISE: - wanted_time_before = cast(datetime, sunrise) + before_offset - condition_trace_update_result(wanted_time_before=wanted_time_before) - if utcnow > wanted_time_before: - return False - - if before == SUN_EVENT_SUNSET: - wanted_time_before = cast(datetime, sunset) + before_offset - condition_trace_update_result(wanted_time_before=wanted_time_before) - if utcnow > wanted_time_before: - return False - - if after == SUN_EVENT_SUNRISE: - wanted_time_after = cast(datetime, sunrise) + after_offset - condition_trace_update_result(wanted_time_after=wanted_time_after) - if utcnow < wanted_time_after: - return False - - if after == SUN_EVENT_SUNSET: - wanted_time_after = cast(datetime, sunset) + after_offset - condition_trace_update_result(wanted_time_after=wanted_time_after) - if utcnow < wanted_time_after: - return False - - return True - - -def sun_from_config(config: ConfigType) -> ConditionCheckerType: - """Wrap action method with sun based condition.""" - before = config.get("before") - after = config.get("after") - before_offset = config.get("before_offset") - after_offset = config.get("after_offset") - - @trace_condition_function - def sun_if(hass: HomeAssistant, variables: TemplateVarsType = None) -> bool: - """Validate time based if-condition.""" - return sun(hass, before, after, before_offset, after_offset) - - return sun_if - - def template( hass: HomeAssistant, value_template: Template, variables: TemplateVarsType = None ) -> bool: @@ -1054,8 +951,10 @@ async def async_validate_condition_config( return config platform = await _async_get_condition_platform(hass, config) - if platform is not None and hasattr(platform, "async_validate_condition_config"): - return await platform.async_validate_condition_config(hass, config) + if platform is not None: + if hasattr(platform, "async_validate_condition_config"): + return await platform.async_validate_condition_config(hass, config) + return cast(ConfigType, platform.CONDITION_SCHEMA(config)) if platform is None and condition in ("numeric_state", "state"): validator = cast( Callable[[HomeAssistant, ConfigType], ConfigType], diff --git a/homeassistant/helpers/config_validation.py b/homeassistant/helpers/config_validation.py index 4c760bd9d70..31a3e365071 100644 --- a/homeassistant/helpers/config_validation.py +++ b/homeassistant/helpers/config_validation.py @@ -1090,7 +1090,7 @@ type ValueSchemas = dict[Hashable, VolSchemaType | Callable[[Any], dict[str, Any def key_value_schemas( key: str, value_schemas: ValueSchemas, - default_schema: VolSchemaType | None = None, + default_schema: VolSchemaType | Callable[[Any], dict[str, Any]] | None = None, default_description: str | None = None, ) -> Callable[[Any], dict[Hashable, Any]]: """Create a validator that validates based on a value for specific key. @@ -1745,18 +1745,35 @@ BUILT_IN_CONDITIONS: ValueSchemas = { "numeric_state": NUMERIC_STATE_CONDITION_SCHEMA, "or": OR_CONDITION_SCHEMA, "state": STATE_CONDITION_SCHEMA, - "sun": SUN_CONDITION_SCHEMA, "template": TEMPLATE_CONDITION_SCHEMA, "time": TIME_CONDITION_SCHEMA, "trigger": TRIGGER_CONDITION_SCHEMA, "zone": ZONE_CONDITION_SCHEMA, } + +# This is first round of validation, we don't want to mutate the config here already, +# just ensure basics as condition type and alias are there. +def _base_condition_validator(value: Any) -> Any: + vol.Schema( + { + **CONDITION_BASE_SCHEMA, + CONF_CONDITION: vol.NotIn(BUILT_IN_CONDITIONS), + }, + extra=vol.ALLOW_EXTRA, + )(value) + return value + + CONDITION_SCHEMA: vol.Schema = vol.Schema( vol.Any( vol.All( expand_condition_shorthand, - key_value_schemas(CONF_CONDITION, BUILT_IN_CONDITIONS), + key_value_schemas( + CONF_CONDITION, + BUILT_IN_CONDITIONS, + _base_condition_validator, + ), ), dynamic_template_condition, ) @@ -1783,7 +1800,10 @@ CONDITION_ACTION_SCHEMA: vol.Schema = vol.Schema( key_value_schemas( CONF_CONDITION, BUILT_IN_CONDITIONS, - dynamic_template_condition_action, + vol.Any( + dynamic_template_condition_action, + _base_condition_validator, + ), "a list of conditions or a valid template", ), ) @@ -1842,7 +1862,7 @@ def _base_trigger_list_flatten(triggers: list[Any]) -> list[Any]: return flatlist -# This is first round of validation, we don't want to process the config here already, +# This is first round of validation, we don't want to mutate the config here already, # just ensure basics as platform and ID are there. def _base_trigger_validator(value: Any) -> Any: _base_trigger_validator_schema(value) diff --git a/tests/components/sun/test_condition.py b/tests/components/sun/test_condition.py new file mode 100644 index 00000000000..52c0d885461 --- /dev/null +++ b/tests/components/sun/test_condition.py @@ -0,0 +1,1235 @@ +"""The tests for sun conditions.""" + +from datetime import datetime + +from freezegun import freeze_time +import pytest + +from homeassistant.components import automation +from homeassistant.const import SUN_EVENT_SUNRISE, SUN_EVENT_SUNSET +from homeassistant.core import HomeAssistant, ServiceCall +from homeassistant.helpers import trace +from homeassistant.setup import async_setup_component +from homeassistant.util import dt as dt_util + +from tests.typing import WebSocketGenerator + + +@pytest.fixture(autouse=True) +def prepare_condition_trace() -> None: + """Clear previous trace.""" + trace.trace_clear() + + +def _find_run_id(traces, trace_type, item_id): + """Find newest run_id for a script or automation.""" + for _trace in reversed(traces): + if _trace["domain"] == trace_type and _trace["item_id"] == item_id: + return _trace["run_id"] + + return None + + +async def assert_automation_condition_trace(hass_ws_client, automation_id, expected): + """Test the result of automation condition.""" + msg_id = 1 + + def next_id(): + nonlocal msg_id + msg_id += 1 + return msg_id + + client = await hass_ws_client() + + # List traces + await client.send_json( + {"id": next_id(), "type": "trace/list", "domain": "automation"} + ) + response = await client.receive_json() + assert response["success"] + run_id = _find_run_id(response["result"], "automation", automation_id) + + # Get trace + await client.send_json( + { + "id": next_id(), + "type": "trace/get", + "domain": "automation", + "item_id": "sun", + "run_id": run_id, + } + ) + response = await client.receive_json() + assert response["success"] + trace = response["result"] + assert len(trace["trace"]["condition/0"]) == 1 + condition_trace = trace["trace"]["condition/0"][0]["result"] + assert condition_trace == expected + + +async def test_if_action_before_sunrise_no_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunrise. + + Before sunrise is true from midnight until sunset, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "before": SUN_EVENT_SUNRISE}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise + 1s -> 'before sunrise' not true + now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = sunrise -> 'before sunrise' true + now = datetime(2015, 9, 16, 13, 33, 18, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = local midnight -> 'before sunrise' true + now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = local midnight - 1s -> 'before sunrise' not true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, + ) + + +async def test_if_action_after_sunrise_no_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunrise. + + After sunrise is true from sunrise until midnight, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "after": SUN_EVENT_SUNRISE}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise - 1s -> 'after sunrise' not true + now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = sunrise + 1s -> 'after sunrise' true + now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = local midnight -> 'after sunrise' not true + now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, + ) + + # now = local midnight - 1s -> 'after sunrise' true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, + ) + + +async def test_if_action_before_sunrise_with_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunrise with offset. + + Before sunrise is true from midnight until sunset, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "before": SUN_EVENT_SUNRISE, + "before_offset": "+1:00:00", + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise + 1s + 1h -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 16, 14, 33, 19, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunrise + 1h -> 'before sunrise' with offset +1h true + now = datetime(2015, 9, 16, 14, 33, 18, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = UTC midnight -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 0, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = UTC midnight - 1s -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 16, 23, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local midnight -> 'before sunrise' with offset +1h true + now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local midnight - 1s -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunset -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunset -1s -> 'before sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, + ) + + +async def test_if_action_before_sunset_with_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunset with offset. + + Before sunset is true from midnight until sunset, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "before": "sunset", + "before_offset": "+1:00:00", + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = local midnight -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = sunset + 1s + 1h -> 'before sunset' with offset +1h not true + now = datetime(2015, 9, 17, 2, 53, 46, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = sunset + 1h -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 17, 2, 53, 44, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = UTC midnight -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 17, 0, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 3 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = UTC midnight - 1s -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 16, 23, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 4 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = sunrise -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 16, 13, 33, 18, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 5 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = sunrise -1s -> 'before sunset' with offset +1h true + now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 6 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = local midnight-1s -> 'after sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 6 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, + ) + + +async def test_if_action_after_sunrise_with_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunrise with offset. + + After sunrise is true from sunrise until midnight, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "after": SUN_EVENT_SUNRISE, + "after_offset": "+1:00:00", + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise - 1s + 1h -> 'after sunrise' with offset +1h not true + now = datetime(2015, 9, 16, 14, 33, 17, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunrise + 1h -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 16, 14, 33, 58, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = UTC noon -> 'after sunrise' with offset +1h not true + now = datetime(2015, 9, 16, 12, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = UTC noon - 1s -> 'after sunrise' with offset +1h not true + now = datetime(2015, 9, 16, 11, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local noon -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 16, 19, 1, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local noon - 1s -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 16, 18, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 3 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunset -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 4 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = sunset + 1s -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 5 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local midnight-1s -> 'after sunrise' with offset +1h true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 6 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, + ) + + # now = local midnight -> 'after sunrise' with offset +1h not true + now = datetime(2015, 9, 17, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 6 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-17T14:33:57.053037+00:00"}, + ) + + +async def test_if_action_after_sunset_with_offset( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunset with offset. + + After sunset is true from sunset until midnight, local time. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "after": "sunset", + "after_offset": "+1:00:00", + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunset - 1s + 1h -> 'after sunset' with offset +1h not true + now = datetime(2015, 9, 17, 2, 53, 44, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = sunset + 1h -> 'after sunset' with offset +1h true + now = datetime(2015, 9, 17, 2, 53, 45, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, + ) + + # now = midnight-1s -> 'after sunset' with offset +1h true + now = datetime(2015, 9, 16, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-09-16T02:55:06.099767+00:00"}, + ) + + # now = midnight -> 'after sunset' with offset +1h not true + now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, + ) + + +async def test_if_action_after_and_before_during( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunrise and before sunset. + + This is true from sunrise until sunset. + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "after": SUN_EVENT_SUNRISE, + "before": SUN_EVENT_SUNSET, + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise - 1s -> 'after sunrise' + 'before sunset' not true + now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": False, + "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = sunset + 1s -> 'after sunrise' + 'before sunset' not true + now = datetime(2015, 9, 17, 1, 53, 46, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-09-17T01:53:44.723614+00:00"}, + ) + + # now = sunrise + 1s -> 'after sunrise' + 'before sunset' true + now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = sunset - 1s -> 'after sunrise' + 'before sunset' true + now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = 9AM local -> 'after sunrise' + 'before sunset' true + now = datetime(2015, 9, 16, 16, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 3 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + +async def test_if_action_before_or_after_during( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunrise or after sunset. + + This is true from midnight until sunrise and from sunset until midnight + """ + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": { + "condition": "sun", + "before": SUN_EVENT_SUNRISE, + "after": SUN_EVENT_SUNSET, + }, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local + # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC + # now = sunrise - 1s -> 'before sunrise' | 'after sunset' true + now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = sunset + 1s -> 'before sunrise' | 'after sunset' true + now = datetime(2015, 9, 17, 1, 53, 46, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = sunrise + 1s -> 'before sunrise' | 'after sunset' false + now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": False, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = sunset - 1s -> 'before sunrise' | 'after sunset' false + now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": False, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = midnight + 1s local -> 'before sunrise' | 'after sunset' true + now = datetime(2015, 9, 16, 7, 0, 1, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 3 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + # now = midnight - 1s local -> 'before sunrise' | 'after sunset' true + now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 4 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + { + "result": True, + "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", + "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", + }, + ) + + +async def test_if_action_before_sunrise_no_offset_kotzebue( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunrise. + + Local timezone: Alaska time + Location: Kotzebue, which has a very skewed local timezone with sunrise + at 7 AM and sunset at 3AM during summer + After sunrise is true from sunrise until midnight, local time. + """ + await hass.config.async_set_time_zone("America/Anchorage") + hass.config.latitude = 66.5 + hass.config.longitude = 162.4 + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "before": SUN_EVENT_SUNRISE}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local + # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC + # now = sunrise + 1s -> 'before sunrise' not true + now = datetime(2015, 7, 24, 15, 21, 13, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = sunrise - 1h -> 'before sunrise' true + now = datetime(2015, 7, 24, 14, 21, 12, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = local midnight -> 'before sunrise' true + now = datetime(2015, 7, 24, 8, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = local midnight - 1s -> 'before sunrise' not true + now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-07-23T15:12:19.155123+00:00"}, + ) + + +async def test_if_action_after_sunrise_no_offset_kotzebue( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunrise. + + Local timezone: Alaska time + Location: Kotzebue, which has a very skewed local timezone with sunrise + at 7 AM and sunset at 3AM during summer + Before sunrise is true from midnight until sunrise, local time. + """ + await hass.config.async_set_time_zone("America/Anchorage") + hass.config.latitude = 66.5 + hass.config.longitude = 162.4 + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "after": SUN_EVENT_SUNRISE}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local + # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC + # now = sunrise -> 'after sunrise' true + now = datetime(2015, 7, 24, 15, 21, 12, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = sunrise - 1h -> 'after sunrise' not true + now = datetime(2015, 7, 24, 14, 21, 12, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = local midnight -> 'after sunrise' not true + now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, + ) + + # now = local midnight - 1s -> 'after sunrise' true + now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-07-23T15:12:19.155123+00:00"}, + ) + + +async def test_if_action_before_sunset_no_offset_kotzebue( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was before sunrise. + + Local timezone: Alaska time + Location: Kotzebue, which has a very skewed local timezone with sunrise + at 7 AM and sunset at 3AM during summer + Before sunset is true from midnight until sunset, local time. + """ + await hass.config.async_set_time_zone("America/Anchorage") + hass.config.latitude = 66.5 + hass.config.longitude = 162.4 + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "before": SUN_EVENT_SUNSET}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local + # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC + # now = sunset + 1s -> 'before sunset' not true + now = datetime(2015, 7, 25, 11, 13, 34, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 0 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-07-25T11:13:32.501837+00:00"}, + ) + + # now = sunset - 1h-> 'before sunset' true + now = datetime(2015, 7, 25, 10, 13, 33, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-07-25T11:13:32.501837+00:00"}, + ) + + # now = local midnight -> 'before sunrise' true + now = datetime(2015, 7, 24, 8, 0, 0, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_before": "2015-07-24T11:17:54.446913+00:00"}, + ) + + # now = local midnight - 1s -> 'before sunrise' not true + now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_before": "2015-07-23T11:22:18.467277+00:00"}, + ) + + +async def test_if_action_after_sunset_no_offset_kotzebue( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + service_calls: list[ServiceCall], +) -> None: + """Test if action was after sunrise. + + Local timezone: Alaska time + Location: Kotzebue, which has a very skewed local timezone with sunrise + at 7 AM and sunset at 3AM during summer + After sunset is true from sunset until midnight, local time. + """ + await hass.config.async_set_time_zone("America/Anchorage") + hass.config.latitude = 66.5 + hass.config.longitude = 162.4 + await async_setup_component( + hass, + automation.DOMAIN, + { + automation.DOMAIN: { + "id": "sun", + "trigger": {"platform": "event", "event_type": "test_event"}, + "condition": {"condition": "sun", "after": SUN_EVENT_SUNSET}, + "action": {"service": "test.automation"}, + } + }, + ) + + # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local + # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC + # now = sunset -> 'after sunset' true + now = datetime(2015, 7, 25, 11, 13, 33, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-07-25T11:13:32.501837+00:00"}, + ) + + # now = sunset - 1s -> 'after sunset' not true + now = datetime(2015, 7, 25, 11, 13, 32, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-07-25T11:13:32.501837+00:00"}, + ) + + # now = local midnight -> 'after sunset' not true + now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 1 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": False, "wanted_time_after": "2015-07-24T11:17:54.446913+00:00"}, + ) + + # now = local midnight - 1s -> 'after sunset' true + now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) + with freeze_time(now): + hass.bus.async_fire("test_event") + await hass.async_block_till_done() + assert len(service_calls) == 2 + await assert_automation_condition_trace( + hass_ws_client, + "sun", + {"result": True, "wanted_time_after": "2015-07-23T11:22:18.467277+00:00"}, + ) diff --git a/tests/components/websocket_api/test_commands.py b/tests/components/websocket_api/test_commands.py index 80e6b8be056..4ca2098550b 100644 --- a/tests/components/websocket_api/test_commands.py +++ b/tests/components/websocket_api/test_commands.py @@ -2529,9 +2529,8 @@ async def test_validate_config_works( "state": "paulus", }, ( - "Unexpected value for condition: 'non_existing'. Expected and, device," - " not, numeric_state, or, state, sun, template, time, trigger, zone " - "@ data[0]" + "Invalid condition \"non_existing\" specified {'condition': " + "'non_existing', 'entity_id': 'hello.world', 'state': 'paulus'}" ), ), # Raises HomeAssistantError diff --git a/tests/helpers/test_condition.py b/tests/helpers/test_condition.py index aac64f6139a..7285301f12b 100644 --- a/tests/helpers/test_condition.py +++ b/tests/helpers/test_condition.py @@ -1,6 +1,6 @@ """Test the condition helper.""" -from datetime import datetime, timedelta +from datetime import timedelta from typing import Any from unittest.mock import AsyncMock, patch @@ -8,7 +8,6 @@ from freezegun import freeze_time import pytest import voluptuous as vol -from homeassistant.components import automation from homeassistant.components.sensor import SensorDeviceClass from homeassistant.const import ( ATTR_DEVICE_CLASS, @@ -17,10 +16,8 @@ from homeassistant.const import ( CONF_DOMAIN, STATE_UNAVAILABLE, STATE_UNKNOWN, - SUN_EVENT_SUNRISE, - SUN_EVENT_SUNSET, ) -from homeassistant.core import HomeAssistant, ServiceCall +from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConditionError, HomeAssistantError from homeassistant.helpers import ( condition, @@ -32,8 +29,6 @@ from homeassistant.helpers.template import Template from homeassistant.setup import async_setup_component from homeassistant.util import dt as dt_util -from tests.typing import WebSocketGenerator - def assert_element(trace_element, expected_element, path): """Assert a trace element is as expected. @@ -2242,1220 +2237,6 @@ async def test_condition_template_invalid_results(hass: HomeAssistant) -> None: assert not test(hass) -def _find_run_id(traces, trace_type, item_id): - """Find newest run_id for a script or automation.""" - for _trace in reversed(traces): - if _trace["domain"] == trace_type and _trace["item_id"] == item_id: - return _trace["run_id"] - - return None - - -async def assert_automation_condition_trace(hass_ws_client, automation_id, expected): - """Test the result of automation condition.""" - msg_id = 1 - - def next_id(): - nonlocal msg_id - msg_id += 1 - return msg_id - - client = await hass_ws_client() - - # List traces - await client.send_json( - {"id": next_id(), "type": "trace/list", "domain": "automation"} - ) - response = await client.receive_json() - assert response["success"] - run_id = _find_run_id(response["result"], "automation", automation_id) - - # Get trace - await client.send_json( - { - "id": next_id(), - "type": "trace/get", - "domain": "automation", - "item_id": "sun", - "run_id": run_id, - } - ) - response = await client.receive_json() - assert response["success"] - trace = response["result"] - assert len(trace["trace"]["condition/0"]) == 1 - condition_trace = trace["trace"]["condition/0"][0]["result"] - assert condition_trace == expected - - -async def test_if_action_before_sunrise_no_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunrise. - - Before sunrise is true from midnight until sunset, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "before": SUN_EVENT_SUNRISE}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise + 1s -> 'before sunrise' not true - now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = sunrise -> 'before sunrise' true - now = datetime(2015, 9, 16, 13, 33, 18, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = local midnight -> 'before sunrise' true - now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = local midnight - 1s -> 'before sunrise' not true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T13:33:18.342542+00:00"}, - ) - - -async def test_if_action_after_sunrise_no_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunrise. - - After sunrise is true from sunrise until midnight, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "after": SUN_EVENT_SUNRISE}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise - 1s -> 'after sunrise' not true - now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = sunrise + 1s -> 'after sunrise' true - now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = local midnight -> 'after sunrise' not true - now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, - ) - - # now = local midnight - 1s -> 'after sunrise' true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T13:33:18.342542+00:00"}, - ) - - -async def test_if_action_before_sunrise_with_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunrise with offset. - - Before sunrise is true from midnight until sunset, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "before": SUN_EVENT_SUNRISE, - "before_offset": "+1:00:00", - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise + 1s + 1h -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 16, 14, 33, 19, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunrise + 1h -> 'before sunrise' with offset +1h true - now = datetime(2015, 9, 16, 14, 33, 18, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = UTC midnight -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 0, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = UTC midnight - 1s -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 16, 23, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local midnight -> 'before sunrise' with offset +1h true - now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local midnight - 1s -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunset -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunset -1s -> 'before sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-16T14:33:18.342542+00:00"}, - ) - - -async def test_if_action_before_sunset_with_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunset with offset. - - Before sunset is true from midnight until sunset, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "before": "sunset", - "before_offset": "+1:00:00", - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = local midnight -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = sunset + 1s + 1h -> 'before sunset' with offset +1h not true - now = datetime(2015, 9, 17, 2, 53, 46, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = sunset + 1h -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 17, 2, 53, 44, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = UTC midnight -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 17, 0, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 3 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = UTC midnight - 1s -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 16, 23, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 4 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = sunrise -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 16, 13, 33, 18, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 5 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = sunrise -1s -> 'before sunset' with offset +1h true - now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 6 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = local midnight-1s -> 'after sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 6 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-17T02:53:44.723614+00:00"}, - ) - - -async def test_if_action_after_sunrise_with_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunrise with offset. - - After sunrise is true from sunrise until midnight, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "after": SUN_EVENT_SUNRISE, - "after_offset": "+1:00:00", - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise - 1s + 1h -> 'after sunrise' with offset +1h not true - now = datetime(2015, 9, 16, 14, 33, 17, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunrise + 1h -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 16, 14, 33, 58, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = UTC noon -> 'after sunrise' with offset +1h not true - now = datetime(2015, 9, 16, 12, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = UTC noon - 1s -> 'after sunrise' with offset +1h not true - now = datetime(2015, 9, 16, 11, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local noon -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 16, 19, 1, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local noon - 1s -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 16, 18, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 3 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunset -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 4 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = sunset + 1s -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 17, 1, 53, 45, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 5 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local midnight-1s -> 'after sunrise' with offset +1h true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 6 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T14:33:18.342542+00:00"}, - ) - - # now = local midnight -> 'after sunrise' with offset +1h not true - now = datetime(2015, 9, 17, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 6 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-17T14:33:57.053037+00:00"}, - ) - - -async def test_if_action_after_sunset_with_offset( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunset with offset. - - After sunset is true from sunset until midnight, local time. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "after": "sunset", - "after_offset": "+1:00:00", - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunset - 1s + 1h -> 'after sunset' with offset +1h not true - now = datetime(2015, 9, 17, 2, 53, 44, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = sunset + 1h -> 'after sunset' with offset +1h true - now = datetime(2015, 9, 17, 2, 53, 45, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, - ) - - # now = midnight-1s -> 'after sunset' with offset +1h true - now = datetime(2015, 9, 16, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-09-16T02:55:06.099767+00:00"}, - ) - - # now = midnight -> 'after sunset' with offset +1h not true - now = datetime(2015, 9, 16, 7, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-09-17T02:53:44.723614+00:00"}, - ) - - -async def test_if_action_after_and_before_during( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunrise and before sunset. - - This is true from sunrise until sunset. - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "after": SUN_EVENT_SUNRISE, - "before": SUN_EVENT_SUNSET, - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise - 1s -> 'after sunrise' + 'before sunset' not true - now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": False, - "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = sunset + 1s -> 'after sunrise' + 'before sunset' not true - now = datetime(2015, 9, 17, 1, 53, 46, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-09-17T01:53:44.723614+00:00"}, - ) - - # now = sunrise + 1s -> 'after sunrise' + 'before sunset' true - now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = sunset - 1s -> 'after sunrise' + 'before sunset' true - now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = 9AM local -> 'after sunrise' + 'before sunset' true - now = datetime(2015, 9, 16, 16, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 3 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_before": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_after": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - -async def test_if_action_before_or_after_during( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunrise or after sunset. - - This is true from midnight until sunrise and from sunset until midnight - """ - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": { - "condition": "sun", - "before": SUN_EVENT_SUNRISE, - "after": SUN_EVENT_SUNSET, - }, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-09-16 06:33:18 local, sunset: 2015-09-16 18:53:45 local - # sunrise: 2015-09-16 13:33:18 UTC, sunset: 2015-09-17 01:53:45 UTC - # now = sunrise - 1s -> 'before sunrise' | 'after sunset' true - now = datetime(2015, 9, 16, 13, 33, 17, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = sunset + 1s -> 'before sunrise' | 'after sunset' true - now = datetime(2015, 9, 17, 1, 53, 46, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = sunrise + 1s -> 'before sunrise' | 'after sunset' false - now = datetime(2015, 9, 16, 13, 33, 19, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": False, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = sunset - 1s -> 'before sunrise' | 'after sunset' false - now = datetime(2015, 9, 17, 1, 53, 44, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": False, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = midnight + 1s local -> 'before sunrise' | 'after sunset' true - now = datetime(2015, 9, 16, 7, 0, 1, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 3 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - # now = midnight - 1s local -> 'before sunrise' | 'after sunset' true - now = datetime(2015, 9, 17, 6, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 4 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - { - "result": True, - "wanted_time_after": "2015-09-17T01:53:44.723614+00:00", - "wanted_time_before": "2015-09-16T13:33:18.342542+00:00", - }, - ) - - -async def test_if_action_before_sunrise_no_offset_kotzebue( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunrise. - - Local timezone: Alaska time - Location: Kotzebue, which has a very skewed local timezone with sunrise - at 7 AM and sunset at 3AM during summer - After sunrise is true from sunrise until midnight, local time. - """ - await hass.config.async_set_time_zone("America/Anchorage") - hass.config.latitude = 66.5 - hass.config.longitude = 162.4 - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "before": SUN_EVENT_SUNRISE}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local - # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC - # now = sunrise + 1s -> 'before sunrise' not true - now = datetime(2015, 7, 24, 15, 21, 13, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = sunrise - 1h -> 'before sunrise' true - now = datetime(2015, 7, 24, 14, 21, 12, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = local midnight -> 'before sunrise' true - now = datetime(2015, 7, 24, 8, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = local midnight - 1s -> 'before sunrise' not true - now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-07-23T15:12:19.155123+00:00"}, - ) - - -async def test_if_action_after_sunrise_no_offset_kotzebue( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunrise. - - Local timezone: Alaska time - Location: Kotzebue, which has a very skewed local timezone with sunrise - at 7 AM and sunset at 3AM during summer - Before sunrise is true from midnight until sunrise, local time. - """ - await hass.config.async_set_time_zone("America/Anchorage") - hass.config.latitude = 66.5 - hass.config.longitude = 162.4 - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "after": SUN_EVENT_SUNRISE}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local - # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC - # now = sunrise -> 'after sunrise' true - now = datetime(2015, 7, 24, 15, 21, 12, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = sunrise - 1h -> 'after sunrise' not true - now = datetime(2015, 7, 24, 14, 21, 12, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = local midnight -> 'after sunrise' not true - now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-07-24T15:16:46.975735+00:00"}, - ) - - # now = local midnight - 1s -> 'after sunrise' true - now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-07-23T15:12:19.155123+00:00"}, - ) - - -async def test_if_action_before_sunset_no_offset_kotzebue( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was before sunrise. - - Local timezone: Alaska time - Location: Kotzebue, which has a very skewed local timezone with sunrise - at 7 AM and sunset at 3AM during summer - Before sunset is true from midnight until sunset, local time. - """ - await hass.config.async_set_time_zone("America/Anchorage") - hass.config.latitude = 66.5 - hass.config.longitude = 162.4 - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "before": SUN_EVENT_SUNSET}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local - # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC - # now = sunset + 1s -> 'before sunset' not true - now = datetime(2015, 7, 25, 11, 13, 34, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 0 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-07-25T11:13:32.501837+00:00"}, - ) - - # now = sunset - 1h-> 'before sunset' true - now = datetime(2015, 7, 25, 10, 13, 33, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-07-25T11:13:32.501837+00:00"}, - ) - - # now = local midnight -> 'before sunrise' true - now = datetime(2015, 7, 24, 8, 0, 0, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_before": "2015-07-24T11:17:54.446913+00:00"}, - ) - - # now = local midnight - 1s -> 'before sunrise' not true - now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_before": "2015-07-23T11:22:18.467277+00:00"}, - ) - - -async def test_if_action_after_sunset_no_offset_kotzebue( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - service_calls: list[ServiceCall], -) -> None: - """Test if action was after sunrise. - - Local timezone: Alaska time - Location: Kotzebue, which has a very skewed local timezone with sunrise - at 7 AM and sunset at 3AM during summer - After sunset is true from sunset until midnight, local time. - """ - await hass.config.async_set_time_zone("America/Anchorage") - hass.config.latitude = 66.5 - hass.config.longitude = 162.4 - await async_setup_component( - hass, - automation.DOMAIN, - { - automation.DOMAIN: { - "id": "sun", - "trigger": {"platform": "event", "event_type": "test_event"}, - "condition": {"condition": "sun", "after": SUN_EVENT_SUNSET}, - "action": {"service": "test.automation"}, - } - }, - ) - - # sunrise: 2015-07-24 07:21:12 local, sunset: 2015-07-25 03:13:33 local - # sunrise: 2015-07-24 15:21:12 UTC, sunset: 2015-07-25 11:13:33 UTC - # now = sunset -> 'after sunset' true - now = datetime(2015, 7, 25, 11, 13, 33, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-07-25T11:13:32.501837+00:00"}, - ) - - # now = sunset - 1s -> 'after sunset' not true - now = datetime(2015, 7, 25, 11, 13, 32, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-07-25T11:13:32.501837+00:00"}, - ) - - # now = local midnight -> 'after sunset' not true - now = datetime(2015, 7, 24, 8, 0, 1, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 1 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": False, "wanted_time_after": "2015-07-24T11:17:54.446913+00:00"}, - ) - - # now = local midnight - 1s -> 'after sunset' true - now = datetime(2015, 7, 24, 7, 59, 59, tzinfo=dt_util.UTC) - with freeze_time(now): - hass.bus.async_fire("test_event") - await hass.async_block_till_done() - assert len(service_calls) == 2 - await assert_automation_condition_trace( - hass_ws_client, - "sun", - {"result": True, "wanted_time_after": "2015-07-23T11:22:18.467277+00:00"}, - ) - - async def test_trigger(hass: HomeAssistant) -> None: """Test trigger condition.""" config = {"alias": "Trigger Cond", "condition": "trigger", "id": "123456"} diff --git a/tests/helpers/test_config_validation.py b/tests/helpers/test_config_validation.py index ecf5271dafd..aec687be40a 100644 --- a/tests/helpers/test_config_validation.py +++ b/tests/helpers/test_config_validation.py @@ -1460,11 +1460,6 @@ def test_key_value_schemas_with_default() -> None: [ ({"delay": "{{ invalid"}, "should be format 'HH:MM'"), ({"wait_template": "{{ invalid"}, "invalid template"), - ({"condition": "invalid"}, "Unexpected value for condition: 'invalid'"), - ( - {"condition": "not", "conditions": {"condition": "invalid"}}, - "Unexpected value for condition: 'invalid'", - ), # The validation error message could be improved to explain that this is not # a valid shorthand template ( @@ -1496,7 +1491,7 @@ def test_key_value_schemas_with_default() -> None: ) @pytest.mark.usefixtures("hass") def test_script(caplog: pytest.LogCaptureFixture, config: dict, error: str) -> None: - """Test script validation is user friendly.""" + """Test script action validation is user friendly.""" with pytest.raises(vol.Invalid, match=error): cv.script_action(config) From b15c9ad130229bd4137f75fc8cd30b27392276d5 Mon Sep 17 00:00:00 2001 From: Maciej Bieniek Date: Tue, 13 May 2025 07:19:07 +0200 Subject: [PATCH 05/14] Link Shelly device entry with Shelly BT scanner entry (#144626) * Add BT address to DeviceInfo.connections * Cleaning * Use bluetooth_source property * Add test * Add connections property --- .../components/shelly/coordinator.py | 21 +++++++++++++++++-- tests/components/shelly/test_coordinator.py | 18 ++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/homeassistant/components/shelly/coordinator.py b/homeassistant/components/shelly/coordinator.py index f980ba8f914..e4af35484c8 100644 --- a/homeassistant/components/shelly/coordinator.py +++ b/homeassistant/components/shelly/coordinator.py @@ -33,7 +33,11 @@ from homeassistant.const import ( from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant, callback from homeassistant.helpers import device_registry as dr, issue_registry as ir from homeassistant.helpers.debounce import Debouncer -from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, format_mac +from homeassistant.helpers.device_registry import ( + CONNECTION_BLUETOOTH, + CONNECTION_NETWORK_MAC, + format_mac, +) from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed from .bluetooth import async_connect_scanner @@ -160,6 +164,11 @@ class ShellyCoordinatorBase[_DeviceT: BlockDevice | RpcDevice]( """Sleep period of the device.""" return self.config_entry.data.get(CONF_SLEEP_PERIOD, 0) + @property + def connections(self) -> set[tuple[str, str]]: + """Connections of the device.""" + return {(CONNECTION_NETWORK_MAC, self.mac)} + def async_setup(self, pending_platforms: list[Platform] | None = None) -> None: """Set up the coordinator.""" self._pending_platforms = pending_platforms @@ -167,7 +176,7 @@ class ShellyCoordinatorBase[_DeviceT: BlockDevice | RpcDevice]( device_entry = dev_reg.async_get_or_create( config_entry_id=self.config_entry.entry_id, name=self.name, - connections={(CONNECTION_NETWORK_MAC, self.mac)}, + connections=self.connections, identifiers={(DOMAIN, self.mac)}, manufacturer="Shelly", model=get_shelly_model_name(self.model, self.sleep_period, self.device), @@ -523,6 +532,14 @@ class ShellyRpcCoordinator(ShellyCoordinatorBase[RpcDevice]): """ return format_mac(bluetooth_mac_from_primary_mac(self.mac)).upper() + @property + def connections(self) -> set[tuple[str, str]]: + """Connections of the device.""" + connections = super().connections + if not self.sleep_period: + connections.add((CONNECTION_BLUETOOTH, self.bluetooth_source)) + return connections + async def async_device_online(self, source: str) -> None: """Handle device going online.""" if not self.sleep_period: diff --git a/tests/components/shelly/test_coordinator.py b/tests/components/shelly/test_coordinator.py index cf7f82014a0..aae452538bb 100644 --- a/tests/components/shelly/test_coordinator.py +++ b/tests/components/shelly/test_coordinator.py @@ -1078,3 +1078,21 @@ async def test_xmod_model_lookup( ) assert device assert device.model == xmod_model + + +async def test_device_entry_bt_address( + hass: HomeAssistant, + device_registry: dr.DeviceRegistry, + mock_rpc_device: Mock, +) -> None: + """Check if BT address is added to device entry connections.""" + entry = await init_integration(hass, 2) + + device = device_registry.async_get_device( + identifiers={(DOMAIN, entry.entry_id)}, + connections={(dr.CONNECTION_NETWORK_MAC, dr.format_mac(entry.unique_id))}, + ) + + assert device + assert len(device.connections) == 2 + assert (dr.CONNECTION_BLUETOOTH, "12:34:56:78:9A:BE") in device.connections From eec617b391972b418b425c078864d4de699aef4d Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Tue, 13 May 2025 07:54:37 +0200 Subject: [PATCH 06/14] Add comments to samsungtv config flow tests (#144787) --- .../components/samsungtv/test_config_flow.py | 36 +++++++++++++------ 1 file changed, 25 insertions(+), 11 deletions(-) diff --git a/tests/components/samsungtv/test_config_flow.py b/tests/components/samsungtv/test_config_flow.py index 83639171576..dd744bd82ca 100644 --- a/tests/components/samsungtv/test_config_flow.py +++ b/tests/components/samsungtv/test_config_flow.py @@ -17,7 +17,10 @@ from websockets import frames from websockets.exceptions import ConnectionClosedError, WebSocketException from homeassistant import config_entries -from homeassistant.components.samsungtv.config_flow import SamsungTVConfigFlow +from homeassistant.components.samsungtv.config_flow import ( + SamsungTVConfigFlow, + _strip_uuid, +) from homeassistant.components.samsungtv.const import ( CONF_MANUFACTURER, CONF_SESSION_ID, @@ -45,6 +48,7 @@ from homeassistant.const import ( ) from homeassistant.core import HomeAssistant from homeassistant.data_entry_flow import BaseServiceInfo, FlowResultType +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo from homeassistant.helpers.service_info.ssdp import ( ATTR_UPNP_FRIENDLY_NAME, @@ -2001,11 +2005,9 @@ async def test_update_incorrect_udn_matching_mac_unique_id_added_from_ssdp( assert entry.unique_id == "be9554b9-c9fb-41f4-8920-22da015376a4" -@pytest.mark.usefixtures( - "remote_websocket", "rest_api", "remote_encrypted_websocket_failing" -) +@pytest.mark.usefixtures("remote_websocket") async def test_update_incorrect_udn_matching_mac_from_dhcp( - hass: HomeAssistant, mock_setup_entry: AsyncMock + hass: HomeAssistant, rest_api: Mock, mock_setup_entry: AsyncMock ) -> None: """Test that DHCP updates the wrong udn from ssdp via mac match.""" entry = MockConfigEntry( @@ -2016,6 +2018,12 @@ async def test_update_incorrect_udn_matching_mac_from_dhcp( ) entry.add_to_hass(hass) + assert entry.data[CONF_HOST] == MOCK_DHCP_DATA.ip + assert entry.data[CONF_MAC] == dr.format_mac( + rest_api.rest_device_info.return_value["device"]["wifiMac"] + ) + assert entry.unique_id != _strip_uuid(rest_api.rest_device_info.return_value["id"]) + result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_DHCP}, @@ -2026,15 +2034,14 @@ async def test_update_incorrect_udn_matching_mac_from_dhcp( assert result["type"] is FlowResultType.ABORT assert result["reason"] == "already_configured" - assert entry.data[CONF_MAC] == "aa:bb:aa:aa:aa:aa" + + # Same IP + same MAC => unique id updated assert entry.unique_id == "be9554b9-c9fb-41f4-8920-22da015376a4" -@pytest.mark.usefixtures( - "remote_websocket", "rest_api", "remote_encrypted_websocket_failing" -) +@pytest.mark.usefixtures("remote_websocket") async def test_no_update_incorrect_udn_not_matching_mac_from_dhcp( - hass: HomeAssistant, mock_setup_entry: AsyncMock + hass: HomeAssistant, rest_api: Mock, mock_setup_entry: AsyncMock ) -> None: """Test that DHCP does not update the wrong udn from ssdp via host match.""" entry = MockConfigEntry( @@ -2045,6 +2052,12 @@ async def test_no_update_incorrect_udn_not_matching_mac_from_dhcp( ) entry.add_to_hass(hass) + assert entry.data[CONF_HOST] == MOCK_DHCP_DATA.ip + assert entry.data[CONF_MAC] != dr.format_mac( + rest_api.rest_device_info.return_value["device"]["wifiMac"] + ) + assert entry.unique_id != _strip_uuid(rest_api.rest_device_info.return_value["id"]) + result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_DHCP}, @@ -2055,7 +2068,8 @@ async def test_no_update_incorrect_udn_not_matching_mac_from_dhcp( assert result["type"] is FlowResultType.FORM assert result["step_id"] == "confirm" - assert entry.data[CONF_MAC] == "aa:bb:ss:ss:dd:pp" + + # Same IP + different MAC => unique id not updated assert entry.unique_id == "0d1cef00-00dc-1000-9c80-4844f7b172de" From d4c2356c70be7280050b8a213c41ccfa2da1b3c1 Mon Sep 17 00:00:00 2001 From: Brett Adams Date: Tue, 13 May 2025 16:05:33 +1000 Subject: [PATCH 07/14] Create stream on demand in Teslemetry (#144777) Create stream on demand --- .../components/teslemetry/__init__.py | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/homeassistant/components/teslemetry/__init__.py b/homeassistant/components/teslemetry/__init__.py index 1eb1ea54091..7b46caf2b43 100644 --- a/homeassistant/components/teslemetry/__init__.py +++ b/homeassistant/components/teslemetry/__init__.py @@ -95,13 +95,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: TeslemetryConfigEntry) - energysites: list[TeslemetryEnergyData] = [] # Create the stream - stream = TeslemetryStream( - session, - access_token, - server=f"{region.lower()}.teslemetry.com", - parse_timestamp=True, - manual=True, - ) + stream: TeslemetryStream | None = None for product in products: if ( @@ -123,6 +117,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: TeslemetryConfigEntry) - serial_number=vin, ) + # Create stream if required + if not stream: + stream = TeslemetryStream( + session, + access_token, + server=f"{region.lower()}.teslemetry.com", + parse_timestamp=True, + manual=True, + ) + remove_listener = stream.async_add_listener( create_handle_vehicle_stream(vin, coordinator), {"vin": vin}, @@ -240,7 +244,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: TeslemetryConfigEntry) - entry.runtime_data = TeslemetryData(vehicles, energysites, scopes) await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) - entry.async_create_background_task(hass, stream.listen(), "Teslemetry Stream") + if stream: + entry.async_create_background_task(hass, stream.listen(), "Teslemetry Stream") return True From 3e07f6543e2edc3721f0f24a969f07df1b2c644a Mon Sep 17 00:00:00 2001 From: Franck Nijhof Date: Tue, 13 May 2025 08:14:55 +0200 Subject: [PATCH 08/14] Update debugpy to v1.8.14 (#144755) --- homeassistant/components/debugpy/manifest.json | 2 +- requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/homeassistant/components/debugpy/manifest.json b/homeassistant/components/debugpy/manifest.json index 21211d334df..0b9f8ea55f5 100644 --- a/homeassistant/components/debugpy/manifest.json +++ b/homeassistant/components/debugpy/manifest.json @@ -6,5 +6,5 @@ "integration_type": "service", "iot_class": "local_push", "quality_scale": "internal", - "requirements": ["debugpy==1.8.13"] + "requirements": ["debugpy==1.8.14"] } diff --git a/requirements_all.txt b/requirements_all.txt index 16592ce1d3f..3d9ca46c149 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -750,7 +750,7 @@ datapoint==0.9.9 dbus-fast==2.43.0 # homeassistant.components.debugpy -debugpy==1.8.13 +debugpy==1.8.14 # homeassistant.components.decora_wifi # decora-wifi==1.4 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index 8b29082b212..3333523b1cc 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -647,7 +647,7 @@ datapoint==0.9.9 dbus-fast==2.43.0 # homeassistant.components.debugpy -debugpy==1.8.13 +debugpy==1.8.14 # homeassistant.components.ecovacs deebot-client==13.1.0 From b0fb16d48d9c46f364f5451cfe3859981029621f Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Tue, 13 May 2025 09:54:26 +0200 Subject: [PATCH 09/14] Remove obsolete compatibility code from SamsungTV (#144800) --- .../components/samsungtv/__init__.py | 33 +--------- tests/components/samsungtv/test_init.py | 63 +------------------ 2 files changed, 4 insertions(+), 92 deletions(-) diff --git a/homeassistant/components/samsungtv/__init__.py b/homeassistant/components/samsungtv/__init__.py index e306e00691f..0fbd0f6d1e0 100644 --- a/homeassistant/components/samsungtv/__init__.py +++ b/homeassistant/components/samsungtv/__init__.py @@ -21,26 +21,19 @@ from homeassistant.const import ( Platform, ) from homeassistant.core import Event, HomeAssistant, callback -from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady +from homeassistant.exceptions import ConfigEntryAuthFailed from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.debounce import Debouncer -from .bridge import ( - SamsungTVBridge, - async_get_device_info, - mac_from_device_info, - model_requires_encryption, -) +from .bridge import SamsungTVBridge, mac_from_device_info, model_requires_encryption from .const import ( CONF_SESSION_ID, CONF_SSDP_MAIN_TV_AGENT_LOCATION, CONF_SSDP_RENDERING_CONTROL_LOCATION, DOMAIN, ENTRY_RELOAD_COOLDOWN, - LEGACY_PORT, LOGGER, METHOD_ENCRYPTED_WEBSOCKET, - METHOD_LEGACY, UPNP_SVC_MAIN_TV_AGENT, UPNP_SVC_RENDERING_CONTROL, ) @@ -180,30 +173,10 @@ async def _async_create_bridge_with_updated_data( """Create a bridge object and update any missing data in the config entry.""" updated_data: dict[str, str | int] = {} host: str = entry.data[CONF_HOST] - port: int | None = entry.data.get(CONF_PORT) - method: str | None = entry.data.get(CONF_METHOD) + method: str = entry.data[CONF_METHOD] load_info_attempted = False info: dict[str, Any] | None = None - if not port or not method: - LOGGER.debug("Attempting to get port or method for %s", host) - if method == METHOD_LEGACY: - port = LEGACY_PORT - else: - # When we imported from yaml we didn't setup the method - # because we didn't know it - _result, port, method, info = await async_get_device_info(hass, host) - load_info_attempted = True - if not port or not method: - raise ConfigEntryNotReady( - translation_domain=DOMAIN, - translation_key="failed_to_determine_connection_method", - ) - - LOGGER.debug("Updated port to %s and method to %s for %s", port, method, host) - updated_data[CONF_PORT] = port - updated_data[CONF_METHOD] = method - bridge = _async_get_device_bridge(hass, {**entry.data, **updated_data}) mac: str | None = entry.data.get(CONF_MAC) diff --git a/tests/components/samsungtv/test_init.py b/tests/components/samsungtv/test_init.py index 0b72a112301..e2e7f2323ed 100644 --- a/tests/components/samsungtv/test_init.py +++ b/tests/components/samsungtv/test_init.py @@ -1,6 +1,5 @@ """Tests for the Samsung TV Integration.""" -from typing import Any from unittest.mock import AsyncMock, Mock, patch import pytest @@ -16,8 +15,6 @@ from homeassistant.components.samsungtv.const import ( CONF_SSDP_MAIN_TV_AGENT_LOCATION, CONF_SSDP_RENDERING_CONTROL_LOCATION, DOMAIN, - LEGACY_PORT, - METHOD_LEGACY, METHOD_WEBSOCKET, UPNP_SVC_MAIN_TV_AGENT, UPNP_SVC_RENDERING_CONTROL, @@ -53,6 +50,7 @@ MOCK_CONFIG = { CONF_HOST: "fake_host", CONF_NAME: "fake_name", CONF_METHOD: METHOD_WEBSOCKET, + CONF_PORT: 8001, } @@ -78,42 +76,6 @@ async def test_setup(hass: HomeAssistant) -> None: ) -async def test_setup_without_port_device_offline(hass: HomeAssistant) -> None: - """Test import from yaml when the device is offline.""" - with ( - patch("homeassistant.components.samsungtv.bridge.Remote", side_effect=OSError), - patch( - "homeassistant.components.samsungtv.bridge.SamsungTVEncryptedWSAsyncRemote.start_listening", - side_effect=OSError, - ), - patch( - "homeassistant.components.samsungtv.bridge.SamsungTVWSAsyncRemote.open", - side_effect=OSError, - ), - patch( - "homeassistant.components.samsungtv.bridge.SamsungTVWSBridge.async_device_info", - return_value=None, - ), - ): - await setup_samsungtv_entry(hass, MOCK_CONFIG) - - config_entries_domain = hass.config_entries.async_entries(DOMAIN) - assert len(config_entries_domain) == 1 - assert config_entries_domain[0].state is ConfigEntryState.SETUP_RETRY - - -@pytest.mark.usefixtures( - "remote_websocket", "remote_encrypted_websocket_failing", "rest_api" -) -async def test_setup_without_port_device_online(hass: HomeAssistant) -> None: - """Test import from yaml when the device is online.""" - await setup_samsungtv_entry(hass, MOCK_CONFIG) - - config_entries_domain = hass.config_entries.async_entries(DOMAIN) - assert len(config_entries_domain) == 1 - assert config_entries_domain[0].data[CONF_MAC] == "aa:bb:aa:aa:aa:aa" - - @pytest.mark.usefixtures("remote_websocket", "remote_encrypted_websocket_failing") async def test_setup_h_j_model( hass: HomeAssistant, rest_api: Mock, caplog: pytest.LogCaptureFixture @@ -182,29 +144,6 @@ async def test_reauth_triggered_encrypted(hass: HomeAssistant) -> None: assert len(flows_in_progress) == 1 -@pytest.mark.usefixtures( - "remote_legacy", "remote_encrypted_websocket_failing", "rest_api_failing" -) -@pytest.mark.parametrize( - "entry_data", - [ - {CONF_HOST: "1.2.3.4"}, # Missing port/method - {CONF_HOST: "1.2.3.4", CONF_PORT: LEGACY_PORT}, # Missing method - {CONF_HOST: "1.2.3.4", CONF_METHOD: METHOD_LEGACY}, # Missing port - ], -) -async def test_update_imported_legacy( - hass: HomeAssistant, entry_data: dict[str, Any] -) -> None: - """Test updating an imported legacy entry.""" - await setup_samsungtv_entry(hass, entry_data) - - entries = hass.config_entries.async_entries(DOMAIN) - assert len(entries) == 1 - assert entries[0].data[CONF_METHOD] == METHOD_LEGACY - assert entries[0].data[CONF_PORT] == LEGACY_PORT - - @pytest.mark.usefixtures("remote_websocket", "rest_api") async def test_incorrectly_formatted_mac_fixed(hass: HomeAssistant) -> None: """Test incorrectly formatted mac is corrected.""" From c121631fef9ed8d3a88805556a4c40af8feeaba3 Mon Sep 17 00:00:00 2001 From: Mick Vleeshouwer Date: Tue, 13 May 2025 10:35:32 +0200 Subject: [PATCH 10/14] Refactor config flow tests to improve result variable usage in Overkiz (#143374) * Refactor test setup for unique ID migration in Overkiz integration * Refactor test cases to unify result variable usage in Overkiz config flow tests (resultn -> result) * Revert change in test_init --- tests/components/overkiz/test_config_flow.py | 216 +++++++++---------- 1 file changed, 108 insertions(+), 108 deletions(-) diff --git a/tests/components/overkiz/test_config_flow.py b/tests/components/overkiz/test_config_flow.py index 5c98b4e9260..410c2ebb5f1 100644 --- a/tests/components/overkiz/test_config_flow.py +++ b/tests/components/overkiz/test_config_flow.py @@ -82,21 +82,21 @@ async def test_form_cloud(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> N assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with ( patch("pyoverkiz.client.OverkizClient.login", return_value=True), @@ -105,7 +105,7 @@ async def test_form_cloud(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> N return_value=MOCK_GATEWAY_RESPONSE, ), ): - await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) @@ -125,13 +125,13 @@ async def test_form_only_cloud_supported( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER2}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with ( patch("pyoverkiz.client.OverkizClient.login", return_value=True), @@ -140,7 +140,7 @@ async def test_form_only_cloud_supported( return_value=MOCK_GATEWAY_RESPONSE, ), ): - await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) @@ -160,28 +160,28 @@ async def test_form_local_happy_flow( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "local"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "local" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local" with patch.multiple( "pyoverkiz.client.OverkizClient", login=AsyncMock(return_value=True), get_gateways=AsyncMock(return_value=MOCK_GATEWAY_RESPONSE), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], { "host": "gateway-1234-5678-1234.local:8443", @@ -192,9 +192,9 @@ async def test_form_local_happy_flow( await hass.async_block_till_done() - assert result4["type"] is FlowResultType.CREATE_ENTRY - assert result4["title"] == "gateway-1234-5678-1234.local:8443" - assert result4["data"] == { + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == "gateway-1234-5678-1234.local:8443" + assert result["data"] == { "host": "gateway-1234-5678-1234.local:8443", "token": TEST_TOKEN, "verify_ssl": True, @@ -227,32 +227,32 @@ async def test_form_invalid_auth_cloud( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with patch("pyoverkiz.client.OverkizClient.login", side_effect=side_effect): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) await hass.async_block_till_done() - assert result4["type"] is FlowResultType.FORM - assert result4["errors"] == {"base": error} + assert result["type"] is FlowResultType.FORM + assert result["errors"] == {"base": error} @pytest.mark.parametrize( @@ -283,24 +283,24 @@ async def test_form_invalid_auth_local( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "local"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "local" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local" with patch("pyoverkiz.client.OverkizClient.login", side_effect=side_effect): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], { "host": TEST_HOST, @@ -311,8 +311,8 @@ async def test_form_invalid_auth_local( await hass.async_block_till_done() - assert result4["type"] is FlowResultType.FORM - assert result4["errors"] == {"base": error} + assert result["type"] is FlowResultType.FORM + assert result["errors"] == {"base": error} @pytest.mark.parametrize( @@ -331,25 +331,25 @@ async def test_form_invalid_cozytouch_auth( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER_COZYTOUCH}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with patch("pyoverkiz.client.OverkizClient.login", side_effect=side_effect): - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) await hass.async_block_till_done() - assert result3["type"] is FlowResultType.FORM - assert result3["errors"] == {"base": error} - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["errors"] == {"base": error} + assert result["step_id"] == "cloud" async def test_cloud_abort_on_duplicate_entry( @@ -369,21 +369,21 @@ async def test_cloud_abort_on_duplicate_entry( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with ( patch("pyoverkiz.client.OverkizClient.login", return_value=True), @@ -392,13 +392,13 @@ async def test_cloud_abort_on_duplicate_entry( return_value=MOCK_GATEWAY_RESPONSE, ), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) - assert result4["type"] is FlowResultType.ABORT - assert result4["reason"] == "already_configured" + assert result["type"] is FlowResultType.ABORT + assert result["reason"] == "already_configured" async def test_local_abort_on_duplicate_entry( @@ -425,21 +425,21 @@ async def test_local_abort_on_duplicate_entry( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "local"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "local" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local" with patch.multiple( "pyoverkiz.client.OverkizClient", @@ -447,7 +447,7 @@ async def test_local_abort_on_duplicate_entry( get_gateways=AsyncMock(return_value=MOCK_GATEWAY_RESPONSE), get_setup_option=AsyncMock(return_value=True), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], { "host": TEST_HOST, @@ -456,8 +456,8 @@ async def test_local_abort_on_duplicate_entry( }, ) - assert result4["type"] is FlowResultType.ABORT - assert result4["reason"] == "already_configured" + assert result["type"] is FlowResultType.ABORT + assert result["reason"] == "already_configured" async def test_cloud_allow_multiple_unique_entries( @@ -478,21 +478,21 @@ async def test_cloud_allow_multiple_unique_entries( assert result["type"] is FlowResultType.FORM - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with ( patch("pyoverkiz.client.OverkizClient.login", return_value=True), @@ -501,14 +501,14 @@ async def test_cloud_allow_multiple_unique_entries( return_value=MOCK_GATEWAY_RESPONSE, ), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) - assert result4["type"] is FlowResultType.CREATE_ENTRY - assert result4["title"] == TEST_EMAIL - assert result4["data"] == { + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == TEST_EMAIL + assert result["data"] == { "api_type": "cloud", "username": TEST_EMAIL, "password": TEST_PASSWORD, @@ -544,7 +544,7 @@ async def test_cloud_reauth_success(hass: HomeAssistant) -> None: return_value=MOCK_GATEWAY_RESPONSE, ), ): - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={ "username": TEST_EMAIL, @@ -552,8 +552,8 @@ async def test_cloud_reauth_success(hass: HomeAssistant) -> None: }, ) - assert result2["type"] is FlowResultType.ABORT - assert result2["reason"] == "reauth_successful" + assert result["type"] is FlowResultType.ABORT + assert result["reason"] == "reauth_successful" assert mock_entry.data["username"] == TEST_EMAIL assert mock_entry.data["password"] == TEST_PASSWORD2 @@ -586,7 +586,7 @@ async def test_cloud_reauth_wrong_account(hass: HomeAssistant) -> None: return_value=MOCK_GATEWAY2_RESPONSE, ), ): - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={ "username": TEST_EMAIL, @@ -594,8 +594,8 @@ async def test_cloud_reauth_wrong_account(hass: HomeAssistant) -> None: }, ) - assert result2["type"] is FlowResultType.ABORT - assert result2["reason"] == "reauth_wrong_account" + assert result["type"] is FlowResultType.ABORT + assert result["reason"] == "reauth_wrong_account" async def test_local_reauth_legacy(hass: HomeAssistant) -> None: @@ -759,15 +759,15 @@ async def test_dhcp_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> No assert result["type"] is FlowResultType.FORM assert result["step_id"] == config_entries.SOURCE_USER - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) @@ -776,7 +776,7 @@ async def test_dhcp_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> No patch("pyoverkiz.client.OverkizClient.login", return_value=True), patch("pyoverkiz.client.OverkizClient.get_gateways", return_value=None), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], { "username": TEST_EMAIL, @@ -784,9 +784,9 @@ async def test_dhcp_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> No }, ) - assert result4["type"] is FlowResultType.CREATE_ENTRY - assert result4["title"] == TEST_EMAIL - assert result4["data"] == { + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == TEST_EMAIL + assert result["data"] == { "username": TEST_EMAIL, "password": TEST_PASSWORD, "hub": TEST_SERVER, @@ -830,21 +830,21 @@ async def test_zeroconf_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) - assert result["type"] is FlowResultType.FORM assert result["step_id"] == config_entries.SOURCE_USER - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "cloud"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "cloud" with ( patch("pyoverkiz.client.OverkizClient.login", return_value=True), @@ -853,14 +853,14 @@ async def test_zeroconf_flow(hass: HomeAssistant, mock_setup_entry: AsyncMock) - return_value=MOCK_GATEWAY_RESPONSE, ), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"username": TEST_EMAIL, "password": TEST_PASSWORD}, ) - assert result4["type"] is FlowResultType.CREATE_ENTRY - assert result4["title"] == TEST_EMAIL - assert result4["data"] == { + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == TEST_EMAIL + assert result["data"] == { "username": TEST_EMAIL, "password": TEST_PASSWORD, "hub": TEST_SERVER, @@ -883,28 +883,28 @@ async def test_local_zeroconf_flow( assert result["type"] is FlowResultType.FORM assert result["step_id"] == config_entries.SOURCE_USER - result2 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"hub": TEST_SERVER}, ) - assert result2["type"] is FlowResultType.FORM - assert result2["step_id"] == "local_or_cloud" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local_or_cloud" - result3 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], {"api_type": "local"}, ) - assert result3["type"] is FlowResultType.FORM - assert result3["step_id"] == "local" + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "local" with patch.multiple( "pyoverkiz.client.OverkizClient", login=AsyncMock(return_value=True), get_gateways=AsyncMock(return_value=MOCK_GATEWAY_RESPONSE), ): - result4 = await hass.config_entries.flow.async_configure( + result = await hass.config_entries.flow.async_configure( result["flow_id"], { "host": "gateway-1234-5678-9123.local:8443", @@ -913,11 +913,11 @@ async def test_local_zeroconf_flow( }, ) - assert result4["type"] is FlowResultType.CREATE_ENTRY - assert result4["title"] == "gateway-1234-5678-9123.local:8443" + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == "gateway-1234-5678-9123.local:8443" # Verify no username/password in data - assert result4["data"] == { + assert result["data"] == { "host": "gateway-1234-5678-9123.local:8443", "token": TEST_TOKEN, "verify_ssl": False, From 2db60340c2a0ab2b7b03ba7f8bc38985a6d92615 Mon Sep 17 00:00:00 2001 From: Jeremiah Paige Date: Tue, 13 May 2025 01:43:03 -0700 Subject: [PATCH 11/14] Add typing to wsdot (#143117) * increase wsdot typing * remove Final types * help out mypy * simplify wsdot types * minor wsdot type changes * type wsdot state --- homeassistant/components/wsdot/sensor.py | 31 +++++++++++++++--------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/homeassistant/components/wsdot/sensor.py b/homeassistant/components/wsdot/sensor.py index 8ae93c809f2..b3eb2715562 100644 --- a/homeassistant/components/wsdot/sensor.py +++ b/homeassistant/components/wsdot/sensor.py @@ -65,7 +65,7 @@ def setup_platform( name = travel_time.get(CONF_NAME) or travel_time.get(CONF_ID) sensors.append( WashingtonStateTravelTimeSensor( - name, config.get(CONF_API_KEY), travel_time.get(CONF_ID) + name, config[CONF_API_KEY], travel_time.get(CONF_ID) ) ) @@ -82,20 +82,20 @@ class WashingtonStateTransportSensor(SensorEntity): _attr_icon = ICON - def __init__(self, name, access_code): + def __init__(self, name: str, access_code: str) -> None: """Initialize the sensor.""" - self._data = {} + self._data: dict[str, str | int | None] = {} self._access_code = access_code self._name = name - self._state = None + self._state: int | None = None @property - def name(self): + def name(self) -> str: """Return the name of the sensor.""" return self._name @property - def native_value(self): + def native_value(self) -> int | None: """Return the state of the sensor.""" return self._state @@ -106,7 +106,7 @@ class WashingtonStateTravelTimeSensor(WashingtonStateTransportSensor): _attr_attribution = ATTRIBUTION _attr_native_unit_of_measurement = UnitOfTime.MINUTES - def __init__(self, name, access_code, travel_time_id): + def __init__(self, name: str, access_code: str, travel_time_id: str) -> None: """Construct a travel time sensor.""" self._travel_time_id = travel_time_id WashingtonStateTransportSensor.__init__(self, name, access_code) @@ -123,13 +123,17 @@ class WashingtonStateTravelTimeSensor(WashingtonStateTransportSensor): _LOGGER.warning("Invalid response from WSDOT API") else: self._data = response.json() - self._state = self._data.get(ATTR_CURRENT_TIME) + _state = self._data.get(ATTR_CURRENT_TIME) + if not isinstance(_state, int): + self._state = None + else: + self._state = _state @property def extra_state_attributes(self) -> dict[str, Any] | None: """Return other details about the sensor state.""" if self._data is not None: - attrs = {} + attrs: dict[str, str | int | None | datetime] = {} for key in ( ATTR_AVG_TIME, ATTR_NAME, @@ -144,12 +148,15 @@ class WashingtonStateTravelTimeSensor(WashingtonStateTransportSensor): return None -def _parse_wsdot_timestamp(timestamp): +def _parse_wsdot_timestamp(timestamp: Any) -> datetime | None: """Convert WSDOT timestamp to datetime.""" - if not timestamp: + if not isinstance(timestamp, str): return None # ex: Date(1485040200000-0800) - milliseconds, tzone = re.search(r"Date\((\d+)([+-]\d\d)\d\d\)", timestamp).groups() + timestamp_parts = re.search(r"Date\((\d+)([+-]\d\d)\d\d\)", timestamp) + if timestamp_parts is None: + return None + milliseconds, tzone = timestamp_parts.groups() return datetime.fromtimestamp( int(milliseconds) / 1000, tz=timezone(timedelta(hours=int(tzone))) ) From a7787d6080203acea87558f379854c12f3c0c7a3 Mon Sep 17 00:00:00 2001 From: Josef Zweck Date: Tue, 13 May 2025 10:46:46 +0200 Subject: [PATCH 12/14] Fix blocking call in azure storage (#144803) --- .../components/azure_storage/__init__.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/homeassistant/components/azure_storage/__init__.py b/homeassistant/components/azure_storage/__init__.py index f22e7b70c12..00e419fd3c9 100644 --- a/homeassistant/components/azure_storage/__init__.py +++ b/homeassistant/components/azure_storage/__init__.py @@ -39,11 +39,20 @@ async def async_setup_entry( session = async_create_clientsession( hass, timeout=ClientTimeout(connect=10, total=12 * 60 * 60) ) - container_client = ContainerClient( - account_url=f"https://{entry.data[CONF_ACCOUNT_NAME]}.blob.core.windows.net/", - container_name=entry.data[CONF_CONTAINER_NAME], - credential=entry.data[CONF_STORAGE_ACCOUNT_KEY], - transport=AioHttpTransport(session=session), + + def create_container_client() -> ContainerClient: + """Create a ContainerClient.""" + + return ContainerClient( + account_url=f"https://{entry.data[CONF_ACCOUNT_NAME]}.blob.core.windows.net/", + container_name=entry.data[CONF_CONTAINER_NAME], + credential=entry.data[CONF_STORAGE_ACCOUNT_KEY], + transport=AioHttpTransport(session=session), + ) + + # has a blocking call to open in cpython + container_client: ContainerClient = await hass.async_add_executor_job( + create_container_client ) try: From 5c6984d3261674981f79791228abe1e0fb29d2a0 Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Tue, 13 May 2025 10:47:26 +0200 Subject: [PATCH 13/14] Do not abort on invalid host in SamsungTV user flow (#144794) --- .../components/samsungtv/config_flow.py | 35 +++++++------ .../components/samsungtv/strings.json | 2 +- tests/components/samsungtv/conftest.py | 2 +- .../components/samsungtv/test_config_flow.py | 49 ++++++++++--------- 4 files changed, 48 insertions(+), 40 deletions(-) diff --git a/homeassistant/components/samsungtv/config_flow.py b/homeassistant/components/samsungtv/config_flow.py index 9867e44254e..806a4db4bf6 100644 --- a/homeassistant/components/samsungtv/config_flow.py +++ b/homeassistant/components/samsungtv/config_flow.py @@ -56,7 +56,6 @@ from .const import ( RESULT_INVALID_PIN, RESULT_NOT_SUPPORTED, RESULT_SUCCESS, - RESULT_UNKNOWN_HOST, SUCCESSFUL_RESULTS, UPNP_SVC_MAIN_TV_AGENT, UPNP_SVC_RENDERING_CONTROL, @@ -252,32 +251,40 @@ class SamsungTVConfigFlow(ConfigFlow, domain=DOMAIN): self._mac = mac return True - async def _async_set_name_host_from_input(self, user_input: dict[str, Any]) -> None: + async def _async_set_name_host_from_input(self, user_input: dict[str, Any]) -> bool: try: self._host = await self.hass.async_add_executor_job( socket.gethostbyname, user_input[CONF_HOST] ) except socket.gaierror as err: - raise AbortFlow(RESULT_UNKNOWN_HOST) from err + LOGGER.debug("Failed to get IP for %s: %s", user_input[CONF_HOST], err) + return False self._title = self._host + return True async def async_step_user( self, user_input: dict[str, Any] | None = None ) -> ConfigFlowResult: """Handle a flow initialized by the user.""" + errors: dict[str, str] | None = None if user_input is not None: - await self._async_set_name_host_from_input(user_input) - await self._async_create_bridge() - assert self._bridge - self._async_abort_entries_match({CONF_HOST: self._host}) - if self._bridge.method != METHOD_LEGACY: - # Legacy bridge does not provide device info - await self._async_set_device_unique_id(raise_on_progress=False) - if self._bridge.method == METHOD_ENCRYPTED_WEBSOCKET: - return await self.async_step_encrypted_pairing() - return await self.async_step_pairing({}) + if await self._async_set_name_host_from_input(user_input): + await self._async_create_bridge() + assert self._bridge + self._async_abort_entries_match({CONF_HOST: self._host}) + if self._bridge.method != METHOD_LEGACY: + # Legacy bridge does not provide device info + await self._async_set_device_unique_id(raise_on_progress=False) + if self._bridge.method == METHOD_ENCRYPTED_WEBSOCKET: + return await self.async_step_encrypted_pairing() + return await self.async_step_pairing({}) + errors = {"base": "invalid_host"} - return self.async_show_form(step_id="user", data_schema=DATA_SCHEMA) + return self.async_show_form( + step_id="user", + data_schema=self.add_suggested_values_to_schema(DATA_SCHEMA, user_input), + errors=errors, + ) async def async_step_pairing( self, user_input: dict[str, Any] | None = None diff --git a/homeassistant/components/samsungtv/strings.json b/homeassistant/components/samsungtv/strings.json index 17fde5db5bf..431c9bd3ec6 100644 --- a/homeassistant/components/samsungtv/strings.json +++ b/homeassistant/components/samsungtv/strings.json @@ -43,6 +43,7 @@ }, "error": { "auth_missing": "[%key:component::samsungtv::config::abort::auth_missing%]", + "invalid_host": "Host is invalid, please try again.", "invalid_pin": "PIN is invalid, please try again." }, "abort": { @@ -52,7 +53,6 @@ "id_missing": "This Samsung device doesn't have a SerialNumber.", "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]", "not_supported": "This Samsung device is currently not supported.", - "unknown": "[%key:common::config_flow::error::unknown%]", "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]" } }, diff --git a/tests/components/samsungtv/conftest.py b/tests/components/samsungtv/conftest.py index d0c53020d85..6fe784addd7 100644 --- a/tests/components/samsungtv/conftest.py +++ b/tests/components/samsungtv/conftest.py @@ -67,7 +67,7 @@ def fake_host_fixture() -> Generator[None]: """Patch gethostbyname.""" with patch( "homeassistant.components.samsungtv.config_flow.socket.gethostbyname", - return_value="fake_host", + return_value="10.20.43.21", ): yield diff --git a/tests/components/samsungtv/test_config_flow.py b/tests/components/samsungtv/test_config_flow.py index dd744bd82ca..f62c3cc1ae8 100644 --- a/tests/components/samsungtv/test_config_flow.py +++ b/tests/components/samsungtv/test_config_flow.py @@ -2,6 +2,7 @@ from copy import deepcopy from ipaddress import ip_address +import socket from unittest.mock import ANY, AsyncMock, Mock, call, patch import pytest @@ -106,35 +107,22 @@ AUTODETECT_LEGACY = { "id": "ha.component.samsung", "method": METHOD_LEGACY, "port": LEGACY_PORT, - "host": "fake_host", + "host": "10.20.43.21", "timeout": TIMEOUT_REQUEST, } -AUTODETECT_WEBSOCKET_PLAIN = { - "host": "fake_host", - "name": "HomeAssistant", - "port": 8001, - "timeout": TIMEOUT_REQUEST, - "token": None, -} AUTODETECT_WEBSOCKET_SSL = { - "host": "fake_host", + "host": "10.20.43.21", "name": "HomeAssistant", "port": 8002, "timeout": TIMEOUT_REQUEST, "token": None, } DEVICEINFO_WEBSOCKET_SSL = { - "host": "fake_host", + "host": "10.20.43.21", "session": ANY, "port": 8002, "timeout": TIMEOUT_WEBSOCKET, } -DEVICEINFO_WEBSOCKET_NO_SSL = { - "host": "fake_host", - "session": ANY, - "port": 8001, - "timeout": TIMEOUT_WEBSOCKET, -} pytestmark = pytest.mark.usefixtures("mock_setup_entry") @@ -149,14 +137,27 @@ async def test_user_legacy(hass: HomeAssistant) -> None: assert result["type"] is FlowResultType.FORM assert result["step_id"] == "user" - # entry was added + # Wrong host allow to retry + with patch( + "homeassistant.components.samsungtv.config_flow.socket.gethostbyname", + side_effect=socket.gaierror("[Error -2] Name or Service not known"), + ): + result = await hass.config_entries.flow.async_configure( + result["flow_id"], user_input=MOCK_USER_DATA + ) + + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "user" + assert result["errors"] == {"base": "invalid_host"} + + # Good host creates entry result = await hass.config_entries.flow.async_configure( result["flow_id"], user_input=MOCK_USER_DATA ) # legacy tv entry created assert result["type"] is FlowResultType.CREATE_ENTRY - assert result["title"] == "fake_host" - assert result["data"][CONF_HOST] == "fake_host" + assert result["title"] == "10.20.43.21" + assert result["data"][CONF_HOST] == "10.20.43.21" assert result["data"][CONF_METHOD] == METHOD_LEGACY assert result["data"][CONF_MANUFACTURER] == DEFAULT_MANUFACTURER assert result["data"][CONF_MODEL] is None @@ -189,8 +190,8 @@ async def test_user_legacy_does_not_ok_first_time(hass: HomeAssistant) -> None: # legacy tv entry created assert result3["type"] is FlowResultType.CREATE_ENTRY - assert result3["title"] == "fake_host" - assert result3["data"][CONF_HOST] == "fake_host" + assert result3["title"] == "10.20.43.21" + assert result3["data"][CONF_HOST] == "10.20.43.21" assert result3["data"][CONF_METHOD] == METHOD_LEGACY assert result3["data"][CONF_MANUFACTURER] == DEFAULT_MANUFACTURER assert result3["data"][CONF_MODEL] is None @@ -219,7 +220,7 @@ async def test_user_websocket(hass: HomeAssistant) -> None: # websocket tv entry created assert result["type"] is FlowResultType.CREATE_ENTRY assert result["title"] == "Living Room (82GXARRS)" - assert result["data"][CONF_HOST] == "fake_host" + assert result["data"][CONF_HOST] == "10.20.43.21" assert result["data"][CONF_METHOD] == "websocket" assert result["data"][CONF_MANUFACTURER] == "Samsung" assert result["data"][CONF_MODEL] == "82GXARRS" @@ -267,7 +268,7 @@ async def test_user_encrypted_websocket( assert result4["type"] is FlowResultType.CREATE_ENTRY assert result4["title"] == "TV-UE48JU6470 (UE48JU6400)" - assert result4["data"][CONF_HOST] == "fake_host" + assert result4["data"][CONF_HOST] == "10.20.43.21" assert result4["data"][CONF_MAC] == "aa:bb:aa:aa:aa:aa" assert result4["data"][CONF_MANUFACTURER] == "Samsung" assert result4["data"][CONF_MODEL] == "UE48JU6400" @@ -398,7 +399,7 @@ async def test_user_websocket_auth_retry(hass: HomeAssistant) -> None: ) assert result["type"] is FlowResultType.CREATE_ENTRY assert result["title"] == "Living Room (82GXARRS)" - assert result["data"][CONF_HOST] == "fake_host" + assert result["data"][CONF_HOST] == "10.20.43.21" assert result["data"][CONF_MANUFACTURER] == "Samsung" assert result["data"][CONF_MODEL] == "82GXARRS" assert result["result"].unique_id == "be9554b9-c9fb-41f4-8920-22da015376a4" From 55b9dee448dc412a6a4e32c9e086970eb67562ed Mon Sep 17 00:00:00 2001 From: Martin Hjelmare Date: Tue, 13 May 2025 13:12:00 +0200 Subject: [PATCH 14/14] Fix Z-Wave unique id after controller reset (#144813) --- homeassistant/components/zwave_js/api.py | 23 +++++++++++ .../components/zwave_js/config_flow.py | 26 +----------- homeassistant/components/zwave_js/helpers.py | 26 ++++++++++++ tests/components/zwave_js/conftest.py | 40 ++++++++++++++++++ tests/components/zwave_js/test_api.py | 40 ++++++++++++++++++ tests/components/zwave_js/test_config_flow.py | 41 +------------------ 6 files changed, 133 insertions(+), 63 deletions(-) diff --git a/homeassistant/components/zwave_js/api.py b/homeassistant/components/zwave_js/api.py index 5eb59c6c288..f480c822a8c 100644 --- a/homeassistant/components/zwave_js/api.py +++ b/homeassistant/components/zwave_js/api.py @@ -71,6 +71,7 @@ from homeassistant.components.websocket_api import ( ActiveConnection, ) from homeassistant.config_entries import ConfigEntry, ConfigEntryState +from homeassistant.const import CONF_URL from homeassistant.core import HomeAssistant, callback from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.aiohttp_client import async_get_clientsession @@ -88,13 +89,16 @@ from .const import ( DATA_CLIENT, DOMAIN, EVENT_DEVICE_ADDED_TO_REGISTRY, + LOGGER, RESTORE_NVM_DRIVER_READY_TIMEOUT, USER_AGENT, ) from .helpers import ( + CannotConnect, async_enable_statistics, async_get_node_from_device_id, async_get_provisioning_entry_from_device_id, + async_get_version_info, get_device_id, ) @@ -2865,6 +2869,25 @@ async def websocket_hard_reset_controller( async with asyncio.timeout(HARD_RESET_CONTROLLER_DRIVER_READY_TIMEOUT): await wait_driver_ready.wait() + # When resetting the controller, the controller home id is also changed. + # The controller state in the client is stale after resetting the controller, + # so get the new home id with a new client using the helper function. + # The client state will be refreshed by reloading the config entry, + # after the unique id of the config entry has been updated. + try: + version_info = await async_get_version_info(hass, entry.data[CONF_URL]) + except CannotConnect: + # Just log this error, as there's nothing to do about it here. + # The stale unique id needs to be handled by a repair flow, + # after the config entry has been reloaded. + LOGGER.error( + "Failed to get server version, cannot update config entry" + "unique id with new home id, after controller reset" + ) + else: + hass.config_entries.async_update_entry( + entry, unique_id=str(version_info.home_id) + ) await hass.config_entries.async_reload(entry.entry_id) diff --git a/homeassistant/components/zwave_js/config_flow.py b/homeassistant/components/zwave_js/config_flow.py index 407af9e902b..e52a5e784e8 100644 --- a/homeassistant/components/zwave_js/config_flow.py +++ b/homeassistant/components/zwave_js/config_flow.py @@ -9,14 +9,13 @@ import logging from pathlib import Path from typing import Any -import aiohttp from awesomeversion import AwesomeVersion from serial.tools import list_ports import voluptuous as vol from zwave_js_server.client import Client from zwave_js_server.exceptions import FailedCommand from zwave_js_server.model.driver import Driver -from zwave_js_server.version import VersionInfo, get_server_version +from zwave_js_server.version import VersionInfo from homeassistant.components import usb from homeassistant.components.hassio import ( @@ -36,7 +35,6 @@ from homeassistant.const import CONF_NAME, CONF_URL from homeassistant.core import HomeAssistant, callback from homeassistant.data_entry_flow import AbortFlow from homeassistant.exceptions import HomeAssistantError -from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.hassio import is_hassio from homeassistant.helpers.service_info.hassio import HassioServiceInfo from homeassistant.helpers.service_info.usb import UsbServiceInfo @@ -69,6 +67,7 @@ from .const import ( DOMAIN, RESTORE_NVM_DRIVER_READY_TIMEOUT, ) +from .helpers import CannotConnect, async_get_version_info _LOGGER = logging.getLogger(__name__) @@ -79,7 +78,6 @@ ADDON_SETUP_TIMEOUT = 5 ADDON_SETUP_TIMEOUT_ROUNDS = 40 CONF_EMULATE_HARDWARE = "emulate_hardware" CONF_LOG_LEVEL = "log_level" -SERVER_VERSION_TIMEOUT = 10 ADDON_LOG_LEVELS = { "error": "Error", @@ -130,22 +128,6 @@ async def validate_input(hass: HomeAssistant, user_input: dict) -> VersionInfo: raise InvalidInput("cannot_connect") from err -async def async_get_version_info(hass: HomeAssistant, ws_address: str) -> VersionInfo: - """Return Z-Wave JS version info.""" - try: - async with asyncio.timeout(SERVER_VERSION_TIMEOUT): - version_info: VersionInfo = await get_server_version( - ws_address, async_get_clientsession(hass) - ) - except (TimeoutError, aiohttp.ClientError) as err: - # We don't want to spam the log if the add-on isn't started - # or takes a long time to start. - _LOGGER.debug("Failed to connect to Z-Wave JS server: %s", err) - raise CannotConnect from err - - return version_info - - def get_usb_ports() -> dict[str, str]: """Return a dict of USB ports and their friendly names.""" ports = list_ports.comports() @@ -1357,10 +1339,6 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN): return client.driver -class CannotConnect(HomeAssistantError): - """Indicate connection error.""" - - class InvalidInput(HomeAssistantError): """Error to indicate input data is invalid.""" diff --git a/homeassistant/components/zwave_js/helpers.py b/homeassistant/components/zwave_js/helpers.py index ded87b590a4..bfa093f7db9 100644 --- a/homeassistant/components/zwave_js/helpers.py +++ b/homeassistant/components/zwave_js/helpers.py @@ -2,11 +2,13 @@ from __future__ import annotations +import asyncio from collections.abc import Callable from dataclasses import astuple, dataclass import logging from typing import Any, cast +import aiohttp import voluptuous as vol from zwave_js_server.client import Client as ZwaveClient from zwave_js_server.const import ( @@ -25,6 +27,7 @@ from zwave_js_server.model.value import ( ValueDataType, get_value_id_str, ) +from zwave_js_server.version import VersionInfo, get_server_version from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN from homeassistant.config_entries import ConfigEntry, ConfigEntryState @@ -38,6 +41,7 @@ from homeassistant.const import ( from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import device_registry as dr, entity_registry as er +from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.group import expand_entity_ids from homeassistant.helpers.typing import ConfigType, VolSchemaType @@ -54,6 +58,8 @@ from .const import ( LOGGER, ) +SERVER_VERSION_TIMEOUT = 10 + @dataclass class ZwaveValueID: @@ -568,3 +574,23 @@ def get_network_identifier_for_notification( return f"`{config_entry.title}`, with the home ID `{home_id}`," return f"with the home ID `{home_id}`" return "" + + +async def async_get_version_info(hass: HomeAssistant, ws_address: str) -> VersionInfo: + """Return Z-Wave JS version info.""" + try: + async with asyncio.timeout(SERVER_VERSION_TIMEOUT): + version_info: VersionInfo = await get_server_version( + ws_address, async_get_clientsession(hass) + ) + except (TimeoutError, aiohttp.ClientError) as err: + # We don't want to spam the log if the add-on isn't started + # or takes a long time to start. + LOGGER.debug("Failed to connect to Z-Wave JS server: %s", err) + raise CannotConnect from err + + return version_info + + +class CannotConnect(HomeAssistantError): + """Indicate connection error.""" diff --git a/tests/components/zwave_js/conftest.py b/tests/components/zwave_js/conftest.py index 609a0229bcf..e0485ced091 100644 --- a/tests/components/zwave_js/conftest.py +++ b/tests/components/zwave_js/conftest.py @@ -1,6 +1,7 @@ """Provide common Z-Wave JS fixtures.""" import asyncio +from collections.abc import Generator import copy import io from typing import Any, cast @@ -15,6 +16,7 @@ from zwave_js_server.version import VersionInfo from homeassistant.components.zwave_js import PLATFORMS from homeassistant.components.zwave_js.const import DOMAIN +from homeassistant.components.zwave_js.helpers import SERVER_VERSION_TIMEOUT from homeassistant.const import Platform from homeassistant.core import HomeAssistant from homeassistant.util.json import JsonArrayType @@ -587,6 +589,44 @@ def mock_client_fixture( yield client +@pytest.fixture(name="server_version_side_effect") +def server_version_side_effect_fixture() -> Any | None: + """Return the server version side effect.""" + return None + + +@pytest.fixture(name="get_server_version", autouse=True) +def mock_get_server_version( + server_version_side_effect: Any | None, server_version_timeout: int +) -> Generator[AsyncMock]: + """Mock server version.""" + version_info = VersionInfo( + driver_version="mock-driver-version", + server_version="mock-server-version", + home_id=1234, + min_schema_version=0, + max_schema_version=1, + ) + with ( + patch( + "homeassistant.components.zwave_js.helpers.get_server_version", + side_effect=server_version_side_effect, + return_value=version_info, + ) as mock_version, + patch( + "homeassistant.components.zwave_js.helpers.SERVER_VERSION_TIMEOUT", + new=server_version_timeout, + ), + ): + yield mock_version + + +@pytest.fixture(name="server_version_timeout") +def mock_server_version_timeout() -> int: + """Patch the timeout for getting server version.""" + return SERVER_VERSION_TIMEOUT + + @pytest.fixture(name="multisensor_6") def multisensor_6_fixture(client, multisensor_6_state) -> Node: """Mock a multisensor 6 node.""" diff --git a/tests/components/zwave_js/test_api.py b/tests/components/zwave_js/test_api.py index 150ee39925b..7d4f9fe7a36 100644 --- a/tests/components/zwave_js/test_api.py +++ b/tests/components/zwave_js/test_api.py @@ -7,6 +7,7 @@ import json from typing import Any from unittest.mock import AsyncMock, MagicMock, PropertyMock, call, patch +from aiohttp import ClientError import pytest from zwave_js_server.const import ( ExclusionStrategy, @@ -5096,14 +5097,17 @@ async def test_subscribe_node_statistics( async def test_hard_reset_controller( hass: HomeAssistant, + caplog: pytest.LogCaptureFixture, device_registry: dr.DeviceRegistry, client: MagicMock, + get_server_version: AsyncMock, integration: MockConfigEntry, hass_ws_client: WebSocketGenerator, ) -> None: """Test that the hard_reset_controller WS API call works.""" entry = integration ws_client = await hass_ws_client(hass) + assert entry.unique_id == "3245146787" async def async_send_command_driver_ready( message: dict[str, Any], @@ -5138,6 +5142,40 @@ async def test_hard_reset_controller( assert client.async_send_command.call_args_list[0] == call( {"command": "driver.hard_reset"}, 25 ) + assert entry.unique_id == "1234" + + client.async_send_command.reset_mock() + + # Test client connect error when getting the server version. + + get_server_version.side_effect = ClientError("Boom!") + + await ws_client.send_json_auto_id( + { + TYPE: "zwave_js/hard_reset_controller", + ENTRY_ID: entry.entry_id, + } + ) + + msg = await ws_client.receive_json() + + device = device_registry.async_get_device( + identifiers={get_device_id(client.driver, client.driver.controller.nodes[1])} + ) + assert device is not None + assert msg["result"] == device.id + assert msg["success"] + + assert client.async_send_command.call_count == 3 + # The first call is the relevant hard reset command. + # 25 is the require_schema parameter. + assert client.async_send_command.call_args_list[0] == call( + {"command": "driver.hard_reset"}, 25 + ) + assert ( + "Failed to get server version, cannot update config entry" + "unique id with new home id, after controller reset" + ) in caplog.text client.async_send_command.reset_mock() @@ -5178,6 +5216,8 @@ async def test_hard_reset_controller( {"command": "driver.hard_reset"}, 25 ) + client.async_send_command.reset_mock() + # Test FailedZWaveCommand is caught with patch( "zwave_js_server.model.driver.Driver.async_hard_reset", diff --git a/tests/components/zwave_js/test_config_flow.py b/tests/components/zwave_js/test_config_flow.py index 3f1d894030f..e651a92339b 100644 --- a/tests/components/zwave_js/test_config_flow.py +++ b/tests/components/zwave_js/test_config_flow.py @@ -17,8 +17,9 @@ from zwave_js_server.exceptions import FailedCommand from zwave_js_server.version import VersionInfo from homeassistant import config_entries, data_entry_flow -from homeassistant.components.zwave_js.config_flow import SERVER_VERSION_TIMEOUT, TITLE +from homeassistant.components.zwave_js.config_flow import TITLE from homeassistant.components.zwave_js.const import ADDON_SLUG, CONF_USB_PATH, DOMAIN +from homeassistant.components.zwave_js.helpers import SERVER_VERSION_TIMEOUT from homeassistant.core import HomeAssistant from homeassistant.data_entry_flow import FlowResultType from homeassistant.helpers.service_info.hassio import HassioServiceInfo @@ -95,44 +96,6 @@ def mock_supervisor_fixture() -> Generator[None]: yield -@pytest.fixture(name="server_version_side_effect") -def server_version_side_effect_fixture() -> Any | None: - """Return the server version side effect.""" - return None - - -@pytest.fixture(name="get_server_version", autouse=True) -def mock_get_server_version( - server_version_side_effect: Any | None, server_version_timeout: int -) -> Generator[AsyncMock]: - """Mock server version.""" - version_info = VersionInfo( - driver_version="mock-driver-version", - server_version="mock-server-version", - home_id=1234, - min_schema_version=0, - max_schema_version=1, - ) - with ( - patch( - "homeassistant.components.zwave_js.config_flow.get_server_version", - side_effect=server_version_side_effect, - return_value=version_info, - ) as mock_version, - patch( - "homeassistant.components.zwave_js.config_flow.SERVER_VERSION_TIMEOUT", - new=server_version_timeout, - ), - ): - yield mock_version - - -@pytest.fixture(name="server_version_timeout") -def mock_server_version_timeout() -> int: - """Patch the timeout for getting server version.""" - return SERVER_VERSION_TIMEOUT - - @pytest.fixture(name="addon_setup_time", autouse=True) def mock_addon_setup_time() -> Generator[None]: """Mock add-on setup sleep time."""