From b5664f9eaf11a75a87f8cc60cc096212e472b266 Mon Sep 17 00:00:00 2001 From: amitfin Date: Tue, 3 Jan 2023 20:21:11 +0200 Subject: [PATCH] Bump pycoolmasternet-async and add coolmaster swing mode (#82809) * Add filter and error code support to CoolMastetNet * Create separate entities * coolmaster swing_mode support * Changed default to False * Raise HomeAssistantError * Add tests for init and climate * Fixed bad merge * Catch only ValueError --- .coveragerc | 3 - .../components/coolmaster/__init__.py | 6 +- .../components/coolmaster/climate.py | 38 ++- .../components/coolmaster/config_flow.py | 11 +- homeassistant/components/coolmaster/const.py | 1 + .../components/coolmaster/strings.json | 3 +- .../coolmaster/translations/en.json | 3 +- tests/components/coolmaster/conftest.py | 84 +++-- tests/components/coolmaster/test_climate.py | 290 ++++++++++++++++++ .../components/coolmaster/test_config_flow.py | 2 + tests/components/coolmaster/test_init.py | 26 ++ 11 files changed, 430 insertions(+), 37 deletions(-) create mode 100644 tests/components/coolmaster/test_climate.py create mode 100644 tests/components/coolmaster/test_init.py diff --git a/.coveragerc b/.coveragerc index b6972ddde4d..21b860bc602 100644 --- a/.coveragerc +++ b/.coveragerc @@ -195,9 +195,6 @@ omit = homeassistant/components/control4/const.py homeassistant/components/control4/director_utils.py homeassistant/components/control4/light.py - homeassistant/components/coolmaster/__init__.py - homeassistant/components/coolmaster/climate.py - homeassistant/components/coolmaster/const.py homeassistant/components/cppm_tracker/device_tracker.py homeassistant/components/crownstone/__init__.py homeassistant/components/crownstone/const.py diff --git a/homeassistant/components/coolmaster/__init__.py b/homeassistant/components/coolmaster/__init__.py index 6e244abfd84..129797c356f 100644 --- a/homeassistant/components/coolmaster/__init__.py +++ b/homeassistant/components/coolmaster/__init__.py @@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConfigEntryNotReady from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed -from .const import DATA_COORDINATOR, DATA_INFO, DOMAIN +from .const import CONF_SWING_SUPPORT, DATA_COORDINATOR, DATA_INFO, DOMAIN _LOGGER = logging.getLogger(__name__) @@ -21,7 +21,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up Coolmaster from a config entry.""" host = entry.data[CONF_HOST] port = entry.data[CONF_PORT] - coolmaster = CoolMasterNet(host, port) + coolmaster = CoolMasterNet( + host, port, swing_support=entry.data.get(CONF_SWING_SUPPORT, False) + ) try: info = await coolmaster.info() if not info: diff --git a/homeassistant/components/coolmaster/climate.py b/homeassistant/components/coolmaster/climate.py index 27c139af824..d27f776c655 100644 --- a/homeassistant/components/coolmaster/climate.py +++ b/homeassistant/components/coolmaster/climate.py @@ -1,7 +1,11 @@ """CoolMasterNet platform to control of CoolMasterNet Climate Devices.""" +from __future__ import annotations + import logging from typing import Any +from pycoolmasternet_async import SWING_MODES + from homeassistant.components.climate import ( ClimateEntity, ClimateEntityFeature, @@ -10,6 +14,7 @@ from homeassistant.components.climate import ( from homeassistant.config_entries import ConfigEntry from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature from homeassistant.core import HomeAssistant +from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers.entity_platform import AddEntitiesCallback from .const import CONF_SUPPORTED_MODES, DATA_COORDINATOR, DATA_INFO, DOMAIN @@ -48,10 +53,6 @@ async def async_setup_entry( class CoolmasterClimate(CoolmasterEntity, ClimateEntity): """Representation of a coolmaster climate device.""" - _attr_supported_features = ( - ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE - ) - def __init__(self, coordinator, unit_id, info, supported_modes): """Initialize the climate device.""" super().__init__(coordinator, unit_id, info) @@ -67,6 +68,16 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity): """Return the name of the climate device.""" return self.unique_id + @property + def supported_features(self) -> ClimateEntityFeature: + """Return the list of supported features.""" + supported_features = ( + ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE + ) + if self.swing_mode: + supported_features |= ClimateEntityFeature.SWING_MODE + return supported_features + @property def temperature_unit(self) -> str: """Return the unit of measurement.""" @@ -109,6 +120,16 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity): """Return the list of available fan modes.""" return FAN_MODES + @property + def swing_mode(self) -> str | None: + """Return the swing mode setting.""" + return self._unit.swing + + @property + def swing_modes(self) -> list[str] | None: + """Return swing modes if supported.""" + return SWING_MODES if self.swing_mode is not None else None + async def async_set_temperature(self, **kwargs: Any) -> None: """Set new target temperatures.""" if (temp := kwargs.get(ATTR_TEMPERATURE)) is not None: @@ -122,6 +143,15 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity): self._unit = await self._unit.set_fan_speed(fan_mode) self.async_write_ha_state() + async def async_set_swing_mode(self, swing_mode: str) -> None: + """Set new swing mode.""" + _LOGGER.debug("Setting swing mode of %s to %s", self.unique_id, swing_mode) + try: + self._unit = await self._unit.set_swing(swing_mode) + except ValueError as error: + raise HomeAssistantError(error) from error + self.async_write_ha_state() + async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None: """Set new operation mode.""" _LOGGER.debug("Setting operation mode of %s to %s", self.unique_id, hvac_mode) diff --git a/homeassistant/components/coolmaster/config_flow.py b/homeassistant/components/coolmaster/config_flow.py index 9ad88d36574..ad3817b77ce 100644 --- a/homeassistant/components/coolmaster/config_flow.py +++ b/homeassistant/components/coolmaster/config_flow.py @@ -12,7 +12,7 @@ from homeassistant.const import CONF_HOST, CONF_PORT from homeassistant.core import callback from homeassistant.data_entry_flow import FlowResult -from .const import CONF_SUPPORTED_MODES, DEFAULT_PORT, DOMAIN +from .const import CONF_SUPPORTED_MODES, CONF_SWING_SUPPORT, DEFAULT_PORT, DOMAIN AVAILABLE_MODES = [ HVACMode.OFF.value, @@ -25,7 +25,13 @@ AVAILABLE_MODES = [ MODES_SCHEMA = {vol.Required(mode, default=True): bool for mode in AVAILABLE_MODES} -DATA_SCHEMA = vol.Schema({vol.Required(CONF_HOST): str, **MODES_SCHEMA}) +DATA_SCHEMA = vol.Schema( + { + vol.Required(CONF_HOST): str, + **MODES_SCHEMA, + vol.Required(CONF_SWING_SUPPORT, default=False): bool, + } +) async def _validate_connection(host: str) -> bool: @@ -50,6 +56,7 @@ class CoolmasterConfigFlow(ConfigFlow, domain=DOMAIN): CONF_HOST: data[CONF_HOST], CONF_PORT: DEFAULT_PORT, CONF_SUPPORTED_MODES: supported_modes, + CONF_SWING_SUPPORT: data[CONF_SWING_SUPPORT], }, ) diff --git a/homeassistant/components/coolmaster/const.py b/homeassistant/components/coolmaster/const.py index e5aa1f1b93d..1fa46e20ee9 100644 --- a/homeassistant/components/coolmaster/const.py +++ b/homeassistant/components/coolmaster/const.py @@ -8,3 +8,4 @@ DOMAIN = "coolmaster" DEFAULT_PORT = 10102 CONF_SUPPORTED_MODES = "supported_modes" +CONF_SWING_SUPPORT = "swing_support" diff --git a/homeassistant/components/coolmaster/strings.json b/homeassistant/components/coolmaster/strings.json index 970660e6e63..6bba26b6bc9 100644 --- a/homeassistant/components/coolmaster/strings.json +++ b/homeassistant/components/coolmaster/strings.json @@ -10,7 +10,8 @@ "cool": "Support cool mode", "heat_cool": "Support automatic heat/cool mode", "dry": "Support dry mode", - "fan_only": "Support fan only mode" + "fan_only": "Support fan only mode", + "swing_support": "Control swing mode" } } }, diff --git a/homeassistant/components/coolmaster/translations/en.json b/homeassistant/components/coolmaster/translations/en.json index 9f12a4ebb30..57cea971c66 100644 --- a/homeassistant/components/coolmaster/translations/en.json +++ b/homeassistant/components/coolmaster/translations/en.json @@ -13,7 +13,8 @@ "heat": "Support heat mode", "heat_cool": "Support automatic heat/cool mode", "host": "Host", - "off": "Can be turned off" + "off": "Can be turned off", + "swing_support": "Control swing mode" }, "title": "Set up your CoolMasterNet connection details." } diff --git a/tests/components/coolmaster/conftest.py b/tests/components/coolmaster/conftest.py index c46a33aaa97..fadce747d6a 100644 --- a/tests/components/coolmaster/conftest.py +++ b/tests/components/coolmaster/conftest.py @@ -7,6 +7,7 @@ from unittest.mock import patch import pytest +from homeassistant.components.climate import HVACMode from homeassistant.components.coolmaster.const import DOMAIN from homeassistant.core import HomeAssistant @@ -16,27 +17,28 @@ DEFAULT_INFO: dict[str, str] = { "version": "1", } -DEFUALT_UNIT_DATA: dict[str, Any] = { - "is_on": False, - "thermostat": 20, - "temperature": 25, - "fan_speed": "low", - "mode": "cool", - "error_code": None, - "clean_filter": False, - "swing": None, - "temperature_unit": "celsius", -} - TEST_UNITS: dict[dict[str, Any]] = { - "L1.100": {**DEFUALT_UNIT_DATA}, + "L1.100": { + "is_on": False, + "thermostat": 20, + "temperature": 25, + "temperature_unit": "celsius", + "fan_speed": "low", + "mode": "cool", + "error_code": None, + "clean_filter": False, + "swing": None, + }, "L1.101": { - **DEFUALT_UNIT_DATA, - **{ - "is_on": True, - "clean_filter": True, - "error_code": "Err1", - }, + "is_on": True, + "thermostat": 68, + "temperature": 50, + "temperature_unit": "imperial", + "fan_speed": "high", + "mode": "heat", + "error_code": "Err1", + "clean_filter": True, + "swing": "horizontal", }, } @@ -51,17 +53,50 @@ class CoolMasterNetUnitMock: for key, value in attributes.items(): setattr(self, key, value) - async def reset_filter(self): + async def set_fan_speed(self, value: str) -> CoolMasterNetUnitMock: + """Set the fan speed.""" + self._attributes["fan_speed"] = value + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def set_mode(self, value: str) -> CoolMasterNetUnitMock: + """Set the mode.""" + self._attributes["mode"] = value + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def set_thermostat(self, value: int | float) -> CoolMasterNetUnitMock: + """Set the target temperature.""" + self._attributes["thermostat"] = value + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def set_swing(self, value: str | None) -> CoolMasterNetUnitMock: + """Set the swing mode.""" + if value == "": + raise ValueError() + self._attributes["swing"] = value + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def turn_on(self) -> CoolMasterNetUnitMock: + """Turn a unit on.""" + self._attributes["is_on"] = True + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def turn_off(self) -> CoolMasterNetUnitMock: + """Turn a unit off.""" + self._attributes["is_on"] = False + return CoolMasterNetUnitMock(self.unit_id, self._attributes) + + async def reset_filter(self) -> CoolMasterNetUnitMock: """Report that the air filter was cleaned and reset the timer.""" self._attributes["clean_filter"] = False + return CoolMasterNetUnitMock(self.unit_id, self._attributes) class CoolMasterNetMock: """Mock for CoolMasterNet.""" - def __init__(self, *_args: Any) -> None: + def __init__(self, *_args: Any, **kwargs: Any) -> None: """Initialize the CoolMasterNetMock.""" - self._data = copy.deepcopy(TEST_UNITS) + self._units = copy.deepcopy(TEST_UNITS) async def info(self) -> dict[str, Any]: """Return info about the bridge device.""" @@ -70,8 +105,8 @@ class CoolMasterNetMock: async def status(self) -> dict[str, CoolMasterNetUnitMock]: """Return the units.""" return { - key: CoolMasterNetUnitMock(key, attributes) - for key, attributes in self._data.items() + unit_id: CoolMasterNetUnitMock(unit_id, attributes) + for unit_id, attributes in self._units.items() } @@ -83,6 +118,7 @@ async def load_int(hass: HomeAssistant) -> MockConfigEntry: data={ "host": "1.2.3.4", "port": 1234, + "supported_modes": [HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT], }, ) diff --git a/tests/components/coolmaster/test_climate.py b/tests/components/coolmaster/test_climate.py new file mode 100644 index 00000000000..5f98082e822 --- /dev/null +++ b/tests/components/coolmaster/test_climate.py @@ -0,0 +1,290 @@ +"""The test for the Coolmaster climate platform.""" +from __future__ import annotations + +from pycoolmasternet_async import SWING_MODES +import pytest + +from homeassistant.components.climate import ( + ATTR_CURRENT_TEMPERATURE, + ATTR_FAN_MODE, + ATTR_FAN_MODES, + ATTR_HVAC_MODE, + ATTR_HVAC_MODES, + ATTR_SWING_MODE, + ATTR_SWING_MODES, + DOMAIN as CLIMATE_DOMAIN, + FAN_HIGH, + FAN_LOW, + SERVICE_SET_FAN_MODE, + SERVICE_SET_HVAC_MODE, + SERVICE_SET_SWING_MODE, + SERVICE_SET_TEMPERATURE, + ClimateEntityFeature, + HVACMode, +) +from homeassistant.components.coolmaster.climate import FAN_MODES +from homeassistant.config_entries import ConfigEntry +from homeassistant.const import ( + ATTR_ENTITY_ID, + ATTR_FRIENDLY_NAME, + ATTR_SUPPORTED_FEATURES, + ATTR_TEMPERATURE, + SERVICE_TURN_OFF, + SERVICE_TURN_ON, +) +from homeassistant.core import HomeAssistant +from homeassistant.exceptions import HomeAssistantError + + +async def test_climate_state( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate state.""" + assert hass.states.get("climate.l1_100").state == HVACMode.OFF + assert hass.states.get("climate.l1_101").state == HVACMode.HEAT + + +async def test_climate_friendly_name( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate friendly name.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_FRIENDLY_NAME] == "L1.100" + assert hass.states.get("climate.l1_101").attributes[ATTR_FRIENDLY_NAME] == "L1.101" + + +async def test_climate_supported_features( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate supported features.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_SUPPORTED_FEATURES] == ( + ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE + ) + assert hass.states.get("climate.l1_101").attributes[ATTR_SUPPORTED_FEATURES] == ( + ClimateEntityFeature.TARGET_TEMPERATURE + | ClimateEntityFeature.FAN_MODE + | ClimateEntityFeature.SWING_MODE + ) + + +async def test_climate_temperature( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate current temperature.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_CURRENT_TEMPERATURE] == 25 + assert hass.states.get("climate.l1_101").attributes[ATTR_CURRENT_TEMPERATURE] == 10 + + +async def test_climate_thermostat( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate thermostat.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_TEMPERATURE] == 20 + assert hass.states.get("climate.l1_101").attributes[ATTR_TEMPERATURE] == 20 + + +async def test_climate_hvac_modes( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate hvac modes.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_HVAC_MODES] == [ + HVACMode.OFF, + HVACMode.COOL, + HVACMode.HEAT, + ] + assert ( + hass.states.get("climate.l1_101").attributes[ATTR_HVAC_MODES] + == hass.states.get("climate.l1_100").attributes[ATTR_HVAC_MODES] + ) + + +async def test_climate_fan_mode( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate fan mode.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_FAN_MODE] == FAN_LOW + assert hass.states.get("climate.l1_101").attributes[ATTR_FAN_MODE] == FAN_HIGH + + +async def test_climate_fan_modes( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate fan modes.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_FAN_MODES] == FAN_MODES + assert ( + hass.states.get("climate.l1_101").attributes[ATTR_FAN_MODES] + == hass.states.get("climate.l1_100").attributes[ATTR_FAN_MODES] + ) + + +async def test_climate_swing_mode( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate swing mode.""" + assert ATTR_SWING_MODE not in hass.states.get("climate.l1_100").attributes + assert hass.states.get("climate.l1_101").attributes[ATTR_SWING_MODE] == "horizontal" + + +async def test_climate_swing_modes( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate swing modes.""" + assert ATTR_SWING_MODES not in hass.states.get("climate.l1_100").attributes + assert hass.states.get("climate.l1_101").attributes[ATTR_SWING_MODES] == SWING_MODES + + +async def test_set_temperature( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set temperature.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_TEMPERATURE] == 20 + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_TEMPERATURE, + { + ATTR_ENTITY_ID: "climate.l1_100", + ATTR_TEMPERATURE: 30, + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_100").attributes[ATTR_TEMPERATURE] == 30 + + +async def test_set_fan_mode( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set fan mode.""" + assert hass.states.get("climate.l1_100").attributes[ATTR_FAN_MODE] == FAN_LOW + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_FAN_MODE, + { + ATTR_ENTITY_ID: "climate.l1_100", + ATTR_FAN_MODE: FAN_HIGH, + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_100").attributes[ATTR_FAN_MODE] == FAN_HIGH + + +async def test_set_swing_mode( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set swing mode.""" + assert hass.states.get("climate.l1_101").attributes[ATTR_SWING_MODE] == "horizontal" + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_SWING_MODE, + { + ATTR_ENTITY_ID: "climate.l1_101", + ATTR_SWING_MODE: "vertical", + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_101").attributes[ATTR_SWING_MODE] == "vertical" + + +async def test_set_swing_mode_error( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set swing mode with error.""" + with pytest.raises(HomeAssistantError): + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_SWING_MODE, + { + ATTR_ENTITY_ID: "climate.l1_101", + ATTR_SWING_MODE: "", + }, + blocking=True, + ) + + +async def test_set_hvac_mode( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set hvac mode.""" + assert hass.states.get("climate.l1_100").state == HVACMode.OFF + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_HVAC_MODE, + { + ATTR_ENTITY_ID: "climate.l1_100", + ATTR_HVAC_MODE: HVACMode.HEAT, + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_100").state == HVACMode.HEAT + + +async def test_set_hvac_mode_off( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate set hvac mode to off.""" + assert hass.states.get("climate.l1_101").state == HVACMode.HEAT + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_SET_HVAC_MODE, + { + ATTR_ENTITY_ID: "climate.l1_101", + ATTR_HVAC_MODE: HVACMode.OFF, + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_101").state == HVACMode.OFF + + +async def test_turn_on( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate turn on.""" + assert hass.states.get("climate.l1_100").state == HVACMode.OFF + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_TURN_ON, + { + ATTR_ENTITY_ID: "climate.l1_100", + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_100").state == HVACMode.COOL + + +async def test_turn_off( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test the Coolmaster climate turn off.""" + assert hass.states.get("climate.l1_101").state == HVACMode.HEAT + await hass.services.async_call( + CLIMATE_DOMAIN, + SERVICE_TURN_OFF, + { + ATTR_ENTITY_ID: "climate.l1_101", + }, + blocking=True, + ) + await hass.async_block_till_done() + assert hass.states.get("climate.l1_101").state == HVACMode.OFF diff --git a/tests/components/coolmaster/test_config_flow.py b/tests/components/coolmaster/test_config_flow.py index 1f69e2336bc..2927f438af8 100644 --- a/tests/components/coolmaster/test_config_flow.py +++ b/tests/components/coolmaster/test_config_flow.py @@ -10,6 +10,7 @@ def _flow_data(): options = {"host": "1.1.1.1"} for mode in AVAILABLE_MODES: options[mode] = True + options["swing_support"] = False return options @@ -39,6 +40,7 @@ async def test_form(hass): "host": "1.1.1.1", "port": 10102, "supported_modes": AVAILABLE_MODES, + "swing_support": False, } assert len(mock_setup_entry.mock_calls) == 1 diff --git a/tests/components/coolmaster/test_init.py b/tests/components/coolmaster/test_init.py new file mode 100644 index 00000000000..ce6dd8f60a4 --- /dev/null +++ b/tests/components/coolmaster/test_init.py @@ -0,0 +1,26 @@ +"""The test for the Coolmaster integration.""" +from homeassistant.components.coolmaster.const import DOMAIN +from homeassistant.config_entries import ConfigEntry, ConfigEntryState +from homeassistant.core import HomeAssistant + + +async def test_load_entry( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test Coolmaster initial load.""" + # 2 units times 4 entities (climate, binary_sensor, sensor, button). + assert hass.states.async_entity_ids_count() == 8 + assert load_int.state is ConfigEntryState.LOADED + + +async def test_unload_entry( + hass: HomeAssistant, + load_int: ConfigEntry, +) -> None: + """Test Coolmaster unloading an entry.""" + assert load_int.entry_id in hass.data.get(DOMAIN) + await hass.config_entries.async_unload(load_int.entry_id) + await hass.async_block_till_done() + assert load_int.state is ConfigEntryState.NOT_LOADED + assert not hass.data.get(DOMAIN)