mirror of
https://github.com/home-assistant/core.git
synced 2026-06-30 19:26:31 +01:00
Przemko92
354 lines
12 KiB
Python
354 lines
12 KiB
Python
"""Tests for the Compit climate platform."""
|
|
|
|
from unittest.mock import MagicMock
|
|
|
|
from compit_inext_api.consts import (
|
|
CompitFanMode,
|
|
CompitHVACMode,
|
|
CompitParameter,
|
|
CompitPresetMode,
|
|
)
|
|
import pytest
|
|
from syrupy.assertion import SnapshotAssertion
|
|
|
|
from homeassistant.components.climate import (
|
|
ATTR_FAN_MODE,
|
|
ATTR_HVAC_MODE,
|
|
ATTR_PRESET_MODE,
|
|
DOMAIN as CLIMATE_DOMAIN,
|
|
FAN_AUTO,
|
|
FAN_HIGH,
|
|
FAN_LOW,
|
|
FAN_MEDIUM,
|
|
FAN_OFF,
|
|
PRESET_AWAY,
|
|
PRESET_ECO,
|
|
PRESET_HOME,
|
|
PRESET_NONE,
|
|
SERVICE_SET_FAN_MODE,
|
|
SERVICE_SET_HVAC_MODE,
|
|
SERVICE_SET_PRESET_MODE,
|
|
SERVICE_SET_TEMPERATURE,
|
|
HVACMode,
|
|
)
|
|
from homeassistant.const import (
|
|
ATTR_ENTITY_ID,
|
|
ATTR_TEMPERATURE,
|
|
STATE_UNKNOWN,
|
|
Platform,
|
|
)
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers import entity_registry as er
|
|
|
|
from . import setup_integration, snapshot_compit_entities
|
|
|
|
from tests.common import MockConfigEntry
|
|
|
|
CLIMATE_R900 = "climate.r_900"
|
|
CLIMATE_NANO_COLOR_2 = "climate.nano_color_2"
|
|
|
|
|
|
def _make_climate_values(
|
|
hvac_mode: str = CompitHVACMode.HEAT.value,
|
|
preset_mode: str = CompitPresetMode.AUTO.value,
|
|
fan_mode: str = CompitFanMode.AUTO.value,
|
|
current_temp: float = 21.0,
|
|
target_temp: float = 22.0,
|
|
) -> dict:
|
|
return {
|
|
CompitParameter.HVAC_MODE: hvac_mode,
|
|
CompitParameter.PRESET_MODE: preset_mode,
|
|
CompitParameter.FAN_MODE: fan_mode,
|
|
CompitParameter.CURRENT_TEMPERATURE: current_temp,
|
|
CompitParameter.SET_TARGET_TEMPERATURE: target_temp,
|
|
}
|
|
|
|
|
|
async def test_climate_entities_snapshot(
|
|
hass: HomeAssistant,
|
|
entity_registry: er.EntityRegistry,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
snapshot: SnapshotAssertion,
|
|
) -> None:
|
|
"""Snapshot test for climate entities creation, unique IDs, and device info."""
|
|
values = _make_climate_values()
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: values.get(
|
|
param
|
|
)
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
snapshot_compit_entities(hass, entity_registry, snapshot, Platform.CLIMATE)
|
|
|
|
|
|
async def test_climate_unknown_device_not_created(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
) -> None:
|
|
"""Test that devices with unknown definition codes do not create climate entities."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
assert hass.states.get(CLIMATE_R900) is not None
|
|
assert hass.states.get(CLIMATE_NANO_COLOR_2) is not None
|
|
assert len(hass.states.async_all(Platform.CLIMATE)) == 2
|
|
|
|
|
|
async def test_climate_state_unknown_when_hvac_mode_none(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
) -> None:
|
|
"""Test climate entity state is unknown when hvac mode returns None."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
state = hass.states.get(CLIMATE_NANO_COLOR_2)
|
|
assert state is not None
|
|
assert state.state == STATE_UNKNOWN
|
|
assert state.attributes.get("current_temperature") is None
|
|
assert state.attributes.get("temperature") is None
|
|
assert state.attributes.get("preset_mode") is None
|
|
assert state.attributes.get("fan_mode") is None
|
|
|
|
|
|
async def test_climate_set_temperature(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
) -> None:
|
|
"""Test setting the target temperature."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
await hass.services.async_call(
|
|
CLIMATE_DOMAIN,
|
|
SERVICE_SET_TEMPERATURE,
|
|
{ATTR_ENTITY_ID: CLIMATE_NANO_COLOR_2, ATTR_TEMPERATURE: 23.5},
|
|
blocking=True,
|
|
)
|
|
|
|
mock_connector.set_device_parameter.assert_called_once_with(
|
|
2, CompitParameter.SET_TARGET_TEMPERATURE, 23.5
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("ha_mode", "expected_compit_mode"),
|
|
[
|
|
pytest.param(HVACMode.COOL, CompitHVACMode.COOL, id="cool"),
|
|
pytest.param(HVACMode.HEAT, CompitHVACMode.HEAT, id="heat"),
|
|
pytest.param(HVACMode.OFF, CompitHVACMode.OFF, id="off"),
|
|
],
|
|
)
|
|
async def test_climate_set_hvac_mode(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
ha_mode: HVACMode,
|
|
expected_compit_mode: CompitHVACMode,
|
|
) -> None:
|
|
"""Test setting HVAC mode."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
await hass.services.async_call(
|
|
CLIMATE_DOMAIN,
|
|
SERVICE_SET_HVAC_MODE,
|
|
{ATTR_ENTITY_ID: CLIMATE_NANO_COLOR_2, ATTR_HVAC_MODE: ha_mode},
|
|
blocking=True,
|
|
)
|
|
|
|
mock_connector.set_device_parameter.assert_called_once_with(
|
|
2, CompitParameter.HVAC_MODE, expected_compit_mode.value
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("ha_preset", "expected_compit_preset"),
|
|
[
|
|
pytest.param(PRESET_HOME, CompitPresetMode.AUTO, id="home"),
|
|
pytest.param(PRESET_ECO, CompitPresetMode.HOLIDAY, id="eco"),
|
|
pytest.param(PRESET_NONE, CompitPresetMode.MANUAL, id="none"),
|
|
pytest.param(PRESET_AWAY, CompitPresetMode.AWAY, id="away"),
|
|
],
|
|
)
|
|
async def test_climate_set_preset_mode(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
ha_preset: str,
|
|
expected_compit_preset: CompitPresetMode,
|
|
) -> None:
|
|
"""Test setting preset mode."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
await hass.services.async_call(
|
|
CLIMATE_DOMAIN,
|
|
SERVICE_SET_PRESET_MODE,
|
|
{ATTR_ENTITY_ID: CLIMATE_NANO_COLOR_2, ATTR_PRESET_MODE: ha_preset},
|
|
blocking=True,
|
|
)
|
|
|
|
mock_connector.set_device_parameter.assert_called_once_with(
|
|
2, CompitParameter.PRESET_MODE, expected_compit_preset.value
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("ha_fan_mode", "expected_compit_fan_mode"),
|
|
[
|
|
pytest.param(FAN_OFF, CompitFanMode.OFF, id="off"),
|
|
pytest.param(
|
|
FAN_AUTO, CompitFanMode.HOLIDAY, id="auto"
|
|
), # HOLIDAY overwrites AUTO in the reverse map (both map to FAN_AUTO)
|
|
pytest.param(FAN_LOW, CompitFanMode.LOW, id="low"),
|
|
pytest.param(FAN_MEDIUM, CompitFanMode.MEDIUM, id="medium"),
|
|
pytest.param(FAN_HIGH, CompitFanMode.HIGH, id="high"),
|
|
],
|
|
)
|
|
async def test_climate_set_fan_mode(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
ha_fan_mode: str,
|
|
expected_compit_fan_mode: CompitFanMode,
|
|
) -> None:
|
|
"""Test setting fan mode."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
await hass.services.async_call(
|
|
CLIMATE_DOMAIN,
|
|
SERVICE_SET_FAN_MODE,
|
|
{ATTR_ENTITY_ID: CLIMATE_NANO_COLOR_2, ATTR_FAN_MODE: ha_fan_mode},
|
|
blocking=True,
|
|
)
|
|
|
|
mock_connector.set_device_parameter.assert_called_once_with(
|
|
2, CompitParameter.FAN_MODE, expected_compit_fan_mode.value
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("hvac_value", "expected_ha_mode"),
|
|
[
|
|
pytest.param(CompitHVACMode.COOL.value, HVACMode.COOL, id="cool"),
|
|
pytest.param(CompitHVACMode.HEAT.value, HVACMode.HEAT, id="heat"),
|
|
pytest.param(CompitHVACMode.OFF.value, HVACMode.OFF, id="off"),
|
|
],
|
|
)
|
|
async def test_climate_hvac_mode_state(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
hvac_value: str,
|
|
expected_ha_mode: HVACMode,
|
|
) -> None:
|
|
"""Test that HVAC mode is correctly translated to HA state."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: (
|
|
hvac_value if param == CompitParameter.HVAC_MODE else None
|
|
)
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
state = hass.states.get(CLIMATE_NANO_COLOR_2)
|
|
assert state is not None
|
|
assert state.state == expected_ha_mode
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("preset_value", "expected_ha_preset"),
|
|
[
|
|
pytest.param(CompitPresetMode.AUTO.value, PRESET_HOME, id="home"),
|
|
pytest.param(CompitPresetMode.HOLIDAY.value, PRESET_ECO, id="eco"),
|
|
pytest.param(CompitPresetMode.MANUAL.value, PRESET_NONE, id="none"),
|
|
pytest.param(CompitPresetMode.AWAY.value, PRESET_AWAY, id="away"),
|
|
],
|
|
)
|
|
async def test_climate_preset_mode_state(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
preset_value: str,
|
|
expected_ha_preset: str,
|
|
) -> None:
|
|
"""Test that preset mode is correctly translated to HA preset."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: (
|
|
preset_value if param == CompitParameter.PRESET_MODE else None
|
|
)
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
state = hass.states.get(CLIMATE_NANO_COLOR_2)
|
|
assert state is not None
|
|
assert state.attributes.get("preset_mode") == expected_ha_preset
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("fan_value", "expected_ha_fan"),
|
|
[
|
|
pytest.param(CompitFanMode.OFF.value, FAN_OFF, id="off"),
|
|
pytest.param(CompitFanMode.AUTO.value, FAN_AUTO, id="auto"),
|
|
pytest.param(CompitFanMode.LOW.value, FAN_LOW, id="low"),
|
|
pytest.param(CompitFanMode.MEDIUM.value, FAN_MEDIUM, id="medium"),
|
|
pytest.param(CompitFanMode.HIGH.value, FAN_HIGH, id="high"),
|
|
],
|
|
)
|
|
async def test_climate_fan_mode_state(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
fan_value: str,
|
|
expected_ha_fan: str,
|
|
) -> None:
|
|
"""Test that fan mode is correctly translated to HA fan mode."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: (
|
|
fan_value if param == CompitParameter.FAN_MODE else None
|
|
)
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
state = hass.states.get(CLIMATE_NANO_COLOR_2)
|
|
assert state is not None
|
|
assert state.attributes.get("fan_mode") == expected_ha_fan
|
|
|
|
|
|
async def test_climate_r900_preset_mode(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
) -> None:
|
|
"""Test R 900 device sets preset mode."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
mock_connector.set_device_parameter.side_effect = None
|
|
mock_connector.set_device_parameter.return_value = True
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
await hass.services.async_call(
|
|
CLIMATE_DOMAIN,
|
|
SERVICE_SET_PRESET_MODE,
|
|
{ATTR_ENTITY_ID: CLIMATE_R900, ATTR_PRESET_MODE: PRESET_AWAY},
|
|
blocking=True,
|
|
)
|
|
|
|
mock_connector.set_device_parameter.assert_called_once_with(
|
|
1, CompitParameter.PRESET_MODE, CompitPresetMode.AWAY.value
|
|
)
|
|
|
|
|
|
async def test_climate_r900_supported_features(
|
|
hass: HomeAssistant,
|
|
mock_config_entry: MockConfigEntry,
|
|
mock_connector: MagicMock,
|
|
) -> None:
|
|
"""Test R 900 only supports preset mode (no fan or target temperature)."""
|
|
mock_connector.get_current_value.side_effect = lambda device_id, param: None
|
|
await setup_integration(hass, mock_config_entry)
|
|
|
|
state = hass.states.get(CLIMATE_R900)
|
|
assert state is not None
|
|
assert state.attributes.get("fan_mode") is None
|
|
assert state.attributes.get("temperature") is None
|
|
assert state.attributes.get("preset_modes") == [PRESET_HOME, PRESET_AWAY]
|
|
assert state.attributes.get("hvac_modes") == [HVACMode.HEAT, HVACMode.OFF]
|