Finished GPCV heater tests

Also added some missing coverage

tests/dehumidifier/test_lock.py

@@ -1,6 +1,9 @@
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, patch
 
+from homeassistant.components.lock import STATE_LOCKED, STATE_UNLOCKED
+from homeassistant.const import STATE_UNAVAILABLE
+
 from custom_components.goldair_climate.dehumidifier.const import (
     ATTR_CHILD_LOCK,
     ATTR_HVAC_MODE,
@@ -39,6 +42,16 @@ class TestGoldairDehumidifierChildLock(IsolatedAsyncioTestCase):
     def test_device_info_returns_device_info_from_device(self):
         self.assertEqual(self.subject.device_info, self.subject._device.device_info)
 
+    def test_state(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
+        self.assertEqual(self.subject.state, STATE_LOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = False
+        self.assertEqual(self.subject.state, STATE_UNLOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = None
+        self.assertEqual(self.subject.state, STATE_UNAVAILABLE)
+
     def test_is_locked(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
         self.assertEqual(self.subject.is_locked, True)

tests/geco_heater/test_climate.py

@@ -83,6 +83,10 @@ class TestGoldairGECOHeater(IsolatedAsyncioTestCase):
         ):
             await self.subject.async_set_temperature(temperature=25)
 
+    async def test_legacy_set_temperature_does_nothing_without_temperature_value(self):
+        await self.subject.async_set_temperature(something="else")
+        self.subject._device.async_set_property.assert_not_called()
+
     async def test_set_target_temperature_succeeds_within_valid_range(self):
         async with assert_device_properties_set(
             self.subject._device, {PROPERTY_TO_DPS_ID[ATTR_TARGET_TEMPERATURE]: 25}

tests/geco_heater/test_lock.py

@@ -1,6 +1,9 @@
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, patch
 
+from homeassistant.components.lock import STATE_LOCKED, STATE_UNLOCKED
+from homeassistant.const import STATE_UNAVAILABLE
+
 from custom_components.goldair_climate.geco_heater.const import (
     ATTR_CHILD_LOCK,
     ATTR_HVAC_MODE,
@@ -39,6 +42,16 @@ class TestGoldairGECOHeaterChildLock(IsolatedAsyncioTestCase):
     def test_device_info_returns_device_info_from_device(self):
         self.assertEqual(self.subject.device_info, self.subject._device.device_info)
 
+    def test_state(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
+        self.assertEqual(self.subject.state, STATE_LOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = False
+        self.assertEqual(self.subject.state, STATE_UNLOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = None
+        self.assertEqual(self.subject.state, STATE_UNAVAILABLE)
+
     def test_is_locked(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
         self.assertEqual(self.subject.is_locked, True)

tests/gpcv_heater/test_climate.py

@@ -0,0 +1,211 @@
+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_TARGET_TEMPERATURE,
+)
+from homeassistant.const import ATTR_TEMPERATURE, STATE_UNAVAILABLE
+
+from custom_components.goldair_climate.gpcv_heater.climate import GoldairGPCVHeater
+from custom_components.goldair_climate.gpcv_heater.const import (
+    ATTR_ERROR,
+    ATTR_TARGET_TEMPERATURE,
+    HVAC_MODE_TO_DPS_MODE,
+    PRESET_HIGH,
+    PRESET_LOW,
+    PRESET_MODE_TO_DPS_MODE,
+    PROPERTY_TO_DPS_ID,
+)
+
+from ..const import GPCV_HEATER_PAYLOAD
+from ..helpers import assert_device_properties_set
+
+
+class TestGoldairGPCVHeater(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 = GoldairGPCVHeater(self.mock_device())
+
+        self.dps = GPCV_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,
+        )
+
+    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")
+
+    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.assertEqual(self.subject.target_temperature, 25)
+
+    def test_target_temperature_step(self):
+        self.assertEqual(self.subject.target_temperature_step, 1)
+
+    def test_minimum_target_temperature(self):
+        self.assertEqual(self.subject.min_temp, 15)
+
+    def test_maximum_target_temperature(self):
+        self.assertEqual(self.subject.max_temp, 35)
+
+    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[PRESET_LOW]},
+        ):
+            await self.subject.async_set_temperature(preset_mode=PRESET_LOW)
+
+    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[
+                    PRESET_LOW
+                ],
+            },
+        ):
+            await self.subject.async_set_temperature(
+                temperature=25, preset_mode=PRESET_LOW
+            )
+
+    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_succeeds_within_valid_range(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(25)
+
+    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"
+        ):
+            await self.subject.async_set_target_temperature(14)
+
+        with self.assertRaises(
+            ValueError, msg="Target temperature 36 must be between 15 and 35"
+        ):
+            await self.subject.async_set_target_temperature(36)
+
+    async 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)
+
+    async def test_preset_mode(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            PRESET_LOW
+        ]
+        self.assertEqual(self.subject.preset_mode, PRESET_LOW)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = PRESET_MODE_TO_DPS_MODE[
+            PRESET_HIGH
+        ]
+        self.assertEqual(self.subject.preset_mode, PRESET_HIGH)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]] = None
+        self.assertIs(self.subject.preset_mode, None)
+
+    async def test_preset_modes(self):
+        self.assertEqual(self.subject.preset_modes, [PRESET_LOW, PRESET_HIGH])
+
+    async def test_set_preset_mode_to_low(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[PRESET_LOW]},
+        ):
+            await self.subject.async_set_preset_mode(PRESET_LOW)
+
+    async def test_set_preset_mode_to_high(self):
+        async with assert_device_properties_set(
+            self.subject._device,
+            {
+                PROPERTY_TO_DPS_ID[ATTR_PRESET_MODE]: PRESET_MODE_TO_DPS_MODE[
+                    PRESET_HIGH
+                ]
+            },
+        ):
+            await self.subject.async_set_preset_mode(PRESET_HIGH)
+
+    async 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()

tests/gpcv_heater/test_lock.py

@@ -1,6 +1,9 @@
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, patch
 
+from homeassistant.components.lock import STATE_LOCKED, STATE_UNLOCKED
+from homeassistant.const import STATE_UNAVAILABLE
+
 from custom_components.goldair_climate.gpcv_heater.const import (
     ATTR_CHILD_LOCK,
     ATTR_HVAC_MODE,
@@ -39,6 +42,16 @@ class TestGoldairGPCVHeaterChildLock(IsolatedAsyncioTestCase):
     def test_device_info_returns_device_info_from_device(self):
         self.assertEqual(self.subject.device_info, self.subject._device.device_info)
 
+    def test_state(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
+        self.assertEqual(self.subject.state, STATE_LOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = False
+        self.assertEqual(self.subject.state, STATE_UNLOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = None
+        self.assertEqual(self.subject.state, STATE_UNAVAILABLE)
+
     def test_is_locked(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
         self.assertEqual(self.subject.is_locked, True)

tests/heater/test_lock.py

@@ -1,6 +1,9 @@
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, patch
 
+from homeassistant.components.lock import STATE_LOCKED, STATE_UNLOCKED
+from homeassistant.const import STATE_UNAVAILABLE
+
 from custom_components.goldair_climate.heater.const import (
     ATTR_CHILD_LOCK,
     ATTR_HVAC_MODE,
@@ -37,6 +40,16 @@ class TestGoldairHeaterChildLock(IsolatedAsyncioTestCase):
     def test_device_info_returns_device_info_from_device(self):
         self.assertEqual(self.subject.device_info, self.subject._device.device_info)
 
+    def test_state(self):
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
+        self.assertEqual(self.subject.state, STATE_LOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = False
+        self.assertEqual(self.subject.state, STATE_UNLOCKED)
+
+        self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = None
+        self.assertEqual(self.subject.state, STATE_UNAVAILABLE)
+
     def test_is_locked(self):
         self.dps[PROPERTY_TO_DPS_ID[ATTR_CHILD_LOCK]] = True
         self.assertEqual(self.subject.is_locked, True)

tests/helpers.py

@@ -6,12 +6,20 @@ from custom_components.goldair_climate.device import GoldairTuyaDevice
 
 @asynccontextmanager
 async def assert_device_properties_set(device: GoldairTuyaDevice, properties: dict):
-    result = AsyncMock()
-    device.async_set_property.return_value = result()
+    results = []
+
+    def generate_result(*args):
+        result = AsyncMock()
+        results.append(result)
+        return result()
+
+    device.async_set_property.side_effect = generate_result
 
     try:
         yield
     finally:
+        assert device.async_set_property.call_count == len(properties.keys())
         for key in properties.keys():
-            device.async_set_property.assert_called_once_with(key, properties[key])
-        result.assert_awaited()
+            device.async_set_property.assert_any_call(key, properties[key])
+        for result in results:
+            result.assert_awaited()