python-izone 1.3.1__tar.gz → 1.3.2__tar.gz

{python_izone-1.3.1 → python_izone-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-izone
-Version: 1.3.1
+Version: 1.3.2
 Summary: A python interface to the iZone airconditioner controller
 Project-URL: Homepage, https://github.com/Swamp-Ig/pizone
 Author-email: Penny Wood <pypl@ninjateaparty.com>

{python_izone-1.3.1 → python_izone-1.3.2}/pizone/controller.py

@@ -122,7 +122,7 @@ class Controller:
         """Load system, zone, and optional power data from the device.
 
         Raises:
-            ConnectionError: If any initial HTTP request fails.
+            ConnectionError: If a required HTTP request fails.
             KeyError: If a required field is missing from a device response.
         """
         await self._refresh_system(notify=False)
@@ -131,24 +131,58 @@ class Controller:
             str(self._system_settings.get("FanAuto", "disabled"))
         ]
 
+        await self._probe_v2_api()
+
         zone_count = int(self._system_settings["NoOfZones"])
         self.zones = [Zone(self, i) for i in range(zone_count)]
 
-        if self._is_ipower:
-            self._power = Power(self)
-            await asyncio.gather(
-                self._refresh_zones(notify=False),
-                self._power.init(),
-            )
-            if self._power.enabled:
-                await self._refresh_power(notify=False)
-        else:
-            self._power = None
-            await self._refresh_zones(notify=False)
+        await self._refresh_zones(notify=False)
+
+        await self._probe_power()
 
         self._initialized = True
         self._discovery_service.create_task(self._poll_loop())
 
+    async def _probe_v2_api(self) -> None:
+        """Detect V2 API support; non-fatal on failure."""
+        try:
+            response = await self._send_command_async(
+                "iZoneRequestV2",
+                {"iZoneV2Request": {"Type": 1, "No": 0, "No1": 0}},
+                mark_disconnected=False,
+            )
+            data = json.loads(response)
+            uid = data["AirStreamDeviceUId"]
+            self._is_v2 = uid == self._device_uid and "SystemV2" in data
+        except (ConnectionError, ControllerCommandError, json.JSONDecodeError, KeyError):
+            self._is_v2 = False
+
+    async def _probe_power(self) -> None:
+        """Probe power monitor endpoint when discovery hinted iPower; non-fatal."""
+        if not self._is_ipower:
+            self._power = None
+            return
+
+        try:
+            power = Power(self)
+            await power.init(mark_disconnected=False)
+            if power.enabled:
+                self._power = power
+                return
+            _LOG.warning(
+                "Power monitor disabled on uid=%s; skipping power support",
+                self._device_uid,
+            )
+        except (ConnectionError, ControllerCommandError, json.JSONDecodeError, KeyError):
+            _LOG.warning(
+                "Power monitor probe failed for uid=%s",
+                self._device_uid,
+                exc_info=True,
+            )
+
+        self._is_ipower = False
+        self._power = None
+
     async def _poll_loop(self) -> None:
         while True:
             try:
@@ -206,6 +240,11 @@ class Controller:
         """Return whether this is a v2 controller."""
         return self._is_v2
 
+    @property
+    def is_ipower(self) -> bool:
+        """Return whether power monitoring is available."""
+        return self._is_ipower
+
     @property
     def discovery(self) -> DiscoveryService:
         """Discovery service for this controller."""
@@ -630,10 +669,14 @@ class Controller:
             raise ConnectionError("Unable to connect to the controller") from ex
 
     async def _send_command_async(
-        self, command: str, data: dict[str, Any]
+        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
     ) -> str:
         """Send a command to the device via HTTP POST.
 
+        Args:
+            mark_disconnected: When ``False``, transport failures do not mark
+                the controller disconnected.
+
         Raises:
             ConnectionError: If the device cannot be reached or the HTTP request fails.
             ControllerCommandError: If the device returns HTTP 4xx or an
@@ -665,7 +708,8 @@ class Controller:
                     )
                 result = await response.text(encoding="latin_1")
         except (asyncio.TimeoutError, aiohttp.ClientError) as ex:
-            self._failed_connection(ex)
+            if mark_disconnected:
+                self._failed_connection(ex)
             raise ConnectionError("Unable to connect to controller") from ex
 
         if len(result) >= 7 and result[:6] == "{ERROR":

{python_izone-1.3.1 → python_izone-1.3.2}/pizone/power.py

@@ -191,15 +191,21 @@ class Power:
         self._devices = tuple(PowerDevice(self, i) for i in range(5))
         self._groups: tuple[PowerGroup, ...] | None = None
 
-    async def init(self) -> None:
+    async def init(self, *, mark_disconnected: bool = True) -> None:
         """Load power monitor configuration from the device.
 
+        Args:
+            mark_disconnected: When ``False``, connection failures during this
+                request do not mark the controller disconnected.
+
         Raises:
             ConnectionError: If the HTTP request fails.
             json.JSONDecodeError: If the device response is not valid JSON.
             KeyError: If the response is missing required fields.
         """
-        self._config = await self._do_request(1, "PowerMonitorConfig")
+        self._config = await self._do_request(
+            1, "PowerMonitorConfig", mark_disconnected=mark_disconnected
+        )
         gdict: dict[int, list[PowerChannel]] = {}
         for dev in self.devices:
             for chan in dev.channels:
@@ -226,9 +232,15 @@ class Power:
         self._status = status
         return True
 
-    async def _do_request(self, req_type: int, result: str) -> dict[str, Any]:
+    async def _do_request(
+        self, req_type: int, result: str, *, mark_disconnected: bool = True
+    ) -> dict[str, Any]:
         """Send a power monitor request to the device.
 
+        Args:
+            mark_disconnected: When ``False``, connection failures do not mark
+                the controller disconnected.
+
         Raises:
             ConnectionError: If the HTTP request fails.
             json.JSONDecodeError: If the device response is not valid JSON.
@@ -236,7 +248,9 @@ class Power:
         """
         # pylint: disable=protected-access
         datas = await self._controller._send_command_async(
-            "PowerRequest", {"PowerRequest": {"Type": req_type, "No": 0, "No1": 0}}
+            "PowerRequest",
+            {"PowerRequest": {"Type": req_type, "No": 0, "No1": 0}},
+            mark_disconnected=mark_disconnected,
         )
         data = json.loads(datas)
         return cast(dict[str, Any], data[result])

{python_izone-1.3.1 → python_izone-1.3.2}/pizone/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.1'
-__version_tuple__ = version_tuple = (1, 3, 1)
+__version__ = version = '1.3.2'
+__version_tuple__ = version_tuple = (1, 3, 2)
 
 __commit_id__ = commit_id = None

{python_izone-1.3.1 → python_izone-1.3.2}/tests/conftest.py

@@ -51,6 +51,9 @@ class MockController(Controller):
         self.resources = _system_data(device_uid)
         self.sent: list[tuple[str, Any]] = []
         self._connected = True
+        self.v2_probe_response: str | None = None
+        self.power_config: dict[str, Any] | None = None
+        self.fail_power_types: set[int] = set()
 
     def _check_discovery_connected(self) -> None:
         service = cast(MockDiscoveryService, self.discovery)
@@ -69,7 +72,7 @@ class MockController(Controller):
         raise ConnectionError(f"Mock resource '{resource}' not available")
 
     async def _send_command_async(
-        self, command: str, data: dict[str, Any]
+        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
     ) -> str:
         """Mock out the network IO for _send_command."""
         if self._fail_exception:
@@ -78,13 +81,29 @@ class MockController(Controller):
             ) from self._fail_exception
         self._check_discovery_connected()
         self.sent.append((command, data))
-        self._restored_connection()
+        if command == "iZoneRequestV2":
+            if self.v2_probe_response is not None:
+                self._restored_connection()
+                return self.v2_probe_response
+            ex = ConnectionError("V2 probe failed")
+            if mark_disconnected:
+                self._failed_connection(ex)
+            raise ConnectionError("Unable to connect to controller") from ex
         if command == "PowerRequest":
             req_type: int = data["PowerRequest"]["Type"]
+            if req_type in self.fail_power_types:
+                ex = TimeoutError("Power request failed")
+                if mark_disconnected:
+                    self._failed_connection(ex)
+                raise ConnectionError("Unable to connect to controller") from ex
             if req_type == 1:
-                return json.dumps({"PowerMonitorConfig": POWER_CONFIG})
+                config = self.power_config if self.power_config is not None else POWER_CONFIG
+                self._restored_connection()
+                return json.dumps({"PowerMonitorConfig": config})
             if req_type == 2:
+                self._restored_connection()
                 return json.dumps({"PowerMonitorStatus": POWER_STATUS})
+        self._restored_connection()
         return ""
 
 

python_izone-1.3.2/tests/test_controller.py

@@ -0,0 +1,295 @@
+"""Tests for controller property reads and command paths."""
+
+# pylint: disable=protected-access
+from copy import deepcopy
+from typing import cast
+
+import pytest
+from pytest import raises
+
+from pizone import Controller
+
+from .conftest import MockController, MockDiscoveryService, _register_mock_service
+from .power_data import POWER_CONFIG
+
+
+@pytest.mark.asyncio
+async def test_controller_property_reads(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    assert controller.connected is True
+    assert controller.power is None
+    assert controller.device_ip == "8.8.8.8"
+    assert controller.device_uid == "000000001"
+    assert controller.is_v2 is False
+    assert controller.is_on is True
+    assert controller.mode == Controller.Mode.HEAT
+    assert controller.fan == Controller.Fan.AUTO
+    assert controller.sleep_timer == 0
+    assert controller.free_air_enabled is True
+    assert controller.free_air is False
+    assert controller.temp_supply == pytest.approx(25.1)
+    assert controller.temp_setpoint == pytest.approx(23.5)
+    assert controller.temp_return == pytest.approx(23.6)
+    assert controller.eco_lock is True
+    assert controller.temp_min == pytest.approx(15.0)
+    assert controller.temp_max == pytest.approx(30.0)
+    assert controller.ras_mode == "zones"
+    assert controller.zone_ctrl == 1
+    assert controller.zones_total == 8
+    assert controller.zones_const == 1
+    assert controller.sys_type == "320"
+
+
+@pytest.mark.asyncio
+async def test_set_on(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    await controller.set_on(False)
+    assert controller.is_on is False
+    assert controller.sent[-1] == ("SystemON", {"SystemON": "off"})
+
+    await controller.set_on(True)
+    assert controller.is_on is True
+
+
+@pytest.mark.asyncio
+async def test_set_fan(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+    fan = Controller.Fan.LOW
+
+    await controller.set_fan(fan)
+    assert controller.fan == fan
+    assert controller.sent[-1] == ("SystemFAN", {"SystemFAN": "low"})
+
+
+@pytest.mark.asyncio
+async def test_set_sleep_timer(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    await controller.set_sleep_timer(30)
+    assert controller.sleep_timer == 30
+
+    await controller.set_sleep_timer(0)
+    assert controller.sleep_timer == 0
+
+
+@pytest.mark.asyncio
+async def test_set_temp_setpoint(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    await controller.set_temp_setpoint(22.5)
+    assert controller.temp_setpoint == pytest.approx(22.5)
+
+
+@pytest.mark.asyncio
+async def test_set_fan_validation(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    with raises(AttributeError, match="Fan mode top not allowed"):
+        await controller.set_fan(Controller.Fan.TOP)
+
+
+@pytest.mark.asyncio
+async def test_set_sleep_timer_validation(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    with raises(AttributeError, match="Invalid Sleep Timer"):
+        await controller.set_sleep_timer(45)
+
+
+@pytest.mark.asyncio
+async def test_set_temp_setpoint_validation(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    with raises(AttributeError, match="not rounded to nearest 0.5"):
+        await controller.set_temp_setpoint(23.3)
+    with raises(AttributeError, match="out of range"):
+        await controller.set_temp_setpoint(35.0)
+
+
+@pytest.mark.asyncio
+async def test_refresh_all(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+
+    await controller._refresh_all(notify=False)
+
+    assert controller.mode == Controller.Mode.HEAT
+    assert controller.zones[0].name == "LIVING"
+
+
+@pytest.mark.asyncio
+async def test_initialize_succeeds_when_power_init_fails() -> None:
+    svc = MockDiscoveryService()
+    original_create = svc._create_controller
+
+    def create_controller(
+        device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+    ) -> MockController:
+        controller = original_create(device_uid, device_ip, is_v2, is_ipower)
+        controller.fail_power_types.add(1)
+        return controller
+
+    svc._create_controller = create_controller
+
+    try:
+        await _register_mock_service(
+            svc,
+            b"ASPort_12107,Mac_000000003,IP_10.0.0.1,iZone,iPower",
+        )
+        controller = cast(MockController, svc._controllers["000000003"])
+
+        assert controller.connected is True
+        assert controller.power is None
+        assert controller.is_ipower is False
+        assert controller._initialized is True
+    finally:
+        await svc.close()
+
+
+@pytest.mark.asyncio
+async def test_initialize_sets_power_when_ipower_works(
+    ipower_service: MockDiscoveryService,
+) -> None:
+    controller = cast(MockController, ipower_service._controllers["000000003"])
+
+    assert controller.power is not None
+    assert controller.power.enabled is True
+    assert controller.is_ipower is True
+
+
+@pytest.mark.asyncio
+async def test_initialize_does_not_fetch_power_status(
+    ipower_service: MockDiscoveryService,
+) -> None:
+    controller = cast(MockController, ipower_service._controllers["000000003"])
+    power_requests = [
+        data
+        for command, data in controller.sent
+        if command == "PowerRequest"
+    ]
+
+    assert len(power_requests) == 1
+    assert power_requests[0]["PowerRequest"]["Type"] == 1
+
+    await controller._refresh_power(notify=False)
+
+    status_requests = [
+        data
+        for command, data in controller.sent
+        if command == "PowerRequest" and data["PowerRequest"]["Type"] == 2
+    ]
+    assert len(status_requests) == 1
+
+
+@pytest.mark.asyncio
+async def test_initialize_clears_ipower_when_config_disabled() -> None:
+    disabled_config = deepcopy(POWER_CONFIG)
+    disabled_config["Enabled"] = 0
+
+    svc = MockDiscoveryService()
+    original_create = svc._create_controller
+
+    def create_controller(
+        device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+    ) -> MockController:
+        controller = original_create(device_uid, device_ip, is_v2, is_ipower)
+        controller.power_config = disabled_config
+        return controller
+
+    svc._create_controller = create_controller
+
+    try:
+        await _register_mock_service(
+            svc,
+            b"ASPort_12107,Mac_000000003,IP_10.0.0.1,iZone,iPower",
+        )
+        controller = cast(MockController, svc._controllers["000000003"])
+
+        assert controller.power is None
+        assert controller.is_ipower is False
+    finally:
+        await svc.close()
+
+
+@pytest.mark.asyncio
+async def test_power_init_probe_timeout_does_not_mark_disconnected() -> None:
+    svc = MockDiscoveryService()
+    original_create = svc._create_controller
+
+    def create_controller(
+        device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+    ) -> MockController:
+        controller = original_create(device_uid, device_ip, is_v2, is_ipower)
+        controller.fail_power_types.add(1)
+        return controller
+
+    svc._create_controller = create_controller
+
+    try:
+        await _register_mock_service(
+            svc,
+            b"ASPort_12107,Mac_000000003,IP_10.0.0.1,iZone,iPower",
+        )
+        controller = cast(MockController, svc._controllers["000000003"])
+
+        assert controller.connected is True
+        assert controller._fail_exception is None
+    finally:
+        await svc.close()
+
+
+@pytest.mark.asyncio
+async def test_power_poll_timeout_marks_disconnected(
+    ipower_service: MockDiscoveryService,
+) -> None:
+    controller = cast(MockController, ipower_service._controllers["000000003"])
+    controller.fail_power_types.add(2)
+
+    with raises(ConnectionError):
+        await controller._refresh_power(notify=False)
+
+    assert controller.connected is False
+
+
+@pytest.mark.asyncio
+async def test_v2_probe_sets_is_v2_when_systemv2_returned() -> None:
+    svc = MockDiscoveryService()
+    original_create = svc._create_controller
+
+    def create_controller(
+        device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+    ) -> MockController:
+        controller = original_create(device_uid, device_ip, is_v2, is_ipower)
+        controller.v2_probe_response = (
+            '{"AirStreamDeviceUId":"000000001","SystemV2":{"SysOn":"on"}}'
+        )
+        return controller
+
+    svc._create_controller = create_controller
+
+    try:
+        await _register_mock_service(
+            svc,
+            b"ASPort_12107,Mac_000000001,IP_8.8.8.8,iZone,iLight,iDrate",
+        )
+        controller = cast(MockController, svc._controllers["000000001"])
+
+        assert controller.is_v2 is True
+    finally:
+        await svc.close()
+
+
+@pytest.mark.asyncio
+async def test_v2_probe_clears_is_v2_on_http_error() -> None:
+    svc = MockDiscoveryService()
+    try:
+        await _register_mock_service(
+            svc,
+            b"ASPort_12107,Mac_000000001,IP_8.8.8.8,iZoneV2,iLight,iDrate",
+        )
+        controller = cast(MockController, svc._controllers["000000001"])
+
+        assert controller.is_v2 is False
+    finally:
+        await svc.close()

{python_izone-1.3.1 → python_izone-1.3.2}/tests/test_discovery.py

@@ -109,7 +109,7 @@ async def test_discovery(service: MockDiscoveryService) -> None:
     assert controller.mode == Controller.Mode.HEAT
 
     await controller.set_mode(Controller.Mode.COOL)
-    assert controller.sent[0] == ("SystemMODE", {"SystemMODE": "cool"})
+    assert controller.sent[-1] == ("SystemMODE", {"SystemMODE": "cool"})
     assert controller.mode == Controller.Mode.COOL
 
 
@@ -126,7 +126,7 @@ async def test_legacy_discovery(legacy_service: MockDiscoveryService) -> None:
     assert controller.mode == Controller.Mode.HEAT
 
     await controller.set_mode(Controller.Mode.COOL)
-    assert controller.sent[0] == ("SystemMODE", {"SystemMODE": "cool"})
+    assert controller.sent[-1] == ("SystemMODE", {"SystemMODE": "cool"})
     assert controller.mode == Controller.Mode.COOL
 
 
@@ -236,6 +236,7 @@ async def test_reconnect(
     assert controller.mode == Controller.Mode.HEAT
 
     controller._failed_connection(ConnectionError("Fake connection error"))
+    controller.sent.clear()
     with raises(ConnectionError):
         await controller.set_mode(Controller.Mode.COOL)
 
@@ -251,7 +252,7 @@ async def test_reconnect(
     # Reconnect OK
     assert caplog.messages[1][:23] == "Controller reconnected:"
     await controller.set_mode(Controller.Mode.COOL)
-    assert controller.sent[0] == ("SystemMODE", {"SystemMODE": "cool"})
+    assert controller.sent[-1] == ("SystemMODE", {"SystemMODE": "cool"})
 
 
 @pytest.mark.asyncio

{python_izone-1.3.1 → python_izone-1.3.2}/tests/test_power.py

@@ -19,8 +19,9 @@ class MockPowerController:
         self.sent: list[tuple[str, dict[str, Any]]] = []
 
     async def _send_command_async(
-        self, command: str, data: dict[str, Any]
+        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
     ) -> str:
+        del mark_disconnected
         self.sent.append((command, data))
         req_type: int = data["PowerRequest"]["Type"]
         return json.dumps(self._responses[req_type])

python_izone-1.3.1/tests/test_controller.py

@@ -1,116 +0,0 @@
-"""Tests for controller property reads and command paths."""
-
-# pylint: disable=protected-access
-from typing import cast
-
-import pytest
-from pytest import raises
-
-from pizone import Controller
-
-from .conftest import MockController, MockDiscoveryService
-
-
-@pytest.mark.asyncio
-async def test_controller_property_reads(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    assert controller.connected is True
-    assert controller.power is None
-    assert controller.device_ip == "8.8.8.8"
-    assert controller.device_uid == "000000001"
-    assert controller.is_v2 is False
-    assert controller.is_on is True
-    assert controller.mode == Controller.Mode.HEAT
-    assert controller.fan == Controller.Fan.AUTO
-    assert controller.sleep_timer == 0
-    assert controller.free_air_enabled is True
-    assert controller.free_air is False
-    assert controller.temp_supply == pytest.approx(25.1)
-    assert controller.temp_setpoint == pytest.approx(23.5)
-    assert controller.temp_return == pytest.approx(23.6)
-    assert controller.eco_lock is True
-    assert controller.temp_min == pytest.approx(15.0)
-    assert controller.temp_max == pytest.approx(30.0)
-    assert controller.ras_mode == "zones"
-    assert controller.zone_ctrl == 1
-    assert controller.zones_total == 8
-    assert controller.zones_const == 1
-    assert controller.sys_type == "320"
-
-
-@pytest.mark.asyncio
-async def test_set_on(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    await controller.set_on(False)
-    assert controller.is_on is False
-    assert controller.sent[-1] == ("SystemON", {"SystemON": "off"})
-
-    await controller.set_on(True)
-    assert controller.is_on is True
-
-
-@pytest.mark.asyncio
-async def test_set_fan(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-    fan = Controller.Fan.LOW
-
-    await controller.set_fan(fan)
-    assert controller.fan == fan
-    assert controller.sent[-1] == ("SystemFAN", {"SystemFAN": "low"})
-
-
-@pytest.mark.asyncio
-async def test_set_sleep_timer(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    await controller.set_sleep_timer(30)
-    assert controller.sleep_timer == 30
-
-    await controller.set_sleep_timer(0)
-    assert controller.sleep_timer == 0
-
-
-@pytest.mark.asyncio
-async def test_set_temp_setpoint(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    await controller.set_temp_setpoint(22.5)
-    assert controller.temp_setpoint == pytest.approx(22.5)
-
-
-@pytest.mark.asyncio
-async def test_set_fan_validation(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    with raises(AttributeError, match="Fan mode top not allowed"):
-        await controller.set_fan(Controller.Fan.TOP)
-
-
-@pytest.mark.asyncio
-async def test_set_sleep_timer_validation(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    with raises(AttributeError, match="Invalid Sleep Timer"):
-        await controller.set_sleep_timer(45)
-
-
-@pytest.mark.asyncio
-async def test_set_temp_setpoint_validation(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    with raises(AttributeError, match="not rounded to nearest 0.5"):
-        await controller.set_temp_setpoint(23.3)
-    with raises(AttributeError, match="out of range"):
-        await controller.set_temp_setpoint(35.0)
-
-
-@pytest.mark.asyncio
-async def test_refresh_all(service: MockDiscoveryService) -> None:
-    controller = cast(MockController, service._controllers["000000001"])
-
-    await controller._refresh_all(notify=False)
-
-    assert controller.mode == Controller.Mode.HEAT
-    assert controller.zones[0].name == "LIVING"