Replace climate constants with enums where available.

- replace SUPPORT_* with ClimateEntityFeature enum
- replace HVAC_MODE_* with HVACMode enum
- replace CURRENT_HVAC_* with HVACAction enum
- For all entity types, do not return STATE_UNAVAILABLE, as it causes errors in 2022.5 and later (including in unit tests).

Issue #167

custom_components/tuya_local/generic/climate.py

@@ -3,7 +3,12 @@ Platform to control tuya climate devices.
 """
 import logging
 
-from homeassistant.components.climate import ClimateEntity
+from homeassistant.components.climate import (
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
+)
 from homeassistant.components.climate.const import (
     ATTR_AUX_HEAT,
     ATTR_CURRENT_HUMIDITY,
@@ -20,18 +25,9 @@ from homeassistant.components.climate.const import (
     DEFAULT_MAX_TEMP,
     DEFAULT_MIN_HUMIDITY,
     DEFAULT_MIN_TEMP,
-    HVAC_MODE_AUTO,
-    SUPPORT_AUX_HEAT,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_HUMIDITY,
-    SUPPORT_TARGET_TEMPERATURE,
-    SUPPORT_TARGET_TEMPERATURE_RANGE,
 )
 from homeassistant.const import (
     ATTR_TEMPERATURE,
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
     TEMP_KELVIN,
@@ -83,20 +79,20 @@ class TuyaLocalClimate(TuyaLocalEntity, ClimateEntity):
         self._support_flags = 0
 
         if self._aux_heat_dps:
-            self._support_flags |= SUPPORT_AUX_HEAT
+            self._support_flags |= ClimateEntityFeature.AUX_HEAT
         if self._fan_mode_dps:
-            self._support_flags |= SUPPORT_FAN_MODE
+            self._support_flags |= ClimateEntityFeature.FAN_MODE
         if self._humidity_dps:
-            self._support_flags |= SUPPORT_TARGET_HUMIDITY
+            self._support_flags |= ClimateEntityFeature.TARGET_HUMIDITY
         if self._preset_mode_dps:
-            self._support_flags |= SUPPORT_PRESET_MODE
+            self._support_flags |= ClimateEntityFeature.PRESET_MODE
         if self._swing_mode_dps:
-            self._support_flags |= SUPPORT_SWING_MODE
+            self._support_flags |= ClimateEntityFeature.SWING_MODE
 
         if self._temp_high_dps and self._temp_low_dps:
-            self._support_flags |= SUPPORT_TARGET_TEMPERATURE_RANGE
+            self._support_flags |= ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
         elif self._temperature_dps is not None:
-            self._support_flags |= SUPPORT_TARGET_TEMPERATURE
+            self._support_flags |= ClimateEntityFeature.TARGET_TEMPERATURE
 
     @property
     def supported_features(self):
@@ -258,15 +254,24 @@ class TuyaLocalClimate(TuyaLocalEntity, ClimateEntity):
         """Return the current HVAC action."""
         if self._hvac_action_dps is None:
             return None
-        return self._hvac_action_dps.get_value(self._device)
+        action = self._hvac_action_dps.get_value(self._device)
+        try:
+            return HVACAction(action)
+        except ValueError:
+            _LOGGER.warning(f"_Unrecognised HVAC Action {action} ignored")
+            return None
 
     @property
     def hvac_mode(self):
         """Return current HVAC mode."""
         if self._hvac_mode_dps is None:
-            return HVAC_MODE_AUTO
+            return HVACMode.AUTO
         hvac_mode = self._hvac_mode_dps.get_value(self._device)
-        return STATE_UNAVAILABLE if hvac_mode is None else hvac_mode
+        try:
+            return HVACMode(hvac_mode)
+        except ValueError:
+            _LOGGER.warning(f"Unrecognised HVAC Mode of {hvac_mode} ignored")
+            return None
 
     @property
     def hvac_modes(self):

custom_components/tuya_local/generic/lock.py

@@ -5,7 +5,6 @@ Initial implementation is based on the secondary child-lock feature of Goldair
 climate devices.
 """
 from homeassistant.components.lock import LockEntity, STATE_LOCKED, STATE_UNLOCKED
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..device import TuyaLocalDevice
 from ..helpers.device_config import TuyaEntityConfig
@@ -32,7 +31,7 @@ class TuyaLocalLock(TuyaLocalEntity, LockEntity):
         lock = self._lock_dps.get_value(self._device)
 
         if lock is None:
-            return STATE_UNAVAILABLE
+            return None
         else:
             return STATE_LOCKED if lock else STATE_UNLOCKED
 

custom_components/tuya_local/generic/switch.py

@@ -5,8 +5,6 @@ heater open window detector toggle.
 """
 from homeassistant.components.switch import SwitchEntity, SwitchDeviceClass
 
-from homeassistant.const import STATE_UNAVAILABLE
-
 from ..device import TuyaLocalDevice
 from ..helpers.device_config import TuyaEntityConfig
 from ..helpers.mixin import TuyaLocalEntity
@@ -50,9 +48,6 @@ class TuyaLocalSwitch(TuyaLocalEntity, SwitchEntity):
             return None
 
         pwr = self._power_dps.get_value(self._device)
-        if pwr is None:
-            return STATE_UNAVAILABLE
-
         return pwr
 
     async def async_turn_on(self, **kwargs):

hacs.json

@@ -1,5 +1,5 @@
 {
   "name": "Tuya Local",
   "render_readme": true,
-  "homeassistant": "2022.2.0"
+  "homeassistant": "2022.5.0"
 }

requirements-dev.txt

@@ -1,6 +1,6 @@
 black
 isort
-git+https://github.com/make-all/pytest-homeassistant-custom-component@master#egg=pytest-homeassistant-custom-component
+pytest-homeassistant-custom-component>=0.9.0
 pytest
 pytest-asyncio
 pytest-cov

tests/devices/test_andersson_gsh_heater.py

@@ -1,10 +1,7 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import GSH_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -34,7 +31,10 @@ class TestAnderssonGSHHeater(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -67,28 +67,25 @@ class TestAnderssonGSHHeater(TargetTemperatureTests, TuyaDeviceTestCase):
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "low"

tests/devices/test_aspen_adv200_fan.py

@@ -1,7 +1,6 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.fan import (
     DIRECTION_FORWARD,
@@ -64,7 +63,7 @@ class TestAspenASP200Fan(
         )
         self.assertEqual(
             self.climate.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_fan_direction(self):
@@ -151,14 +150,14 @@ class TestAspenASP200Fan(
 
     def test_climate_hvac_mode(self):
         self.dps[SWITCH_DPS] = False
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.OFF)
         self.dps[SWITCH_DPS] = True
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.FAN_ONLY)
 
     def test_climate_hvac_modes(self):
         self.assertCountEqual(
             self.climate.hvac_modes,
-            [HVAC_MODE_FAN_ONLY, HVAC_MODE_OFF],
+            [HVACMode.FAN_ONLY, HVACMode.OFF],
         )
 
     async def test_climate_turn_on(self):
@@ -166,14 +165,14 @@ class TestAspenASP200Fan(
             self.climate._device,
             {SWITCH_DPS: True},
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.climate.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_climate_turn_off(self):
         async with assert_device_properties_set(
             self.climate._device,
             {SWITCH_DPS: False},
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.climate.async_set_hvac_mode(HVACMode.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[UNKNOWN8_DPS] = 8

tests/devices/test_awow_th213_thermostat.py

@@ -1,18 +1,11 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-)
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import TH213_THERMOSTAT_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -105,7 +98,10 @@ class TestAwowTH213Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -148,28 +144,25 @@ class TestAwowTH213Thermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "1"
@@ -224,13 +217,13 @@ class TestAwowTH213Thermostat(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[HVACACTION_DPS] = True
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[ERROR_DPS] = 8

tests/devices/test_awow_th213v2_thermostat.py

@@ -1,18 +1,11 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-)
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import TH213V2_THERMOSTAT_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -112,7 +105,10 @@ class TestAwowTH213v2Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -155,28 +151,25 @@ class TestAwowTH213v2Thermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "1"
@@ -231,13 +224,13 @@ class TestAwowTH213v2Thermostat(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[HVACACTION_DPS] = True
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[ERROR_DPS] = 8

tests/devices/test_beca_bac002_thermostat.py

@@ -1,19 +1,14 @@
 from homeassistant.components.climate.const import (
+    ClimateEntityFeature,
     FAN_AUTO,
     FAN_HIGH,
     FAN_LOW,
     FAN_MEDIUM,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_OFF,
+    HVACMode,
     PRESET_COMFORT,
     PRESET_ECO,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import BECA_BAC002_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -64,7 +59,11 @@ class TestBecaBAC002Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_FAN_MODE | SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit_returns_configured_temperature_unit(self):
@@ -95,24 +94,22 @@ class TestBecaBAC002Thermostat(
     def test_hvac_mode(self):
         self.dps[SWITCH_DPS] = True
         self.dps[HVACMODE_DPS] = "0"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[HVACMODE_DPS] = "2"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
         self.dps[SWITCH_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_COOL,
-                HVAC_MODE_FAN_ONLY,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.COOL,
+                HVACMode.FAN_ONLY,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
@@ -121,27 +118,27 @@ class TestBecaBAC002Thermostat(
             self.subject._device,
             {SWITCH_DPS: True, HVACMODE_DPS: "0"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_to_heat(self):
         async with assert_device_properties_set(
             self.subject._device,
             {SWITCH_DPS: True, HVACMODE_DPS: "1"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_to_fan(self):
         async with assert_device_properties_set(
             self.subject._device,
             {SWITCH_DPS: True, HVACMODE_DPS: "2"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_set_hvac_mode_to_off(self):
         async with assert_device_properties_set(
             self.subject._device, {SWITCH_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(self.subject.preset_modes, [PRESET_COMFORT, PRESET_ECO])

tests/devices/test_beca_bhp6000_thermostat.py

@@ -1,14 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS, TEMP_FAHRENHEIT
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import BECA_BHP6000_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -50,7 +44,11 @@ class TestBecaBHP6000Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_FAN_MODE | SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit_returns_configured_temperature_unit(self):
@@ -78,32 +76,29 @@ class TestBecaBHP6000Thermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "2"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "3"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[HVACMODE_DPS] = "4"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
 
         self.dps[HVACMODE_DPS] = "5"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_HEAT_COOL,
-                HVAC_MODE_COOL,
-                HVAC_MODE_AUTO,
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.HEAT_COOL,
+                HVACMode.COOL,
+                HVACMode.AUTO,
             ],
         )
 

tests/devices/test_beca_bht002_thermostat.py

@@ -1,17 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_ECO,
     PRESET_COMFORT,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-)
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import BECA_BHT002_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -68,7 +62,10 @@ class TestBecaBHT002Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit(self):
@@ -102,24 +99,21 @@ class TestBecaBHT002Thermostat(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
         self.dps[HVACMODE_DPS] = "0"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[POWER_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_HEAT,
-                HVAC_MODE_AUTO,
-                HVAC_MODE_OFF,
+                HVACMode.HEAT,
+                HVACMode.AUTO,
+                HVACMode.OFF,
             ],
         )
 

tests/devices/test_beca_bht6000_thermostat.py

@@ -1,17 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_ECO,
     PRESET_COMFORT,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-)
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import BECA_BHT6000_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -65,7 +59,10 @@ class TestBecaBHT6000Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit(self):
@@ -99,23 +96,20 @@ class TestBecaBHT6000Thermostat(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
         self.dps[HVACMODE_DPS] = "0"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
         self.dps[POWER_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_HEAT,
-                HVAC_MODE_AUTO,
-                HVAC_MODE_OFF,
+                HVACMode.HEAT,
+                HVACMode.AUTO,
+                HVACMode.OFF,
             ],
         )
 

tests/devices/test_beok_tr9b_thermostat.py

@@ -1,14 +1,11 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS, TEMP_FAHRENHEIT
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import BEOK_TR9B_PAYLOAD
-from ..helpers import assert_device_properties_set
 from ..mixins.climate import TargetTemperatureTests
 from ..mixins.binary_sensor import MultiBinarySensorTests
 from ..mixins.lock import BasicLockTests
@@ -138,7 +135,7 @@ class TestBeokTR9BThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_temperature_unit(self):
@@ -163,24 +160,21 @@ class TestBeokTR9BThermostat(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[POWER_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = "manual"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_HEAT,
-                HVAC_MODE_AUTO,
-                HVAC_MODE_OFF,
+                HVACMode.HEAT,
+                HVACMode.AUTO,
+                HVACMode.OFF,
             ],
         )
 

tests/devices/test_betterlife_bl1500_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_MINUTES
+from homeassistant.const import TIME_MINUTES
 
 from ..const import BETTERLIFE_BL1500_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -73,7 +71,10 @@ class TestBetterlifeBL1500Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -104,28 +105,25 @@ class TestBetterlifeBL1500Heater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "0"

tests/devices/test_bwt_heatpump.py

@@ -1,11 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import BWT_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -47,7 +44,10 @@ class TestBWTHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -81,28 +81,25 @@ class TestBWTHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "heat"

tests/devices/test_carson_cb.py

@@ -1,14 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS, TEMP_FAHRENHEIT
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import CARSON_CB_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -45,7 +39,11 @@ class TestCarsonCBHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -74,33 +72,30 @@ class TestCarsonCBHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "HEAT"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "COOL"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "DRY"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "FAN"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "DRY"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
             ],
         )
 
@@ -108,13 +103,13 @@ class TestCarsonCBHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "HEAT"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = 1

tests/devices/test_devola_patio_heater.py

@@ -1,13 +1,10 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
-    STATE_UNAVAILABLE,
     TIME_MINUTES,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
@@ -89,7 +86,10 @@ class TestDevolaPatioHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -139,28 +139,25 @@ class TestDevolaPatioHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = False

tests/devices/test_eanons_humidifier.py

@@ -1,13 +1,10 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
+    ClimateEntityFeature,
     FAN_HIGH,
     FAN_MEDIUM,
     FAN_LOW,
-    HVAC_MODE_DRY,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_HUMIDITY,
+    HVACMode,
 )
 from homeassistant.components.fan import (
     SUPPORT_SET_SPEED,
@@ -18,7 +15,6 @@ from homeassistant.components.humidifier.const import (
     MODE_SLEEP,
     SUPPORT_MODES,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import EANONS_HUMIDIFIER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -91,7 +87,11 @@ class TestEanonsHumidifier(
     def test_supported_features(self):
         self.assertEqual(
             self.climate.supported_features,
-            SUPPORT_TARGET_HUMIDITY | SUPPORT_PRESET_MODE | SUPPORT_FAN_MODE,
+            (
+                ClimateEntityFeature.TARGET_HUMIDITY
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.FAN_MODE
+            ),
         )
         self.assertEqual(self.subject.supported_features, SUPPORT_MODES)
         self.assertEqual(self.fan.supported_features, SUPPORT_SET_SPEED)
@@ -131,28 +131,25 @@ class TestEanonsHumidifier(
 
     def test_climate_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.climate.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.OFF)
 
     def test_climate_hvac_modes(self):
-        self.assertCountEqual(self.climate.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_DRY])
+        self.assertCountEqual(self.climate.hvac_modes, [HVACMode.OFF, HVACMode.DRY])
 
     async def test_climate_turn_on(self):
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: True}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_DRY)
+            await self.climate.async_set_hvac_mode(HVACMode.DRY)
 
     async def test_climate_turn_off(self):
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: False}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.climate.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_fan_turn_on(self):
         async with assert_device_properties_set(

tests/devices/test_eberg_cooly_c35hd.py

@@ -1,20 +1,10 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
     SWING_OFF,
     SWING_VERTICAL,
 )
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-    TEMP_FAHRENHEIT,
-)
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import EBERG_COOLY_C35HD_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -67,7 +57,11 @@ class TestEbergCoolyC35HDHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            (SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_SWING_MODE),
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -114,30 +108,27 @@ class TestEbergCoolyC35HDHeatpump(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[HVACMODE_DPS] = "2"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
         self.dps[HVACMODE_DPS] = "3"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "4"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "3"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
-                HVAC_MODE_HEAT,
+                HVACMode.OFF,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
+                HVACMode.HEAT,
             ],
         )
 
@@ -145,31 +136,31 @@ class TestEbergCoolyC35HDHeatpump(
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "1"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_to_dry(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "2"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_DRY)
+            await self.subject.async_set_hvac_mode(HVACMode.DRY)
 
     async def test_set_hvac_mode_to_cool(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "3"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_to_fan(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "4"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = "1"

tests/devices/test_eberg_qubo_q40hd_heatpump.py

@@ -1,24 +1,13 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_DRY,
-    CURRENT_HVAC_FAN,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
     PRESET_SLEEP,
     PRESET_COMFORT,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
     SWING_OFF,
     SWING_VERTICAL,
 )
 from homeassistant.const import (
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
     TIME_HOURS,
@@ -71,10 +60,10 @@ class TestEbergQuboQ40HDHeatpump(
         self.assertEqual(
             self.subject.supported_features,
             (
-                SUPPORT_TARGET_TEMPERATURE
-                | SUPPORT_FAN_MODE
-                | SUPPORT_PRESET_MODE
-                | SUPPORT_SWING_MODE
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.SWING_MODE
             ),
         )
 
@@ -108,25 +97,22 @@ class TestEbergQuboQ40HDHeatpump(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "cold"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_COOL,
-                HVAC_MODE_HEAT,
+                HVACMode.OFF,
+                HVACMode.COOL,
+                HVACMode.HEAT,
             ],
         )
 
@@ -134,13 +120,13 @@ class TestEbergQuboQ40HDHeatpump(
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "cold"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = "low"
@@ -252,49 +238,49 @@ class TestEbergQuboQ40HDHeatpump(
     def test_hvac_action(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACACTION_DPS] = "heat_s"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = "cool_s"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
 
         self.dps[HVACACTION_DPS] = "cooling"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
 
         self.dps[HVACACTION_DPS] = "anti-clockwise"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_FAN)
+        self.assertEqual(self.subject.hvac_action, HVACAction.FAN)
 
         self.dps[HVACACTION_DPS] = "ventilation"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_FAN)
+        self.assertEqual(self.subject.hvac_action, HVACAction.FAN)
 
         self.dps[HVACACTION_DPS] = "wind"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_FAN)
+        self.assertEqual(self.subject.hvac_action, HVACAction.FAN)
 
         self.dps[HVACACTION_DPS] = "appointment"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACACTION_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACACTION_DPS] = "auto_clean"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACACTION_DPS] = "eco"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACACTION_DPS] = "wet"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_DRY)
+        self.assertEqual(self.subject.hvac_action, HVACAction.DRYING)
 
         self.dps[HVACACTION_DPS] = "off"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[TIMER_DPS] = 22

tests/devices/test_ecostrad_accentiq_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.const import (
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
     TIME_HOURS,
@@ -48,7 +46,7 @@ class TestEcostradAccentIqHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_temperature_unit(self):
@@ -63,28 +61,25 @@ class TestEcostradAccentIqHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_extra_state_attributes(self):
         self.assertEqual(self.subject.extra_state_attributes, {})

tests/devices/test_ecostrad_iqceramic_radiator.py

@@ -1,13 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
-)
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
+    ClimateEntityFeature,
+    HVACMode,
 )
+from homeassistant.const import TEMP_CELSIUS
 
 from ..const import ECOSTRAD_IQCERAMIC_RADIATOR_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -99,7 +94,10 @@ class TestEcostradAccentIqHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit(self):
@@ -114,31 +112,28 @@ class TestEcostradAccentIqHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_HEAT],
+            [HVACMode.OFF, HVACMode.HEAT],
         )
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_electriq_12wminv_heatpump.py

@@ -1,15 +1,7 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import ELECTRIQ_12WMINV_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -62,7 +54,11 @@ class TestElectriq12WMINVHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -92,37 +88,34 @@ class TestElectriq12WMINVHeatpump(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "wet"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "wind"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
 
         self.dps[HVACMODE_DPS] = "auto"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_HEAT_COOL,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.HEAT_COOL,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
             ],
         )
 
@@ -130,13 +123,13 @@ class TestElectriq12WMINVHeatpump(
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "hot"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = 1

tests/devices/test_electriq_desd9lw_dehumidifier.py

@@ -1,19 +1,9 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_HUMIDITY,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    PERCENTAGE,
-    STATE_UNAVAILABLE,
-)
+from homeassistant.const import PERCENTAGE
 
 from ..const import ELECTRIQ_DESD9LW_DEHUMIDIFIER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -69,10 +59,12 @@ class TestElectriqDESD9LWDehumidifier(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_FAN_MODE
-            | SUPPORT_SWING_MODE
-            | SUPPORT_TARGET_HUMIDITY
-            | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.SWING_MODE
+                | ClimateEntityFeature.TARGET_HUMIDITY
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_icon(self):
@@ -127,33 +119,29 @@ class TestElectriqDESD9LWDehumidifier(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "Heater"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "Dehumidity"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "Fan"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "Auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
-        self.dps[HVACMODE_DPS] = "Auto"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_AUTO,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.AUTO,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
@@ -164,7 +152,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "Heater"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         self.dps[HVACMODE_DPS] = "Auto"
@@ -173,7 +161,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_set_mode_to_heater(self):
         self.dps[HVACMODE_DPS] = "Auto"
@@ -182,7 +170,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "Heater", POWER_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_mode_to_dehumidity(self):
         self.dps[HVACMODE_DPS] = "Auto"
@@ -191,7 +179,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "Dehumidity", POWER_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_DRY)
+            await self.subject.async_set_hvac_mode(HVACMode.DRY)
 
     async def test_set_mode_to_fan(self):
         self.dps[HVACMODE_DPS] = "Auto"
@@ -200,7 +188,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "Fan", POWER_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_set_mode_to_auto(self):
         self.dps[HVACMODE_DPS] = "Fan"
@@ -209,7 +197,7 @@ class TestElectriqDESD9LWDehumidifier(
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "Auto", POWER_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_AUTO)
+            await self.subject.async_set_hvac_mode(HVACMode.AUTO)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = "Low"

tests/devices/test_eurom_600_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import EUROM_600_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -43,7 +41,7 @@ class TestEurom600Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_icon(self):
@@ -64,28 +62,25 @@ class TestEurom600Heater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_error_state(self):
         # There are currently no known error states; update this as

tests/devices/test_eurom_600v2_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import EUROM_600v2_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -43,7 +41,7 @@ class TestEurom600Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_icon(self):
@@ -64,28 +62,25 @@ class TestEurom600Heater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_error_state(self):
         # There are currently no known error states; update this as

tests/devices/test_eurom_601_heater.py

@@ -1,13 +1,10 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_COMFORT,
     PRESET_ECO,
-    SUPPORT_TARGET_TEMPERATURE,
-    SUPPORT_PRESET_MODE,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import EUROM_601_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -47,7 +44,10 @@ class TestEurom601Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -68,28 +68,25 @@ class TestEurom601Heater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_eurom_walldesignheat2000_heater.py

@@ -1,17 +1,12 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_BOOST,
     PRESET_COMFORT,
     PRESET_ECO,
-    SUPPORT_TARGET_TEMPERATURE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_SWING_MODE,
     SWING_OFF,
     SWING_VERTICAL,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import EUROM_WALLDESIGNHEAT2000_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -47,7 +42,11 @@ class TestEuromWallDesignheat2000Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -71,40 +70,37 @@ class TestEuromWallDesignheat2000Heater(
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[PRESET_DPS] = "100_perc"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[PRESET_DPS] = "off"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_HEAT, HVAC_MODE_FAN_ONLY],
+            [HVACMode.OFF, HVACMode.HEAT, HVACMode.FAN_ONLY],
         )
 
     async def test_set_hvac_mode_to_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, PRESET_DPS: "auto"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_to_fan(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, PRESET_DPS: "off"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_fersk_vind_2_climate.py

@@ -1,16 +1,10 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
     SWING_OFF,
     SWING_VERTICAL,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS, TEMP_FAHRENHEIT
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import FERSK_VIND2_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -49,7 +43,11 @@ class TestFerskVind2Climate(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -86,25 +84,25 @@ class TestFerskVind2Climate(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "COOL"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "FAN"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
         self.dps[HVACMODE_DPS] = "DRY"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
         self.dps[HVACMODE_DPS] = "HEAT"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
@@ -112,31 +110,31 @@ class TestFerskVind2Climate(TargetTemperatureTests, TuyaDeviceTestCase):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_set_hvac_mode_cool(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "COOL"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_dry(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "DRY"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_DRY)
+            await self.subject.async_set_hvac_mode(HVACMode.DRY)
 
     async def test_set_hvac_mode_fan(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "FAN"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_set_hvac_mode_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "HEAT"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = 1

tests/devices/test_gardenpac_heatpump.py

@@ -1,16 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -62,7 +57,10 @@ class TestGardenPACPoolHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -94,28 +92,25 @@ class TestGardenPACPoolHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = False
@@ -147,11 +142,11 @@ class TestGardenPACPoolHeatpump(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[OPMODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
         self.dps[OPMODE_DPS] = "warm"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[POWERLEVEL_DPS] = 50

tests/devices/test_goldair_dehumidifier.py

@@ -2,21 +2,14 @@ from unittest.mock import ANY
 
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
+    ClimateEntityFeature,
     FAN_HIGH,
     FAN_LOW,
-    HVAC_MODE_DRY,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_HUMIDITY,
+    HVACMode,
 )
 from homeassistant.components.light import COLOR_MODE_ONOFF
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-    TIME_HOURS,
-)
+from homeassistant.const import TEMP_CELSIUS, TIME_HOURS
 
 from ..const import DEHUMIDIFIER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -123,7 +116,11 @@ class TestGoldairDehumidifier(
     def test_supported_features(self):
         self.assertEqual(
             self.climate.supported_features,
-            SUPPORT_TARGET_HUMIDITY | SUPPORT_PRESET_MODE | SUPPORT_FAN_MODE,
+            (
+                ClimateEntityFeature.TARGET_HUMIDITY
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.FAN_MODE
+            ),
         )
 
     def test_icon_is_always_standard_when_off_without_error(self):
@@ -297,29 +294,26 @@ class TestGoldairDehumidifier(
 
     def test_climate_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.climate.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.OFF)
 
     def test_climate_hvac_modes(self):
-        self.assertCountEqual(self.climate.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_DRY])
+        self.assertCountEqual(self.climate.hvac_modes, [HVACMode.OFF, HVACMode.DRY])
 
     async def test_climate_set_hvac_mode_to_dry(self):
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: True}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_DRY)
+            await self.climate.async_set_hvac_mode(HVACMode.DRY)
 
     async def test_climate_set_hvac_mode_to_off(self):
 
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: False}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.climate.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = PRESET_NORMAL

tests/devices/test_goldair_fan.py

@@ -1,11 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_ECO,
     PRESET_SLEEP,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE as SUPPORT_CLIMATE_PRESET,
-    SUPPORT_SWING_MODE,
     SWING_HORIZONTAL,
     SWING_OFF,
 )
@@ -15,8 +12,6 @@ from homeassistant.components.fan import (
     SUPPORT_SET_SPEED,
 )
 
-from homeassistant.const import STATE_UNAVAILABLE
-
 from ..const import FAN_PAYLOAD
 from ..helpers import assert_device_properties_set
 from ..mixins.light import BasicLightTests
@@ -49,7 +44,11 @@ class TestGoldairFan(BasicLightTests, SwitchableTests, TuyaDeviceTestCase):
         )
         self.assertEqual(
             self.climate.supported_features,
-            SUPPORT_FAN_MODE | SUPPORT_CLIMATE_PRESET | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_climate_icon_is_fan(self):
@@ -65,33 +64,29 @@ class TestGoldairFan(BasicLightTests, SwitchableTests, TuyaDeviceTestCase):
 
     def test_is_on(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.FAN_ONLY)
         self.assertTrue(self.subject.is_on)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.climate.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.climate.hvac_mode, HVACMode.OFF)
         self.assertFalse(self.subject.is_on)
 
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.climate.hvac_mode, STATE_UNAVAILABLE)
-        self.assertIsNone(self.subject.is_on)
-
     def test_climate_hvac_modes(self):
         self.assertCountEqual(
-            self.climate.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_FAN_ONLY]
+            self.climate.hvac_modes, [HVACMode.OFF, HVACMode.FAN_ONLY]
         )
 
     async def test_climate_turn_on(self):
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: True}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.climate.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     async def test_climate_turn_off(self):
         async with assert_device_properties_set(
             self.climate._device, {HVACMODE_DPS: False}
         ):
-            await self.climate.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.climate.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_turn_on(self):
         async with assert_device_properties_set(

tests/devices/test_goldair_geco_heater.py

@@ -1,10 +1,9 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_HOURS
+from homeassistant.const import TIME_HOURS
 
 from ..const import GECO_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -64,7 +63,7 @@ class TestGoldairGECOHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_icon(self):
@@ -85,28 +84,25 @@ class TestGoldairGECOHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_extra_state_attributes(self):
         # There are currently no known error states; update this as

tests/devices/test_goldair_gpcv_heater.py

@@ -1,11 +1,9 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_HOURS
+from homeassistant.const import TIME_HOURS
 
 from ..const import GPCV_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -62,7 +60,10 @@ class TestGoldairGPCVHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -95,28 +96,25 @@ class TestGoldairGPCVHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "Low"

tests/devices/test_goldair_gpph_heater.py

@@ -1,17 +1,10 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    PERCENTAGE,
-    STATE_UNAVAILABLE,
-    TIME_MINUTES,
-)
+from homeassistant.const import PERCENTAGE, TIME_MINUTES
 
 from ..const import GPPH_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -92,7 +85,11 @@ class TestGoldairHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -205,28 +202,25 @@ class TestGoldairHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "C"

tests/devices/test_hellnar_heatpump.py

@@ -1,14 +1,7 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import HELLNAR_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -38,7 +31,7 @@ class TestHellnarHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_SWING_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (ClimateEntityFeature.SWING_MODE | ClimateEntityFeature.TARGET_TEMPERATURE),
         )
 
     def test_icon(self):
@@ -83,37 +76,34 @@ class TestHellnarHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "wet"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "wind"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
 
         self.dps[HVACMODE_DPS] = "auto"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_HEAT_COOL,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.HEAT_COOL,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
             ],
         )
 
@@ -121,13 +111,13 @@ class TestHellnarHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "hot"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_extra_state_attributes(self):
         self.dps["5"] = "fan?"

tests/devices/test_hysen_hy08we2_thermostat.py

@@ -1,18 +1,10 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import (
-    STATE_UNAVAILABLE,
-    TEMP_CELSIUS,
-    TIME_DAYS,
-)
+from homeassistant.const import TEMP_CELSIUS, TIME_DAYS
 
 from ..const import HYSEN_HY08WE2_THERMOSTAT_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -205,7 +197,10 @@ class TestHysenHY08WE2Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_current_temperature(self):
@@ -214,20 +209,17 @@ class TestHysenHY08WE2Thermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
@@ -236,23 +228,23 @@ class TestHysenHY08WE2Thermostat(
             self.subject._device,
             {HVACMODE_DPS: True},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[HVACACTION_DPS] = True
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
         self.dps[HVACACTION_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_inkbird_itc306a_thermostat.py

@@ -1,9 +1,7 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE_RANGE,
+    ClimateEntityFeature,
+    HVACAction,
 )
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, TIME_HOURS
 
@@ -141,7 +139,10 @@ class TestInkbirdThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE_RANGE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -289,9 +290,9 @@ class TestInkbirdThermostat(
 
     def test_hvac_action(self):
         self.dps[SWITCH_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[SWITCH_DPS] = True
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
     def test_extra_state_attributes(self):
         self.dps[ERROR_DPS] = 1

tests/devices/test_inkbird_itc308_thermostat.py

@@ -1,9 +1,7 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
 )
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, TIME_MINUTES
 
@@ -160,7 +158,7 @@ class TestInkbirdITC308Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_icon(self):
@@ -210,11 +208,11 @@ class TestInkbirdITC308Thermostat(
 
     def test_hvac_action(self):
         self.dps[STATUS_DPS] = "1"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
         self.dps[STATUS_DPS] = "2"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[STATUS_DPS] = "3"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
     def test_extra_state_attributes(self):
         self.dps[ERROR_DPS] = 12

tests/devices/test_ips_pro_heatpump.py

@@ -1,16 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -62,7 +57,10 @@ class TestIpsProHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -94,28 +92,25 @@ class TestIpsProHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "silence"
@@ -154,11 +149,11 @@ class TestIpsProHeatpump(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[OPMODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
         self.dps[OPMODE_DPS] = "warm"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[UNKNOWN115_DPS] = 3

tests/devices/test_jiahong_et72w_thermostat.py

@@ -1,9 +1,6 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.sensor import (
     STATE_CLASS_MEASUREMENT,
@@ -13,7 +10,6 @@ from homeassistant.const import (
     DEVICE_CLASS_ENERGY,
     DEVICE_CLASS_TEMPERATURE,
     ENERGY_KILO_WATT_HOUR,
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -151,7 +147,7 @@ class TestJiahongEt72wThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_temperature_unit(self):
@@ -190,35 +186,28 @@ class TestJiahongEt72wThermostat(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
         self.dps[HVACMODE_DPS] = "Smart"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[POWER_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = "Manual"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "Anti_frozen"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_AUTO,
-                HVAC_MODE_COOL,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.AUTO,
+                HVACMode.COOL,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
-    # Override - since min and max are set by attributes, the range
-    # allowed when setting is wider than normal.  The thermostat seems
-    # to be configurable as at least a water heater (to 212F), as tuya
-    # doc says max 1000.0 (after scaling)
     async def test_set_target_temperature_fails_outside_valid_range(self):
         with self.assertRaisesRegex(
             ValueError,

tests/devices/test_kogan_glass_1_7l_kettle.py

@@ -1,9 +1,6 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import KOGAN_GLASS_1_7L_KETTLE_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -25,7 +22,7 @@ class TestKoganGlass1_7LKettle(TuyaDeviceTestCase):
         self.subject = self.entities.get("climate")
 
     def test_supported_features(self):
-        self.assertEqual(self.subject.supported_features, 0)  # SUPPORT_PRESET_MODE,
+        self.assertEqual(self.subject.supported_features, 0)
 
     def test_icon(self):
         self.dps[HVACMODE_DPS] = True
@@ -40,28 +37,28 @@ class TestKoganGlass1_7LKettle(TuyaDeviceTestCase):
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_HEAT, HVAC_MODE_OFF],
+            [HVACMode.HEAT, HVACMode.OFF],
         )
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: True},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     # def test_preset_modes(self):
     #     self.assertCountEqual(

tests/devices/test_kogan_kahtp_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_MINUTES
+from homeassistant.const import TIME_MINUTES
 
 from ..const import KOGAN_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -47,7 +45,10 @@ class TestGoldairKoganKAHTPHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -80,28 +81,25 @@ class TestGoldairKoganKAHTPHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "Low"

tests/devices/test_kogan_kashmfp20ba_heater.py

@@ -1,14 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.light import (
     COLOR_MODE_UNKNOWN,
     SUPPORT_EFFECT,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import KOGAN_KASHMFP20BA_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -43,7 +40,7 @@ class TestKoganKASHMF20BAHeater(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE,
         )
 
     def test_icon(self):
@@ -76,28 +73,25 @@ class TestKoganKASHMF20BAHeater(TargetTemperatureTests, TuyaDeviceTestCase):
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "low"

tests/devices/test_kogan_kawfhtp_heater.py

@@ -1,10 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_MINUTES
+from homeassistant.const import TIME_MINUTES
 
 from ..const import KOGAN_KAWFHTP_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -50,7 +48,10 @@ class TestGoldairKoganKAHTPHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -83,28 +84,25 @@ class TestGoldairKoganKAHTPHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "Low"

tests/devices/test_kogan_kawfpac09ya_airconditioner.py

@@ -1,12 +1,8 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TEMP_CELSIUS, TEMP_FAHRENHEIT
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 from ..const import KOGAN_KAWFPAC09YA_AIRCON_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -43,7 +39,7 @@ class TestKoganKAWFPAC09YA(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE,
+            (ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE),
         )
 
     def test_icon(self):
@@ -78,29 +74,26 @@ class TestKoganKAWFPAC09YA(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "COOL"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "DRY"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "FAN"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "FAN"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
+                HVACMode.OFF,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
             ],
         )
 
@@ -108,13 +101,13 @@ class TestKoganKAWFPAC09YA(TargetTemperatureTests, TuyaDeviceTestCase):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "COOL"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = "1"

tests/devices/test_madimack_elitev3_heatpump.py

@@ -1,10 +1,6 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
@@ -133,7 +129,10 @@ class TestMadimackEliteV3Heatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_icon(self):
@@ -168,18 +167,18 @@ class TestMadimackEliteV3Heatpump(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_COOL, HVAC_MODE_HEAT, HVAC_MODE_HEAT_COOL],
+            [HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT, HVACMode.HEAT_COOL],
         )
 
     async def test_set_hvac_mode_to_cool(self):
@@ -187,28 +186,28 @@ class TestMadimackEliteV3Heatpump(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "cold"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_to_heat(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "heating"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_to_auto(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "auto"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT_COOL)
 
     async def test_set_hvac_mode_to_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "silence"

tests/devices/test_madimack_heatpump.py

@@ -1,17 +1,12 @@
 from homeassistant.components.binary_sensor import DEVICE_CLASS_PROBLEM
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -139,7 +134,10 @@ class TestMadimackPoolHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -171,28 +169,25 @@ class TestMadimackPoolHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = False
@@ -224,11 +219,11 @@ class TestMadimackPoolHeatpump(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[OPMODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
         self.dps[OPMODE_DPS] = "warm"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[ERROR_DPS] = 4

tests/devices/test_minco_mh1823d_thermostat.py

@@ -1,16 +1,10 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    CURRENT_HVAC_OFF,
-    HVAC_MODE_AUTO,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -161,7 +155,10 @@ class TestMincoMH1823DThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -235,40 +232,37 @@ class TestMincoMH1823DThermostat(
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[PRESET_DPS] = "manual"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[PRESET_DPS] = "program"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
         self.dps[PRESET_DPS] = "holiday"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
-            self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT, HVAC_MODE_AUTO]
+            self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT, HVACMode.AUTO]
         )
 
     async def test_set_hvac_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, PRESET_DPS: "manual"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_auto(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, PRESET_DPS: "program"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_AUTO)
+            await self.subject.async_set_hvac_mode(HVACMode.AUTO)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "manual"
@@ -313,13 +307,13 @@ class TestMincoMH1823DThermostat(
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[HVACACTION_DPS] = "start"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = "stop"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_extra_state_attributes(self):
         self.dps[UNKNOWN12_DPS] = False

tests/devices/test_moes_bht002_thermostat.py

@@ -1,13 +1,9 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_AUTO,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_ECO,
     PRESET_COMFORT,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import MOES_BHT002_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -48,7 +44,10 @@ class TestMoesBHT002Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit(self):
@@ -82,24 +81,21 @@ class TestMoesBHT002Thermostat(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
         self.dps[HVACMODE_DPS] = "0"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[POWER_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_AUTO)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.AUTO)
 
         self.dps[HVACMODE_DPS] = "1"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_HEAT,
-                HVAC_MODE_AUTO,
-                HVAC_MODE_OFF,
+                HVACMode.HEAT,
+                HVACMode.AUTO,
+                HVACMode.OFF,
             ],
         )
 

tests/devices/test_nashone_mts700wb_thermostat.py

@@ -1,13 +1,9 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_HEAT,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 from homeassistant.const import (
-    STATE_UNAVAILABLE,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
     TIME_MINUTES,
@@ -94,7 +90,7 @@ class TestNashoneMTS700WBThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_current_temperature(self):
@@ -103,25 +99,22 @@ class TestNashoneMTS700WBThermostat(
 
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_COOL,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_OFF,
+                HVACMode.COOL,
+                HVACMode.HEAT,
+                HVACMode.OFF,
             ],
         )
 
@@ -130,28 +123,28 @@ class TestNashoneMTS700WBThermostat(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "cold"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_heat(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "hot"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_hvac_action(self):
         self.dps[HVACMODE_DPS] = "hot"
         self.dps[HVACACTION_DPS] = "manual"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
 
     def test_extra_state_attributes(self):
         self.assertEqual(self.subject.extra_state_attributes, {})

tests/devices/test_nedis_htpl20f_heater.py

@@ -1,13 +1,11 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_AWAY,
     PRESET_COMFORT,
     PRESET_ECO,
-    SUPPORT_TARGET_TEMPERATURE,
-    SUPPORT_PRESET_MODE,
 )
-from homeassistant.const import STATE_UNAVAILABLE, TIME_MINUTES
+from homeassistant.const import TIME_MINUTES
 
 from ..const import NEDIS_HTPL20F_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -55,7 +53,10 @@ class TestNedisHtpl20fHeater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -76,28 +77,25 @@ class TestNedisHtpl20fHeater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_owon_pct513_thermostat.py

@@ -1,15 +1,7 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_FAN,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
 )
 
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
@@ -74,7 +66,11 @@ class TestOwonPCT513Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_FAN_MODE | SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (
+                ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.TARGET_TEMPERATURE
+            ),
         )
 
     def test_temperature_unit(self):
@@ -99,58 +95,58 @@ class TestOwonPCT513Thermostat(
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_COOL,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_HEAT_COOL,
-                HVAC_MODE_OFF,
+                HVACMode.COOL,
+                HVACMode.HEAT,
+                HVACMode.HEAT_COOL,
+                HVACMode.OFF,
             ],
         )
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = "off"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
         self.dps[HVACMODE_DPS] = "cool"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "heat"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
         self.dps[HVACMODE_DPS] = "emergencyheat"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     async def test_set_hvac_mode_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "off"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_set_hvac_mode_cool(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "cool"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "heat"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_heatcool(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "auto"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT_COOL)
 
     def test_hvac_action(self):
         self.dps[HVACACTION_DPS] = "coolfanon"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
         self.dps[HVACACTION_DPS] = "alloff"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
         self.dps[HVACACTION_DPS] = "fanon"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_FAN)
+        self.assertEqual(self.subject.hvac_action, HVACAction.FAN)
         self.dps[HVACACTION_DPS] = "heatfanon"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
     def test_preset_modes(self):
         self.assertCountEqual(

tests/devices/test_poolex_qline_heatpump.py

@@ -1,11 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import POOLEX_QLINE_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -47,7 +44,7 @@ class TestPoolexSilverlineHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_icon(self):
@@ -73,40 +70,37 @@ class TestPoolexSilverlineHeatpump(
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[MODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[MODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_COOL, HVAC_MODE_HEAT],
+            [HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT],
         )
 
     async def test_hvac_mode_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, MODE_DPS: "heating"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_hvac_mode_cool(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True, MODE_DPS: "cold"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_error_state(self):
         self.dps[ERROR_DPS] = 0

tests/devices/test_poolex_silverline_heatpump.py

@@ -1,11 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import POOLEX_SILVERLINE_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -49,7 +46,7 @@ class TestPoolexSilverlineHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE,
         )
 
     def test_icon(self):
@@ -81,28 +78,25 @@ class TestPoolexSilverlineHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "Heat"

tests/devices/test_poolex_vertigo_heatpump.py

@@ -1,11 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import POOLEX_VERTIGO_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -49,7 +46,10 @@ class TestPoolexVertigoHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -81,28 +81,25 @@ class TestPoolexVertigoHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "heat"

tests/devices/test_purline_m100_heater.py

@@ -1,15 +1,10 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_SWING_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
     SWING_OFF,
     SWING_VERTICAL,
 )
 from homeassistant.components.light import COLOR_MODE_ONOFF
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import PURLINE_M100_HEATER_PAYLOAD
 from ..helpers import (
@@ -57,7 +52,11 @@ class TestPulineM100Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE | SUPPORT_SWING_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+                | ClimateEntityFeature.SWING_MODE
+            ),
         )
 
     def test_icon(self):
@@ -84,21 +83,18 @@ class TestPulineM100Heater(
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
         self.dps[PRESET_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[PRESET_DPS] = "off"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_HEAT, HVAC_MODE_FAN_ONLY],
+            [HVACMode.OFF, HVACMode.HEAT, HVACMode.FAN_ONLY],
         )
 
     async def test_turn_on(self):
@@ -107,14 +103,14 @@ class TestPulineM100Heater(
             {HVACMODE_DPS: True},
             {PRESET_DPS: "auto"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_turn_on_fan(self):
         async with assert_device_properties_set_optional(
@@ -122,7 +118,7 @@ class TestPulineM100Heater(
             {HVACMODE_DPS: True},
             {PRESET_DPS: "off"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_FAN_ONLY)
+            await self.subject.async_set_hvac_mode(HVACMode.FAN_ONLY)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "auto"

tests/devices/test_remora_heatpump.py

@@ -1,11 +1,8 @@
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import REMORA_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -45,7 +42,10 @@ class TestRemoraHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -79,28 +79,25 @@ class TestRemoraHeatpump(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: True}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "heat"

tests/devices/test_saswell_c16_thermostat.py

@@ -1,13 +1,9 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_IDLE,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
     PRESET_AWAY,
     PRESET_HOME,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import POWER_WATT, TEMP_CELSIUS
@@ -131,7 +127,10 @@ class TestSaswellC16Thermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -158,34 +157,34 @@ class TestSaswellC16Thermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_COOL, HVAC_MODE_HEAT],
+            [HVACMode.COOL, HVACMode.HEAT],
         )
 
     async def test_set_hvac_mode_cool(self):
         with self.assertRaises(TypeError):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_heat(self):
         with self.assertRaises(TypeError):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     def test_hvac_action(self):
         self.dps[HVACACTION_DPS] = "Cooling"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
 
         self.dps[HVACACTION_DPS] = "Heating"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[HVACACTION_DPS] = "Standby"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_IDLE)
+        self.assertEqual(self.subject.hvac_action, HVACAction.IDLE)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "Smart"

tests/devices/test_saswell_t29utk_thermostat.py

@@ -1,17 +1,11 @@
 from homeassistant.components.climate.const import (
-    CURRENT_HVAC_COOL,
-    CURRENT_HVAC_HEAT,
-    CURRENT_HVAC_OFF,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
     FAN_AUTO,
     FAN_ON,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
     PRESET_AWAY,
     PRESET_HOME,
-    SUPPORT_FAN_MODE,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
 
@@ -83,7 +77,11 @@ class TestSaswellT29UTKThermostat(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.FAN_MODE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -129,62 +127,62 @@ class TestSaswellT29UTKThermostat(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = "off"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_COOL, HVAC_MODE_HEAT, HVAC_MODE_OFF],
+            [HVACMode.COOL, HVACMode.HEAT, HVACMode.OFF],
         )
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "off"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_set_hvac_mode_cool(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "cold"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_hvac_mode_heat(self):
         async with assert_device_properties_set(
             self.subject._device, {HVACMODE_DPS: "hot"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_heat_fails_in_cooling_config(self):
         self.dps[CONFIG_DPS] = "1"
         with self.assertRaisesRegex(
             AttributeError, "hvac_mode cannot be set at this time"
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_hvac_mode_cool_fails_in_heating_config(self):
         self.dps[CONFIG_DPS] = "2"
         with self.assertRaisesRegex(
             AttributeError, "hvac_mode cannot be set at this time"
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     def test_hvac_action(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACACTION_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_COOL)
+        self.assertEqual(self.subject.hvac_action, HVACAction.COOLING)
 
         self.dps[HVACACTION_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_HEAT)
+        self.assertEqual(self.subject.hvac_action, HVACAction.HEATING)
 
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_action, CURRENT_HVAC_OFF)
+        self.assertEqual(self.subject.hvac_action, HVACAction.OFF)
 
     def test_fan_mode(self):
         self.dps[FAN_DPS] = "auto"

tests/devices/test_tadiran_wind_heatpump.py

@@ -1,14 +1,7 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT_COOL,
-    HVAC_MODE_COOL,
-    HVAC_MODE_DRY,
-    HVAC_MODE_FAN_ONLY,
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    SUPPORT_FAN_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..const import TADIRAN_HEATPUMP_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -38,7 +31,7 @@ class TestTadiranWindHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_FAN_MODE | SUPPORT_TARGET_TEMPERATURE,
+            (ClimateEntityFeature.FAN_MODE | ClimateEntityFeature.TARGET_TEMPERATURE),
         )
 
     def test_icon(self):
@@ -68,37 +61,33 @@ class TestTadiranWindHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "heating"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = "cooling"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
 
         self.dps[HVACMODE_DPS] = "dehum"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_DRY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.DRY)
 
         self.dps[HVACMODE_DPS] = "fan"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_FAN_ONLY)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.FAN_ONLY)
 
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
 
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
-
-        self.dps[HVACMODE_DPS] = "auto"
         self.dps[POWER_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
             [
-                HVAC_MODE_OFF,
-                HVAC_MODE_HEAT,
-                HVAC_MODE_HEAT_COOL,
-                HVAC_MODE_COOL,
-                HVAC_MODE_DRY,
-                HVAC_MODE_FAN_ONLY,
+                HVACMode.OFF,
+                HVACMode.HEAT,
+                HVACMode.HEAT_COOL,
+                HVACMode.COOL,
+                HVACMode.DRY,
+                HVACMode.FAN_ONLY,
             ],
         )
 
@@ -106,13 +95,13 @@ class TestTadiranWindHeatpump(TargetTemperatureTests, TuyaDeviceTestCase):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: True, HVACMODE_DPS: "heating"}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device, {POWER_DPS: False}
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_fan_modes(self):
         self.assertCountEqual(

tests/devices/test_weau_pool_heatpump.py

@@ -1,9 +1,6 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
-    HVAC_MODE_COOL,
-    HVAC_MODE_HEAT_COOL,
-    SUPPORT_TARGET_TEMPERATURE,
+    ClimateEntityFeature,
+    HVACMode,
 )
 from homeassistant.const import TEMP_CELSIUS
 
@@ -38,7 +35,7 @@ class TestWeauPoolHeatpump(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE,
+            ClimateEntityFeature.TARGET_TEMPERATURE,
         )
 
     def test_current_temperature(self):
@@ -48,16 +45,16 @@ class TestWeauPoolHeatpump(
     def test_hvac_mode(self):
         self.dps[POWER_DPS] = True
         self.dps[HVACMODE_DPS] = "hot"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
         self.dps[HVACMODE_DPS] = "cold"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.COOL)
         self.dps[HVACMODE_DPS] = "auto"
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT_COOL)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT_COOL)
 
     def test_hvac_modes(self):
         self.assertCountEqual(
             self.subject.hvac_modes,
-            [HVAC_MODE_OFF, HVAC_MODE_COOL, HVAC_MODE_HEAT, HVAC_MODE_HEAT_COOL],
+            [HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT, HVACMode.HEAT_COOL],
         )
 
     async def test_turn_off(self):
@@ -65,28 +62,28 @@ class TestWeauPoolHeatpump(
             self.subject._device,
             {POWER_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     async def test_set_cool(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "cold"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.COOL)
 
     async def test_set_heat(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "hot"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_set_auto(self):
         async with assert_device_properties_set(
             self.subject._device,
             {POWER_DPS: True, HVACMODE_DPS: "auto"},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT_COOL)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT_COOL)
 
     def test_extra_state_attributes(self):
         self.dps[UNKNOWN6_DPS] = 6

tests/devices/test_wetair_wawh1210lw_humidifier.py

@@ -8,7 +8,6 @@ from homeassistant.components.humidifier.const import (
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
-    STATE_UNAVAILABLE,
 )
 
 from ..const import WETAIR_WAWH1210_HUMIDIFIER_PAYLOAD

tests/devices/test_wetair_wch750_heater.py

@@ -1,14 +1,12 @@
 from homeassistant.components.climate.const import (
-    HVAC_MODE_HEAT,
-    HVAC_MODE_OFF,
+    ClimateEntityFeature,
+    HVACMode,
     PRESET_AWAY,
     PRESET_COMFORT,
     PRESET_BOOST,
-    SUPPORT_PRESET_MODE,
-    SUPPORT_TARGET_TEMPERATURE,
 )
 from homeassistant.components.light import COLOR_MODE_BRIGHTNESS
-from homeassistant.const import STATE_UNAVAILABLE, TIME_MINUTES
+from homeassistant.const import TIME_MINUTES
 
 from ..const import WETAIR_WCH750_HEATER_PAYLOAD
 from ..helpers import assert_device_properties_set
@@ -101,7 +99,10 @@ class TestWetairWCH750Heater(
     def test_supported_features(self):
         self.assertEqual(
             self.subject.supported_features,
-            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE,
+            (
+                ClimateEntityFeature.TARGET_TEMPERATURE
+                | ClimateEntityFeature.PRESET_MODE
+            ),
         )
 
     def test_icon(self):
@@ -149,30 +150,27 @@ class TestWetairWCH750Heater(
 
     def test_hvac_mode(self):
         self.dps[HVACMODE_DPS] = True
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.HEAT)
 
         self.dps[HVACMODE_DPS] = False
-        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
-
-        self.dps[HVACMODE_DPS] = None
-        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+        self.assertEqual(self.subject.hvac_mode, HVACMode.OFF)
 
     def test_hvac_modes(self):
-        self.assertCountEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+        self.assertCountEqual(self.subject.hvac_modes, [HVACMode.OFF, HVACMode.HEAT])
 
     async def test_turn_on(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: True},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+            await self.subject.async_set_hvac_mode(HVACMode.HEAT)
 
     async def test_turn_off(self):
         async with assert_device_properties_set(
             self.subject._device,
             {HVACMODE_DPS: False},
         ):
-            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+            await self.subject.async_set_hvac_mode(HVACMode.OFF)
 
     def test_preset_mode(self):
         self.dps[PRESET_DPS] = "mod_free"

tests/mixins/lock.py

@@ -1,6 +1,5 @@
 # Mixins for testing locks
 from homeassistant.components.lock import STATE_LOCKED, STATE_UNLOCKED
-from homeassistant.const import STATE_UNAVAILABLE
 
 from ..helpers import assert_device_properties_set
 
@@ -17,9 +16,6 @@ class BasicLockTests:
         self.dps[self.basicLockDps] = False
         self.assertEqual(self.basicLock.state, STATE_UNLOCKED)
 
-        self.dps[self.basicLockDps] = None
-        self.assertEqual(self.basicLock.state, STATE_UNAVAILABLE)
-
     def test_basic_lock_is_locked(self):
         self.dps[self.basicLockDps] = True
         self.assertTrue(self.basicLock.is_locked)