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

Sort Home Connect test params (#144035)

Browse Source
This commit is contained in:
J. Diego Rodríguez Royo 2025-05-01 12:04:25 +02:00 committed by GitHub
parent 92944fa509
commit 79aa7aacec
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 333 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
tests/components/home_connect/test_binary_sensor.py
View File

@ -42,13 +42,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -104,14 +104,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -170,9 +170,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_binary_sensors_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if binary sensor entities availability are based on the appliance connection state."""
@ -268,15 +268,15 @@ async def test_binary_sensors_entity_availability(
indirect=["appliance"],
)
async def test_binary_sensors_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
event_key: EventKey,
event_value_update: str,
appliance: HomeAppliance,
expected: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Tests for Home Connect Fridge appliance door states."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -309,9 +309,9 @@ async def test_binary_sensors_functionality(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_connected_sensor_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if the connected binary sensor reports the right values."""

26
tests/components/home_connect/test_button.py
View File

@ -34,13 +34,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -96,14 +96,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -173,9 +173,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_button_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if button entities availability are based on the appliance connection state."""
@ -237,9 +237,9 @@ async def test_button_entity_availability(
)
async def test_button_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
entity_id: str,
method_call: str,
expected_kwargs: dict[str, Any],
@ -265,9 +265,9 @@ async def test_button_functionality(
async def test_command_button_exception(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test if button entities availability are based on the appliance connection state."""
entity_id = "button.washer_pause_program"
@ -301,9 +301,9 @@ async def test_command_button_exception(
async def test_stop_program_button_exception(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test if button entities availability are based on the appliance connection state."""
entity_id = "button.washer_stop_program"

15
tests/components/home_connect/test_config_flow.py
View File

@ -1,8 +1,7 @@
"""Test the Home Connect config flow."""
from collections.abc import Awaitable, Callable
from http import HTTPStatus
from unittest.mock import MagicMock, patch
from unittest.mock import patch
from aiohomeconnect.const import OAUTH2_AUTHORIZE, OAUTH2_TOKEN
import pytest
@ -143,13 +142,13 @@ async def test_prevent_reconfiguring_same_account(
@pytest.mark.usefixtures("current_request_with_host")
async def test_reauth_flow(
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
hass_client_no_auth: ClientSessionGenerator,
aioclient_mock: AiohttpClientMocker,
config_entry: MockConfigEntry,
) -> None:
"""Test reauth flow."""
config_entry.add_to_hass(hass)
result = await config_entry.start_reauth_flow(hass)
assert result["type"] is FlowResultType.FORM
@ -197,13 +196,13 @@ async def test_reauth_flow(
@pytest.mark.usefixtures("current_request_with_host")
async def test_reauth_flow_with_different_account(
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
hass_client_no_auth: ClientSessionGenerator,
aioclient_mock: AiohttpClientMocker,
config_entry: MockConfigEntry,
) -> None:
"""Test reauth flow."""
config_entry.add_to_hass(hass)
result = await config_entry.start_reauth_flow(hass)
assert result["type"] is FlowResultType.FORM

55
tests/components/home_connect/test_coordinator.py
View File

@ -83,10 +83,10 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_coordinator_failure_refresh_and_stream(
hass: HomeAssistant,
freezer: FrozenDateTimeFactory,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
freezer: FrozenDateTimeFactory,
appliance: HomeAppliance,
) -> None:
"""Test entity available state via coordinator refresh and event stream."""
@ -210,9 +210,9 @@ async def test_coordinator_failure_refresh_and_stream(
indirect=True,
)
async def test_coordinator_not_fetching_on_disconnected_appliance(
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test that the coordinator does not fetch anything on disconnected appliance."""
@ -231,10 +231,10 @@ async def test_coordinator_not_fetching_on_disconnected_appliance(
INITIAL_FETCH_CLIENT_METHODS,
)
async def test_coordinator_update_failing(
mock_method: str,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
mock_method: str,
) -> None:
"""Test that although is not possible to get settings and status, the config entry is loaded.
@ -274,16 +274,16 @@ async def test_coordinator_update_failing(
],
)
async def test_event_listener(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
event_type: EventType,
event_key: EventKey,
event_value: str,
entity_id: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
entity_registry: er.EntityRegistry,
) -> None:
"""Test that the event listener works."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -344,9 +344,9 @@ async def test_event_listener(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def tests_receive_setting_and_status_for_first_time_at_events(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test that the event listener is capable of receiving settings and status for the first time."""
@ -400,9 +400,9 @@ async def tests_receive_setting_and_status_for_first_time_at_events(
async def test_event_listener_error(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test that the configuration entry is reloaded when the event stream raises an API error."""
client_with_exception.stream_all_events = MagicMock(
@ -446,17 +446,17 @@ async def test_event_listener_error(
],
)
async def test_event_listener_resilience(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
exception: HomeConnectError,
entity_id: str,
initial_state: str,
event_key: EventKey,
event_value: Any,
after_event_expected_state: str,
exception: HomeConnectError,
hass: HomeAssistant,
appliance: HomeAppliance,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
) -> None:
"""Test that the event listener is resilient to interruptions."""
future = hass.loop.create_future()
@ -516,10 +516,10 @@ async def test_event_listener_resilience(
async def test_devices_updated_on_refresh(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
) -> None:
"""Test handling of devices added or deleted while event stream is down."""
appliances: list[HomeAppliance] = (
@ -557,9 +557,9 @@ async def test_devices_updated_on_refresh(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_disconnected_devices_not_fetching(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test that Home Connect API is not fetched after pairing a disconnected device."""
@ -587,11 +587,11 @@ async def test_paired_disconnected_devices_not_fetching(
async def test_coordinator_disabling_updates_for_appliance(
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
hass_client: ClientSessionGenerator,
) -> None:
"""Test coordinator disables appliance updates on frequent connect/paired events.
@ -680,11 +680,10 @@ async def test_coordinator_disabling_updates_for_appliance(
async def test_coordinator_disabling_updates_for_appliance_is_gone_after_entry_reload(
hass: HomeAssistant,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
hass_client: ClientSessionGenerator,
) -> None:
"""Test that updates are enabled again after unloading the entry.

6
tests/components/home_connect/test_diagnostics.py
View File

@ -19,9 +19,9 @@ from tests.common import MockConfigEntry
async def test_async_get_config_entry_diagnostics(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
snapshot: SnapshotAssertion,
) -> None:
"""Test config entry diagnostics."""
@ -34,10 +34,10 @@ async def test_async_get_config_entry_diagnostics(
async def test_async_get_device_diagnostics(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test device config entry diagnostics."""

30
tests/components/home_connect/test_entity.py
View File

@ -95,6 +95,10 @@ def platforms() -> list[str]:
indirect=["appliance"],
)
async def test_program_options_retrieval(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
array_of_programs_program_arg: str,
event_key: EventKey,
appliance: HomeAppliance,
@ -103,10 +107,6 @@ async def test_program_options_retrieval(
options_availability_stage_2: list[bool],
option_without_default: tuple[OptionKey, str],
option_without_constraints: tuple[OptionKey, str],
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that the options are correctly retrieved at the start and updated on program updates."""
original_get_all_programs_mock = client.get_all_programs.side_effect
@ -250,13 +250,13 @@ async def test_program_options_retrieval(
],
)
async def test_no_options_retrieval_on_unknown_program(
array_of_programs_program_arg: str,
event_key: EventKey,
appliance: HomeAppliance,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
array_of_programs_program_arg: str,
event_key: EventKey,
) -> None:
"""Test that no options are retrieved when the program is unknown."""
@ -326,14 +326,14 @@ async def test_no_options_retrieval_on_unknown_program(
indirect=["appliance"],
)
async def test_program_options_retrieval_after_appliance_connection(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
event_key: EventKey,
appliance: HomeAppliance,
option_key: OptionKey,
option_entity_id: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that the options are correctly retrieved at the start and updated on program updates."""
array_of_home_appliances = client.get_home_appliances.return_value
@ -447,12 +447,12 @@ async def test_program_options_retrieval_after_appliance_connection(
],
)
async def test_option_entity_functionality_exception(
set_active_program_option_side_effect: HomeConnectError | None,
set_selected_program_option_side_effect: HomeConnectError | None,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
set_active_program_option_side_effect: HomeConnectError | None,
set_selected_program_option_side_effect: HomeConnectError | None,
) -> None:
"""Test that the option entity handles exceptions correctly."""
entity_id = "switch.washer_i_dos_1_active"

32
tests/components/home_connect/test_init.py
View File

@ -41,9 +41,9 @@ from tests.test_util.aiohttp import AiohttpClientMocker
async def test_entry_setup(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test setup and unload."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -59,11 +59,11 @@ async def test_entry_setup(
@pytest.mark.parametrize("token_expiration_time", [12345])
async def test_token_refresh_success(
hass: HomeAssistant,
platforms: list[Platform],
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
aioclient_mock: AiohttpClientMocker,
client: MagicMock,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
platforms: list[Platform],
) -> None:
"""Test where token is expired and the refresh attempt succeeds."""
@ -138,14 +138,13 @@ async def test_token_refresh_success(
],
)
async def test_token_refresh_error(
aioclient_mock_args: dict[str, Any],
expected_config_entry_state: ConfigEntryState,
hass: HomeAssistant,
platforms: list[Platform],
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
aioclient_mock: AiohttpClientMocker,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
aioclient_mock_args: dict[str, Any],
expected_config_entry_state: ConfigEntryState,
) -> None:
"""Test where token is expired and the refresh attempt fails."""
@ -174,11 +173,11 @@ async def test_token_refresh_error(
],
)
async def test_client_error(
exception: HomeConnectError,
expected_state: ConfigEntryState,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
exception: HomeConnectError,
expected_state: ConfigEntryState,
) -> None:
"""Test client errors during setup integration."""
client_with_exception.get_home_appliances.return_value = None
@ -200,11 +199,10 @@ async def test_client_error(
],
)
async def test_client_rate_limit_error(
raising_exception_method: str,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
raising_exception_method: str,
) -> None:
"""Test client errors during setup integration."""
retry_after = 42
@ -234,9 +232,9 @@ async def test_client_rate_limit_error(
async def test_required_program_or_at_least_an_option(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"Test that the set_program_and_options does raise an exception if no program nor options are set."
@ -270,8 +268,8 @@ async def test_entity_migration(
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
config_entry_v1_1: MockConfigEntry,
appliance: HomeAppliance,
platforms: list[Platform],
appliance: HomeAppliance,
) -> None:
"""Test entity migration."""

44
tests/components/home_connect/test_light.py
View File

@ -55,13 +55,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Hood"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -117,14 +117,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -177,9 +177,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Hood"], indirect=True)
async def test_light_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if light entities availability are based on the appliance connection state."""
@ -341,16 +341,16 @@ async def test_light_availability(
indirect=["appliance"],
)
async def test_light_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
set_settings_args: dict[SettingKey, Any],
service: str,
exprected_attributes: dict[str, Any],
state: str,
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test light functionality."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -396,13 +396,13 @@ async def test_light_functionality(
indirect=["appliance"],
)
async def test_light_color_different_than_custom(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
events: dict[EventKey, Any],
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that light color attributes are not set if color is different than custom."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -560,16 +560,16 @@ async def test_light_color_different_than_custom(
],
)
async def test_light_exception_handling(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
setting: dict[SettingKey, dict[str, Any]],
service: str,
service_data: dict,
attr_side_effect: list[type[HomeConnectError] | None],
exception_match: str,
hass: HomeAssistant,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
client_with_exception: MagicMock,
) -> None:
"""Test light exception handling."""
client_with_exception.get_settings.side_effect = None

52
tests/components/home_connect/test_number.py
View File

@ -60,13 +60,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
client.get_available_program = AsyncMock(
@ -135,14 +135,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -195,9 +195,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["FridgeFreezer"], indirect=True)
async def test_number_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if number entities availability are based on the appliance connection state."""
@ -285,6 +285,10 @@ async def test_number_entity_availability(
],
)
async def test_number_entity_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
setting_key: SettingKey,
@ -294,10 +298,6 @@ async def test_number_entity_functionality(
max_value: int,
step_size: float,
unit_of_measurement: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test number entity functionality."""
client.get_setting.side_effect = None
@ -372,6 +372,10 @@ async def test_number_entity_functionality(
)
@patch("homeassistant.components.home_connect.entity.API_DEFAULT_RETRY_AFTER", new=0)
async def test_fetch_constraints_after_rate_limit_error(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
retry_after: int | None,
appliance: HomeAppliance,
entity_id: str,
@ -381,10 +385,6 @@ async def test_fetch_constraints_after_rate_limit_error(
max_value: int,
step_size: int,
unit_of_measurement: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that, if a API rate limit error is raised, the constraints are fetched later."""
@ -448,13 +448,13 @@ async def test_fetch_constraints_after_rate_limit_error(
],
)
async def test_number_entity_error(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
setting_key: SettingKey,
mock_attr: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test number entity error."""
client_with_exception.get_settings.side_effect = None
@ -529,6 +529,10 @@ async def test_number_entity_error(
indirect=["appliance"],
)
async def test_options_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
option_key: OptionKey,
appliance: HomeAppliance,
@ -539,10 +543,6 @@ async def test_options_functionality(
set_active_program_options_side_effect: ActiveProgramNotSetError | None,
set_selected_program_options_side_effect: SelectedProgramNotSetError | None,
called_mock_method: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test options functionality."""

92
tests/components/home_connect/test_select.py
View File

@ -64,13 +64,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
client.get_available_program = AsyncMock(
@ -141,14 +141,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -211,9 +211,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_select_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if select entities availability are based on the appliance connection state."""
@ -261,10 +261,10 @@ async def test_select_entity_availability(
async def test_filter_programs(
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
entity_registry: er.EntityRegistry,
) -> None:
"""Test select that only right programs are shown."""
client.get_all_programs.side_effect = None
@ -352,6 +352,10 @@ async def test_filter_programs(
indirect=["appliance"],
)
async def test_select_program_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
expected_initial_state: str,
@ -359,10 +363,6 @@ async def test_select_program_functionality(
program_key: ProgramKey,
program_to_set: str,
event_key: EventKey,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test select functionality."""
assert config_entry.state is ConfigEntryState.NOT_LOADED
@ -428,14 +428,14 @@ async def test_select_program_functionality(
],
)
async def test_select_exception_handling(
hass: HomeAssistant,
client_with_exception: MagicMock,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
entity_id: str,
program_to_set: str,
mock_attr: str,
exception_match: str,
hass: HomeAssistant,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
client_with_exception: MagicMock,
) -> None:
"""Test exception handling."""
client_with_exception.get_all_programs.side_effect = None
@ -470,11 +470,11 @@ async def test_select_exception_handling(
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_programs_updated_on_connect(
appliance: HomeAppliance,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test that devices reconnected.
@ -554,16 +554,16 @@ async def test_programs_updated_on_connect(
],
)
async def test_select_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
setting_key: SettingKey,
expected_options: set[str],
value_to_set: str,
expected_value_call_arg: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test select functionality."""
assert config_entry.state is ConfigEntryState.NOT_LOADED
@ -617,15 +617,15 @@ async def test_select_functionality(
],
)
async def test_fetch_allowed_values(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
test_setting_key: SettingKey,
allowed_values: list[str | None],
expected_options: set[str],
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test fetch allowed values."""
original_get_setting_side_effect = client.get_setting
@ -673,15 +673,15 @@ async def test_fetch_allowed_values(
],
)
async def test_fetch_allowed_values_after_rate_limit_error(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
setting_key: SettingKey,
allowed_values: list[str | None],
expected_options: set[str],
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test fetch allowed values."""
@ -747,15 +747,15 @@ async def test_fetch_allowed_values_after_rate_limit_error(
],
)
async def test_default_values_after_fetch_allowed_values_error(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
setting_key: SettingKey,
exception: Exception,
expected_options: set[str],
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test fetch allowed values."""
@ -799,15 +799,15 @@ async def test_default_values_after_fetch_allowed_values_error(
],
)
async def test_select_entity_error(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
setting_key: SettingKey,
allowed_value: str,
value_to_set: str,
mock_attr: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test select entity error."""
client_with_exception.get_settings.side_effect = None
@ -913,6 +913,10 @@ async def test_select_entity_error(
],
)
async def test_options_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
option_key: OptionKey,
allowed_values: list[str | None] | None,
@ -921,10 +925,6 @@ async def test_options_functionality(
set_active_program_options_side_effect: ActiveProgramNotSetError | None,
set_selected_program_options_side_effect: SelectedProgramNotSetError | None,
called_mock_method: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test options functionality."""
if set_active_program_options_side_effect:

86
tests/components/home_connect/test_sensor.py
View File

@ -91,13 +91,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -176,14 +176,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -236,9 +236,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", [TEST_HC_APP], indirect=True)
async def test_sensor_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if sensor entities availability are based on the appliance connection state."""
@ -355,14 +355,14 @@ ENTITY_ID_STATES = {
),
)
async def test_program_sensors(
hass: HomeAssistant,
freezer: FrozenDateTimeFactory,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
states: tuple,
event_run: dict[EventType, dict[EventKey, str | int]],
freezer: FrozenDateTimeFactory,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
) -> None:
"""Test sequence for sensors that expose information about a program."""
entity_ids = ENTITY_ID_STATES.keys()
@ -428,15 +428,15 @@ async def test_program_sensors(
],
)
async def test_program_sensor_edge_case(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
initial_operation_state: str,
initial_state: str,
event_order: tuple[EventType, EventType],
entity_states: tuple[str, str],
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test edge case for the program related entities."""
entity_id = "sensor.dishwasher_program_progress"
@ -503,12 +503,12 @@ ENTITY_ID_EDGE_CASE_STATES = [
@pytest.mark.parametrize("appliance", [TEST_HC_APP], indirect=True)
async def test_remaining_prog_time_edge_cases(
appliance: HomeAppliance,
freezer: FrozenDateTimeFactory,
hass: HomeAssistant,
freezer: FrozenDateTimeFactory,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Run program sequence to test edge cases for the remaining_prog_time entity."""
entity_id = "sensor.dishwasher_program_finish_time"
@ -581,14 +581,14 @@ async def test_remaining_prog_time_edge_cases(
indirect=["appliance"],
)
async def test_sensors_states(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
event_key: EventKey,
value_expected_state: list[tuple[str, str]],
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Tests for appliance sensors."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -641,15 +641,15 @@ async def test_sensors_states(
indirect=["appliance"],
)
async def test_event_sensors_states(
hass: HomeAssistant,
caplog: pytest.LogCaptureFixture,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
event_key: EventKey,
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
entity_registry: er.EntityRegistry,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Tests for appliance event sensors."""
caplog.set_level(logging.ERROR)
@ -726,16 +726,16 @@ async def test_event_sensors_states(
indirect=["appliance"],
)
async def test_sensor_unit_fetching(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
status_key: StatusKey,
unit_get_status: str | None,
unit_get_status_value: str | None,
get_status_value_call_count: int,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that the sensor entities are capable of fetching units."""
@ -793,13 +793,13 @@ async def test_sensor_unit_fetching(
indirect=["appliance"],
)
async def test_sensor_unit_fetching_error(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
status_key: StatusKey,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that the sensor entities are capable of fetching units."""
@ -844,14 +844,14 @@ async def test_sensor_unit_fetching_error(
indirect=["appliance"],
)
async def test_sensor_unit_fetching_after_rate_limit_error(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
status_key: StatusKey,
unit: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test that the sensor entities are capable of fetching units."""

42
tests/components/home_connect/test_services.py
View File

@ -176,13 +176,13 @@ SERVICES_SET_PROGRAM_AND_OPTIONS = [
SERVICE_KV_CALL_PARAMS + SERVICE_COMMAND_CALL_PARAMS + SERVICE_PROGRAM_CALL_PARAMS,
)
async def test_key_value_services(
service_call: dict[str, Any],
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
service_call: dict[str, Any],
) -> None:
"""Create and test services."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -224,16 +224,16 @@ async def test_key_value_services(
],
)
async def test_programs_and_options_actions_deprecation(
service_call: dict[str, Any],
issue_id: str,
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
device_registry: dr.DeviceRegistry,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
issue_registry: ir.IssueRegistry,
hass_client: ClientSessionGenerator,
service_call: dict[str, Any],
issue_id: str,
) -> None:
"""Test deprecated service keys."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -294,14 +294,14 @@ async def test_programs_and_options_actions_deprecation(
),
)
async def test_set_program_and_options(
service_call: dict[str, Any],
called_method: str,
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
service_call: dict[str, Any],
called_method: str,
snapshot: SnapshotAssertion,
) -> None:
"""Test recognized options."""
@ -337,14 +337,14 @@ async def test_set_program_and_options(
),
)
async def test_set_program_and_options_exceptions(
service_call: dict[str, Any],
error_regex: str,
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
appliance: HomeAppliance,
service_call: dict[str, Any],
error_regex: str,
) -> None:
"""Test recognized options."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -367,13 +367,13 @@ async def test_set_program_and_options_exceptions(
SERVICE_KV_CALL_PARAMS + SERVICE_COMMAND_CALL_PARAMS + SERVICE_PROGRAM_CALL_PARAMS,
)
async def test_services_exception_device_id(
service_call: dict[str, Any],
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
appliance: HomeAppliance,
device_registry: dr.DeviceRegistry,
service_call: dict[str, Any],
) -> None:
"""Raise a HomeAssistantError when there is an API error."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -393,10 +393,10 @@ async def test_services_exception_device_id(
async def test_services_appliance_not_found(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
) -> None:
"""Raise a ServiceValidationError when device id does not match."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -439,13 +439,13 @@ async def test_services_appliance_not_found(
SERVICE_KV_CALL_PARAMS + SERVICE_COMMAND_CALL_PARAMS + SERVICE_PROGRAM_CALL_PARAMS,
)
async def test_services_exception(
service_call: dict[str, Any],
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
appliance: HomeAppliance,
device_registry: dr.DeviceRegistry,
service_call: dict[str, Any],
) -> None:
"""Raise a ValueError when device id does not match."""
assert config_entry.state == ConfigEntryState.NOT_LOADED

125
tests/components/home_connect/test_switch.py
View File

@ -71,13 +71,13 @@ def platforms() -> list[str]:
@pytest.mark.parametrize("appliance", ["Washer"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
client.get_available_program = AsyncMock(
@ -148,14 +148,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -219,9 +219,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Dishwasher"], indirect=True)
async def test_switch_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if switch entities availability are based on the appliance connection state."""
@ -300,16 +300,16 @@ async def test_switch_entity_availability(
indirect=["appliance"],
)
async def test_switch_functionality(
entity_id: str,
settings_key_arg: SettingKey,
setting_value_arg: Any,
service: str,
state: str,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
service: str,
settings_key_arg: SettingKey,
setting_value_arg: Any,
state: str,
appliance: HomeAppliance,
client: MagicMock,
) -> None:
"""Test switch functionality."""
@ -345,14 +345,14 @@ async def test_switch_functionality(
indirect=["appliance"],
)
async def test_program_switch_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
program_key: ProgramKey,
initial_state: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
client: MagicMock,
) -> None:
"""Test switch functionality."""
@ -450,14 +450,14 @@ async def test_program_switch_functionality(
],
)
async def test_switch_exception_handling(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
service: str,
mock_attr: str,
exception_match: str,
hass: HomeAssistant,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
client_with_exception: MagicMock,
) -> None:
"""Test exception handling."""
client_with_exception.get_all_programs.side_effect = None
@ -504,18 +504,16 @@ async def test_switch_exception_handling(
@pytest.mark.parametrize(
("entity_id", "status", "service", "state", "appliance"),
("entity_id", "service", "state", "appliance"),
[
(
"switch.fridgefreezer_freezer_super_mode",
{SettingKey.REFRIGERATION_FRIDGE_FREEZER_SUPER_MODE_FREEZER: True},
SERVICE_TURN_ON,
STATE_ON,
"FridgeFreezer",
),
(
"switch.fridgefreezer_freezer_super_mode",
{SettingKey.REFRIGERATION_FRIDGE_FREEZER_SUPER_MODE_FREEZER: False},
SERVICE_TURN_OFF,
STATE_OFF,
"FridgeFreezer",
@ -524,15 +522,13 @@ async def test_switch_exception_handling(
indirect=["appliance"],
)
async def test_ent_desc_switch_functionality(
entity_id: str,
status: dict,
service: str,
state: str,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
client: MagicMock,
entity_id: str,
service: str,
state: str,
) -> None:
"""Test switch functionality - entity description setup."""
@ -550,7 +546,6 @@ async def test_ent_desc_switch_functionality(
"entity_id",
"status",
"service",
"mock_attr",
"appliance",
"exception_match",
),
@ -559,7 +554,6 @@ async def test_ent_desc_switch_functionality(
"switch.fridgefreezer_freezer_super_mode",
{SettingKey.REFRIGERATION_FRIDGE_FREEZER_SUPER_MODE_FREEZER: ""},
SERVICE_TURN_ON,
"set_setting",
"FridgeFreezer",
r"Error.*turn.*on.*",
),
@ -567,7 +561,6 @@ async def test_ent_desc_switch_functionality(
"switch.fridgefreezer_freezer_super_mode",
{SettingKey.REFRIGERATION_FRIDGE_FREEZER_SUPER_MODE_FREEZER: ""},
SERVICE_TURN_OFF,
"set_setting",
"FridgeFreezer",
r"Error.*turn.*off.*",
),
@ -575,16 +568,14 @@ async def test_ent_desc_switch_functionality(
indirect=["appliance"],
)
async def test_ent_desc_switch_exception_handling(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
status: dict[SettingKey, str],
service: str,
mock_attr: str,
exception_match: str,
hass: HomeAssistant,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
config_entry: MockConfigEntry,
appliance: HomeAppliance,
client_with_exception: MagicMock,
) -> None:
"""Test switch exception handling - entity description setup."""
client_with_exception.get_settings.side_effect = None
@ -658,16 +649,16 @@ async def test_ent_desc_switch_exception_handling(
indirect=["appliance"],
)
async def test_power_switch(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
allowed_values: list[str | None] | None,
service: str,
setting_value_arg: str,
power_state: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
client: MagicMock,
) -> None:
"""Test power switch functionality."""
client.get_settings.side_effect = None
@ -706,11 +697,11 @@ async def test_power_switch(
],
)
async def test_power_switch_fetch_off_state_from_current_value(
initial_value: str,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
initial_value: str,
) -> None:
"""Test power switch functionality to fetch the off state from the current value."""
client.get_settings.side_effect = None
@ -755,14 +746,14 @@ async def test_power_switch_fetch_off_state_from_current_value(
],
)
async def test_power_switch_service_validation_errors(
entity_id: str,
allowed_values: list[str | None] | None | HomeConnectError,
service: str,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
exception_match: str,
client: MagicMock,
entity_id: str,
allowed_values: list[str | None] | None | HomeConnectError,
service: str,
) -> None:
"""Test power switch functionality validation errors."""
client.get_settings.side_effect = None
@ -807,12 +798,11 @@ async def test_power_switch_service_validation_errors(
)
async def test_create_program_switch_deprecation_issue(
hass: HomeAssistant,
appliance: HomeAppliance,
service: str,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
service: str,
) -> None:
"""Test that we create an issue when an automation or script is using a program switch entity or the entity is used by the user."""
entity_id = "switch.washer_program_mix"
@ -888,13 +878,12 @@ async def test_create_program_switch_deprecation_issue(
)
async def test_program_switch_deprecation_issue_fix(
hass: HomeAssistant,
appliance: HomeAppliance,
service: str,
hass_client: ClientSessionGenerator,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
hass_client: ClientSessionGenerator,
service: str,
) -> None:
"""Test we can fix the issues created when a program switch entity is in an automation or in a script or when is used."""
entity_id = "switch.washer_program_mix"
@ -1001,16 +990,16 @@ async def test_program_switch_deprecation_issue_fix(
indirect=["appliance"],
)
async def test_options_functionality(
entity_id: str,
option_key: OptionKey,
appliance: HomeAppliance,
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
set_active_program_options_side_effect: ActiveProgramNotSetError | None,
set_selected_program_options_side_effect: SelectedProgramNotSetError | None,
called_mock_method: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
entity_id: str,
option_key: OptionKey,
appliance: HomeAppliance,
) -> None:
"""Test options functionality."""
if set_active_program_options_side_effect:

48
tests/components/home_connect/test_time.py
View File

@ -48,13 +48,13 @@ def platforms() -> list[str]:
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
@pytest.mark.parametrize("appliance", ["Oven"], indirect=True)
async def test_paired_depaired_devices_flow(
appliance: HomeAppliance,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
) -> None:
"""Test that removed devices are correctly removed from and added to hass on API events."""
assert config_entry.state == ConfigEntryState.NOT_LOADED
@ -111,14 +111,14 @@ async def test_paired_depaired_devices_flow(
indirect=["appliance"],
)
async def test_connected_devices(
appliance: HomeAppliance,
keys_to_check: tuple,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
keys_to_check: tuple,
) -> None:
"""Test that devices reconnected.
@ -172,9 +172,9 @@ async def test_connected_devices(
@pytest.mark.parametrize("appliance", ["Oven"], indirect=True)
async def test_time_entity_availability(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
appliance: HomeAppliance,
) -> None:
"""Test if time entities availability are based on the appliance connection state."""
@ -233,13 +233,13 @@ async def test_time_entity_availability(
],
)
async def test_time_entity_functionality(
hass: HomeAssistant,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
appliance: HomeAppliance,
entity_id: str,
setting_key: SettingKey,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
) -> None:
"""Test time entity functionality."""
assert config_entry.state is ConfigEntryState.NOT_LOADED
@ -277,13 +277,13 @@ async def test_time_entity_functionality(
],
)
async def test_time_entity_error(
hass: HomeAssistant,
client_with_exception: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
entity_id: str,
setting_key: SettingKey,
mock_attr: str,
hass: HomeAssistant,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client_with_exception: MagicMock,
) -> None:
"""Test time entity error."""
client_with_exception.get_settings.side_effect = None
@ -322,11 +322,10 @@ async def test_time_entity_error(
@pytest.mark.parametrize("appliance", ["Oven"], indirect=True)
async def test_create_alarm_clock_deprecation_issue(
hass: HomeAssistant,
appliance: HomeAppliance,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
) -> None:
"""Test that we create an issue when an automation or script is using a alarm clock time entity or the entity is used by the user."""
entity_id = f"{TIME_DOMAIN}.oven_alarm_clock"
@ -402,12 +401,11 @@ async def test_create_alarm_clock_deprecation_issue(
@pytest.mark.parametrize("appliance", ["Oven"], indirect=True)
async def test_alarm_clock_deprecation_issue_fix(
hass: HomeAssistant,
appliance: HomeAppliance,
hass_client: ClientSessionGenerator,
issue_registry: ir.IssueRegistry,
client: MagicMock,
config_entry: MockConfigEntry,
integration_setup: Callable[[MagicMock], Awaitable[bool]],
client: MagicMock,
issue_registry: ir.IssueRegistry,
hass_client: ClientSessionGenerator,
) -> None:
"""Test we can fix the issues created when a alarm clock time entity is in an automation or in a script or when is used."""
entity_id = f"{TIME_DOMAIN}.oven_alarm_clock"