Full coverage for GPPH heater component

Also fixed some missing coverage and tidied up some specs.

custom_components/goldair_climate/geco_heater/climate.py

@@ -110,7 +110,7 @@ class GoldairGECOHeater(ClimateEntity):
         if not limits["min"] <= target_temperature <= limits["max"]:
             raise ValueError(
                 f"Target temperature ({target_temperature}) must be between "
-                f'{limits["min"]} and {limits["max"]}'
+                f'{limits["min"]} and {limits["max"]}.'
             )
 
         await self._device.async_set_property(

custom_components/goldair_climate/gpcv_heater/climate.py

@@ -115,7 +115,7 @@ class GoldairGPCVHeater(ClimateEntity):
         if not limits["min"] <= target_temperature <= limits["max"]:
             raise ValueError(
                 f"Target temperature ({target_temperature}) must be between "
-                f'{limits["min"]} and {limits["max"]}'
+                f'{limits["min"]} and {limits["max"]}.'
             )
 
         await self._device.async_set_property(

custom_components/goldair_climate/heater/climate.py

@@ -26,6 +26,7 @@ from .const import (
     ATTR_POWER_MODE_USER,
     ATTR_TARGET_TEMPERATURE,
     HVAC_MODE_TO_DPS_MODE,
+    POWER_LEVEL_STOP,
     POWER_LEVEL_TO_DPS_LEVEL,
     PRESET_MODE_TO_DPS_MODE,
     PROPERTY_TO_DPS_ID,
@@ -85,7 +86,7 @@ class GoldairHeater(ClimateEntity):
         """Return the icon to use in the frontend for this device."""
         hvac_mode = self.hvac_mode
         power_level = self._device.get_property(PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL])
-        if hvac_mode == HVAC_MODE_HEAT and power_level != "stop":
+        if hvac_mode == HVAC_MODE_HEAT and power_level != POWER_LEVEL_STOP:
             return "mdi:radiator"
         else:
             return "mdi:radiator-disabled"
@@ -148,16 +149,16 @@ class GoldairHeater(ClimateEntity):
         if not limits["min"] <= target_temperature <= limits["max"]:
             raise ValueError(
                 f"Target temperature ({target_temperature}) must be between "
-                f'{limits["min"]} and {limits["max"]}'
+                f'{limits["min"]} and {limits["max"]}.'
             )
 
-        if preset_mode == STATE_COMFORT:
+        if preset_mode == STATE_ECO:
             await self._device.async_set_property(
-                PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE], target_temperature
+                PROPERTY_TO_DPS_ID[ATTR_ECO_TARGET_TEMPERATURE], target_temperature
             )
-        elif preset_mode == STATE_ECO:
+        else:
             await self._device.async_set_property(
-                PROPERTY_TO_DPS_ID[ATTR_ECO_TARGET_TEMPERATURE], target_temperature
+                PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE], target_temperature
             )
 
     @property

tests/fan/test_climate.py

@@ -96,7 +96,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
 
-    async def test_preset_mode(self):
+    def test_preset_mode(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_NORMAL
         ]
@@ -115,7 +115,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = None
         self.assertIs(self.subject.preset_mode, None)
 
-    async def test_preset_modes(self):
+    def test_preset_modes(self):
         self.assertEqual(
             self.subject.preset_modes, [PRESET_NORMAL, PRESET_ECO, PRESET_SLEEP]
         )
@@ -149,7 +149,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_preset_mode(PRESET_SLEEP)
 
-    async def test_swing_mode(self):
+    def test_swing_mode(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_SWING_MODE]] = SWING_MODE_TO_DPS_MODE[
             SWING_OFF
         ]
@@ -163,7 +163,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_SWING_MODE]] = None
         self.assertIs(self.subject.swing_mode, None)
 
-    async def test_swing_modes(self):
+    def test_swing_modes(self):
         self.assertEqual(self.subject.swing_modes, [SWING_OFF, SWING_HORIZONTAL])
 
     async def test_set_swing_mode_to_off(self):
@@ -184,7 +184,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_swing_mode(SWING_HORIZONTAL)
 
-    async def test_fan_modes(self):
+    def test_fan_modes(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_NORMAL
         ]
@@ -203,7 +203,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = None
         self.assertEqual(self.subject.fan_modes, [])
 
-    async def test_fan_mode_for_normal_preset(self):
+    def test_fan_mode_for_normal_preset(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_NORMAL
         ]
@@ -230,7 +230,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_fan_mode(6)
 
-    async def test_fan_mode_for_eco_preset(self):
+    def test_fan_mode_for_eco_preset(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_ECO
         ]
@@ -257,7 +257,7 @@ class TestGoldairFan(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_fan_mode(1)
 
-    async def test_fan_mode_for_sleep_preset(self):
+    def test_fan_mode_for_sleep_preset(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_SLEEP
         ]

tests/geco_heater/test_climate.py

@@ -93,18 +93,24 @@ class TestGoldairGECOHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_target_temperature(25)
 
+    async def test_set_target_temperature_rounds_value_to_closest_integer(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25},
+        ):
+            await self.subject.async_set_target_temperature(24.6)
+
     async def test_set_target_temperature_fails_outside_valid_range(self):
-        with self.assertRaises(
-            ValueError, msg="Target temperature 14 must be between 15 and 35"
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \(14\) must be between 15 and 35"
         ):
             await self.subject.async_set_target_temperature(14)
 
-        with self.assertRaises(
-            ValueError, msg="Target temperature 36 must be between 15 and 35"
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \(36\) must be between 15 and 35"
         ):
             await self.subject.async_set_target_temperature(36)
 
-    async def test_current_temperature(self):
+    def test_current_temperature(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_TEMPERATURE]] = 25
         self.assertEqual(self.subject.current_temperature, 25)
 
@@ -133,7 +139,7 @@ class TestGoldairGECOHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
 
-    async def test_error_state(self):
+    def test_error_state(self):
         # There are currently no known error states; update this as they're discovered
         self.dps[PROPERTY_TO_DPS_ID[ATTR_ERROR]] = "something"
         self.assertEqual(

tests/gpcv_heater/test_climate.py

@@ -119,18 +119,24 @@ class TestGoldairGPCVHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_target_temperature(25)
 
+    async def test_set_target_temperature_rounds_value_to_closest_integer(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25},
+        ):
+            await self.subject.async_set_target_temperature(24.6)
+
     async def test_set_target_temperature_fails_outside_valid_range(self):
-        with self.assertRaises(
-            ValueError, msg="Target temperature 14 must be between 15 and 35"
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \(14\) must be between 15 and 35"
         ):
             await self.subject.async_set_target_temperature(14)
 
-        with self.assertRaises(
-            ValueError, msg="Target temperature 36 must be between 15 and 35"
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \(36\) must be between 15 and 35"
         ):
             await self.subject.async_set_target_temperature(36)
 
-    async def test_current_temperature(self):
+    def test_current_temperature(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_TEMPERATURE]] = 25
         self.assertEqual(self.subject.current_temperature, 25)
 
@@ -159,7 +165,7 @@ class TestGoldairGPCVHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
 
-    async def test_preset_mode(self):
+    def test_preset_mode(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
             PRESET_LOW
         ]
@@ -173,7 +179,7 @@ class TestGoldairGPCVHeater(IsolatedAsyncioTestCase):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = None
         self.assertIs(self.subject.preset_mode, None)
 
-    async def test_preset_modes(self):
+    def test_preset_modes(self):
         self.assertEqual(self.subject.preset_modes, [PRESET_LOW, PRESET_HIGH])
 
     async def test_set_preset_mode_to_low(self):
@@ -194,7 +200,7 @@ class TestGoldairGPCVHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_preset_mode(PRESET_HIGH)
 
-    async def test_error_state(self):
+    def test_error_state(self):
         # There are currently no known error states; update this as they're discovered
         self.dps[PROPERTY_TO_DPS_ID[ATTR_ERROR]] = "something"
         self.assertEqual(

tests/heater/test_climate.py

@@ -0,0 +1,399 @@
+from unittest import IsolatedAsyncioTestCase
+from unittest.mock import AsyncMock, patch
+
+from homeassistant.components.climate.const import (
+    ATTR_HVAC_MODE,
+    ATTR_PRESET_MODE,
+    HVAC_MODE_HEAT,
+    HVAC_MODE_OFF,
+    SUPPORT_PRESET_MODE,
+    SUPPORT_SWING_MODE,
+    SUPPORT_TARGET_TEMPERATURE,
+)
+from homeassistant.const import ATTR_TEMPERATURE, STATE_UNAVAILABLE
+
+from custom_components.goldair_climate.heater.climate import GoldairHeater
+from custom_components.goldair_climate.heater.const import (
+    ATTR_ECO_TARGET_TEMPERATURE,
+    ATTR_ERROR,
+    ATTR_POWER_LEVEL,
+    ATTR_POWER_MODE,
+    ATTR_POWER_MODE_AUTO,
+    ATTR_POWER_MODE_USER,
+    ATTR_TARGET_TEMPERATURE,
+    HVAC_MODE_TO_DPS_MODE,
+    POWER_LEVEL_AUTO,
+    POWER_LEVEL_STOP,
+    POWER_LEVEL_TO_DPS_LEVEL,
+    PRESET_MODE_TO_DPS_MODE,
+    PROPERTY_TO_DPS_ID,
+    STATE_ANTI_FREEZE,
+    STATE_COMFORT,
+    STATE_ECO,
+)
+
+from ..const import GPPH_HEATER_PAYLOAD
+from ..helpers import assert_device_properties_set
+
+
+class TestGoldairHeater(IsolatedAsyncioTestCase):
+    def setUp(self):
+        device_patcher = patch(
+            "custom_components.goldair_climate.device.GoldairTuyaDevice"
+        )
+        self.addCleanup(device_patcher.stop)
+        self.mock_device = device_patcher.start()
+
+        self.subject = GoldairHeater(self.mock_device())
+
+        self.dps = GPPH_HEATER_PAYLOAD.copy()
+        self.subject._device.get_property.side_effect = lambda id: self.dps[id]
+
+    def test_supported_features(self):
+        self.assertEqual(
+            self.subject.supported_features,
+            SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE | SUPPORT_SWING_MODE,
+        )
+
+    def test_should_poll(self):
+        self.assertTrue(self.subject.should_poll)
+
+    def test_name_returns_device_name(self):
+        self.assertEqual(self.subject.name, self.subject._device.name)
+
+    def test_unique_id_returns_device_unique_id(self):
+        self.assertEqual(self.subject.unique_id, self.subject._device.unique_id)
+
+    def test_device_info_returns_device_info_from_device(self):
+        self.assertEqual(self.subject.device_info, self.subject._device.device_info)
+
+    def test_icon(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = True
+        self.assertEqual(self.subject.icon, "mdi:radiator")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = False
+        self.assertEqual(self.subject.icon, "mdi:radiator-disabled")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = True
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]] = POWER_LEVEL_STOP
+        self.assertEqual(self.subject.icon, "mdi:radiator-disabled")
+
+    def test_temperature_unit_returns_device_temperature_unit(self):
+        self.assertEqual(
+            self.subject.temperature_unit, self.subject._device.temperature_unit
+        )
+
+    def test_target_temperature(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]] = 25
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_ECO_TARGET_TEMPERATURE]] = 15
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+        self.assertEqual(self.subject.target_temperature, 25)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+        self.assertEqual(self.subject.target_temperature, 15)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ANTI_FREEZE
+        ]
+        self.assertIs(self.subject.target_temperature, None)
+
+    def test_target_temperature_step(self):
+        self.assertEqual(self.subject.target_temperature_step, 1)
+
+    def test_minimum_target_temperature(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+        self.assertEqual(self.subject.min_temp, 5)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+        self.assertEqual(self.subject.min_temp, 5)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ANTI_FREEZE
+        ]
+        self.assertIs(self.subject.min_temp, None)
+
+    def test_maximum_target_temperature(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+        self.assertEqual(self.subject.max_temp, 35)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+        self.assertEqual(self.subject.max_temp, 21)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ANTI_FREEZE
+        ]
+        self.assertIs(self.subject.max_temp, None)
+
+    async def test_legacy_set_temperature_with_temperature(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25}
+        ):
+            await self.subject.async_set_temperature(temperature=25)
+
+    async def test_legacy_set_temperature_with_preset_mode(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {
+                PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[
+                    STATE_COMFORT
+                ]
+            },
+        ):
+            await self.subject.async_set_temperature(preset_mode=STATE_COMFORT)
+
+    async def test_legacy_set_temperature_with_both_properties(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {
+                PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25,
+                PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[
+                    STATE_COMFORT
+                ],
+            },
+        ):
+            await self.subject.async_set_temperature(
+                temperature=25, preset_mode=STATE_COMFORT
+            )
+
+    async def test_legacy_set_temperature_with_no_valid_properties(self):
+        await self.subject.async_set_temperature(something="else")
+        self.subject._device.async_set_property.assert_not_called
+
+    async def test_set_target_temperature_in_comfort_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25}
+        ):
+            await self.subject.async_set_target_temperature(25)
+
+    async def test_set_target_temperature_in_eco_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_ECO_TARGET_TEMPERATURE]: 15}
+        ):
+            await self.subject.async_set_target_temperature(15)
+
+    async def test_set_target_temperature_rounds_value_to_closest_integer(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25},
+        ):
+            await self.subject.async_set_target_temperature(24.6)
+
+    async def test_set_target_temperature_fails_outside_valid_range_in_comfort(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \\(4\\) must be between 5 and 35"
+        ):
+            await self.subject.async_set_target_temperature(4)
+
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \\(36\\) must be between 5 and 35"
+        ):
+            await self.subject.async_set_target_temperature(36)
+
+    async def test_set_target_temperature_fails_outside_valid_range_in_eco(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \\(4\\) must be between 5 and 21"
+        ):
+            await self.subject.async_set_target_temperature(4)
+
+        with self.assertRaisesRegex(
+            ValueError, "Target temperature \\(22\\) must be between 5 and 21"
+        ):
+            await self.subject.async_set_target_temperature(22)
+
+    async def test_set_target_temperature_fails_in_anti_freeze(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ANTI_FREEZE
+        ]
+
+        with self.assertRaisesRegex(
+            ValueError, "You cannot set the temperature in Anti-freeze mode"
+        ):
+            await self.subject.async_set_target_temperature(25)
+
+    def test_current_temperature(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_TEMPERATURE]] = 25
+        self.assertEqual(self.subject.current_temperature, 25)
+
+    def test_hvac_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = True
+        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_HEAT)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = False
+        self.assertEqual(self.subject.hvac_mode, HVAC_MODE_OFF)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]] = None
+        self.assertEqual(self.subject.hvac_mode, STATE_UNAVAILABLE)
+
+    def test_hvac_modes(self):
+        self.assertEqual(self.subject.hvac_modes, [HVAC_MODE_OFF, HVAC_MODE_HEAT])
+
+    async def test_turn_on(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]: True}
+        ):
+            await self.subject.async_set_hvac_mode(HVAC_MODE_HEAT)
+
+    async def test_turn_off(self):
+        async with assert_device_properties_set(
+            self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_HVAC_MODE]: False}
+        ):
+            await self.subject.async_set_hvac_mode(HVAC_MODE_OFF)
+
+    def test_preset_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_COMFORT
+        ]
+        self.assertEqual(self.subject.preset_mode, STATE_COMFORT)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ECO
+        ]
+        self.assertEqual(self.subject.preset_mode, STATE_ECO)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            STATE_ANTI_FREEZE
+        ]
+        self.assertEqual(self.subject.preset_mode, STATE_ANTI_FREEZE)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = None
+        self.assertIs(self.subject.preset_mode, None)
+
+    def test_preset_modes(self):
+        self.assertEqual(
+            self.subject.preset_modes, [STATE_COMFORT, STATE_ECO, STATE_ANTI_FREEZE]
+        )
+
+    async def test_set_preset_mode_to_comfort(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {
+                PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[
+                    STATE_COMFORT
+                ]
+            },
+        ):
+            await self.subject.async_set_preset_mode(STATE_COMFORT)
+
+    async def test_set_preset_mode_to_eco(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[STATE_ECO]},
+        ):
+            await self.subject.async_set_preset_mode(STATE_ECO)
+
+    async def test_set_preset_mode_to_anti_freeze(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {
+                PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[
+                    STATE_ANTI_FREEZE
+                ]
+            },
+        ):
+            await self.subject.async_set_preset_mode(STATE_ANTI_FREEZE)
+
+    def test_power_level_returns_user_power_level(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_MODE]] = ATTR_POWER_MODE_USER
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]] = POWER_LEVEL_TO_DPS_LEVEL[
+            "Stop"
+        ]
+        self.assertEqual(self.subject.swing_mode, "Stop")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]] = POWER_LEVEL_TO_DPS_LEVEL["3"]
+        self.assertEqual(self.subject.swing_mode, "3")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]] = POWER_LEVEL_TO_DPS_LEVEL[
+            "Auto"
+        ]
+        self.assertEqual(self.subject.swing_mode, "Auto")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]] = None
+        self.assertIs(self.subject.swing_mode, None)
+
+    def test_power_level_in_returns_power_mode_when_not_in_user_power_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_MODE]] = POWER_LEVEL_TO_DPS_LEVEL["Stop"]
+        self.assertEqual(self.subject.swing_mode, "Stop")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_MODE]] = POWER_LEVEL_TO_DPS_LEVEL["3"]
+        self.assertEqual(self.subject.swing_mode, "3")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_MODE]] = POWER_LEVEL_TO_DPS_LEVEL["Auto"]
+        self.assertEqual(self.subject.swing_mode, "Auto")
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_POWER_MODE]] = None
+        self.assertIs(self.subject.swing_mode, None)
+
+    def test_power_levels(self):
+        self.assertEqual(
+            self.subject.swing_modes, ["Stop", "1", "2", "3", "4", "5", "Auto"],
+        )
+
+    async def test_set_power_level_to_stop(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]: POWER_LEVEL_TO_DPS_LEVEL["Stop"]},
+        ):
+            await self.subject.async_set_swing_mode("Stop")
+
+    async def test_set_power_level_to_auto(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]: POWER_LEVEL_TO_DPS_LEVEL["Auto"]},
+        ):
+            await self.subject.async_set_swing_mode("Auto")
+
+    async def test_set_power_level_to_numeric_value(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {PROPERTY_TO_DPS_ID[ATTR_POWER_LEVEL]: POWER_LEVEL_TO_DPS_LEVEL["3"]},
+        ):
+            await self.subject.async_set_swing_mode("3")
+
+    async def test_set_power_level_to_invalid_value_raises_error(self):
+        with self.assertRaisesRegex(ValueError, "Invalid power level: unknown"):
+            await self.subject.async_set_swing_mode("unknown")
+
+    def test_error_state(self):
+        # There are currently no known error states; update this as they're discovered
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_ERROR]] = "something"
+        self.assertEqual(
+            self.subject.device_state_attributes, {ATTR_ERROR: "something"}
+        )
+
+    async def test_update(self):
+        result = AsyncMock()
+        self.subject._device.async_refresh.return_value = result()
+
+        await self.subject.async_update()
+
+        self.subject._device.async_refresh.assert_called_once()
+        result.assert_awaited()