From 912d8c64effb54744ffedbca49159ec6420021c0 Mon Sep 17 00:00:00 2001 From: infy1995 Date: Tue, 17 Nov 2026 20:59:29 +0100 Subject: [PATCH 1/5] fix(v1): ignore legacy water levels pushed to water-slide devices --- roborock/devices/traits/v1/status.py | 14 ++++++++ tests/devices/traits/v1/test_status.py | 49 +++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/roborock/devices/traits/v1/status.py b/roborock/devices/traits/v1/status.py index 01eed9a5..b3d292f0 100644 --- a/roborock/devices/traits/v1/status.py +++ b/roborock/devices/traits/v1/status.py @@ -32,6 +32,16 @@ _DPS_CONVERTER = DpsDataConverter.from_dataclass(StatusV2) +_LEGACY_WATER_LEVEL_CODES = frozenset({WaterModes.LOW.code, WaterModes.MEDIUM.code, WaterModes.HIGH.code}) + + +def _drop_legacy_water_levels(decoded_dps: dict[RoborockDataProtocol, Any]) -> dict[RoborockDataProtocol, Any]: + """Return the pushed data without a legacy water level (low, medium or high).""" + if decoded_dps.get(RoborockDataProtocol.WATER_BOX_MODE) not in _LEGACY_WATER_LEVEL_CODES: + return decoded_dps + return {key: value for key, value in decoded_dps.items() if key != RoborockDataProtocol.WATER_BOX_MODE} + + class StatusTrait(StatusV2, common.V1TraitMixin, TraitUpdateListener): """Trait for managing the status of Roborock devices. @@ -176,5 +186,9 @@ def update_from_dps(self, decoded_dps: dict[RoborockDataProtocol, Any]) -> None: This handles unsolicited status updates pushed by the device via RoborockDataProtocol codes (e.g. STATE=121, BATTERY=122). """ + # Water-slide devices push legacy level codes (201-203) while get_status + # returns slider codes, so a pushed legacy level would overwrite the real value. + if self._device_features_trait.is_water_slide_mode_supported: + decoded_dps = _drop_legacy_water_levels(decoded_dps) if _DPS_CONVERTER.update_from_dps(self, decoded_dps): self._notify_update() diff --git a/tests/devices/traits/v1/test_status.py b/tests/devices/traits/v1/test_status.py index 72274ca6..19a9c464 100644 --- a/tests/devices/traits/v1/test_status.py +++ b/tests/devices/traits/v1/test_status.py @@ -3,7 +3,7 @@ import asyncio import warnings from typing import cast -from unittest.mock import AsyncMock, call +from unittest.mock import AsyncMock, Mock, call import pytest @@ -14,6 +14,7 @@ WaterModes, get_cleaning_mode_parameters, get_current_cleaning_mode, + get_water_slide_mode_name, resolve_cleaning_mode, ) from roborock.data import SHORT_MODEL_TO_ENUM, HomeDataDevice, RoborockProductNickname @@ -917,6 +918,52 @@ def test_update_from_dps_partial(status_trait: StatusTrait) -> None: assert status_trait.state == RoborockStateCode.charging # Unchanged +@pytest.mark.parametrize("pushed", [201, 202, 203]) +def test_update_from_dps_water_slide_ignores_legacy_levels(pushed: int) -> None: + """Legacy water level codes pushed to a water-slide device do not overwrite the slider value.""" + status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + status_trait.water_box_mode = 235 + listener = Mock() + status_trait.add_update_listener(listener) + + status_trait.update_from_dps({RoborockDataProtocol.WATER_BOX_MODE: pushed}) + + assert status_trait.water_box_mode == 235 + assert status_trait.water_mode_name == get_water_slide_mode_name(235) + listener.assert_not_called() + + +@pytest.mark.parametrize("pushed", [200, 209, 225, 245]) +def test_update_from_dps_water_slide_keeps_other_water_codes(pushed: int) -> None: + """Slider codes pushed to a water-slide device are applied.""" + status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + status_trait.water_box_mode = 235 + + status_trait.update_from_dps({RoborockDataProtocol.WATER_BOX_MODE: pushed}) + + assert status_trait.water_box_mode == pushed + + +def test_update_from_dps_water_slide_still_applies_other_fields() -> None: + """Ignoring a legacy water level does not drop other fields in the same push.""" + status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + status_trait.water_box_mode = 235 + + status_trait.update_from_dps({RoborockDataProtocol.FAN_POWER: 101, RoborockDataProtocol.WATER_BOX_MODE: 202}) + + assert status_trait.fan_power == 101 + assert status_trait.water_box_mode == 235 + + +def test_update_from_dps_without_water_slide_keeps_legacy_levels() -> None: + """Devices without the water slider use the legacy level codes.""" + status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=False) + + status_trait.update_from_dps({RoborockDataProtocol.WATER_BOX_MODE: 202}) + + assert status_trait.water_box_mode == 202 + + def test_update_listener(status_trait: StatusTrait) -> None: """Test that update listeners receive notifications.""" event = asyncio.Event() From 4bf8003dd40fbcf8977a0b951084d0cd64dc55df Mon Sep 17 00:00:00 2001 From: infy1995 Date: Tue, 17 Nov 2026 21:01:23 +0100 Subject: [PATCH 2/5] fix(v1): read back status after fan or water pushes --- roborock/devices/traits/v1/__init__.py | 27 +++++ tests/devices/traits/v1/test_init.py | 130 +++++++++++++++++++++++++ 2 files changed, 157 insertions(+) create mode 100644 tests/devices/traits/v1/test_init.py diff --git a/roborock/devices/traits/v1/__init__.py b/roborock/devices/traits/v1/__init__.py index 28c404d6..f9935a4e 100644 --- a/roborock/devices/traits/v1/__init__.py +++ b/roborock/devices/traits/v1/__init__.py @@ -52,6 +52,7 @@ HomeDataProduct Schema that is required for the field to be supported. """ +import asyncio import logging from collections.abc import Callable from dataclasses import dataclass, field, fields @@ -123,6 +124,10 @@ _LOGGER = logging.getLogger(__name__) +# Delay before reading status back after a fan power or water mode push. The +# robot never pushes the mop mode, so a read-back is needed to get it right. +_STATUS_REFRESH_DELAY = 1.0 + __all__ = [ "PropertiesApi", "camera", @@ -213,6 +218,7 @@ def __init__( self._device_cache = device_cache self._region = region self._unsub: Callable[[], None] | None = None + self._status_refresh_task: asyncio.Task[None] | None = None self._add_dps_listener = add_dps_listener self.device_features = DeviceFeaturesTrait(product, self._device_cache) @@ -265,6 +271,9 @@ def close(self) -> None: if self._unsub: self._unsub() self._unsub = None + if self._status_refresh_task: + self._status_refresh_task.cancel() + self._status_refresh_task = None def _on_dps_update(self, dps: dict[RoborockDataProtocol, Any]) -> None: """Handle incoming messages from the device. @@ -276,6 +285,24 @@ def _on_dps_update(self, dps: dict[RoborockDataProtocol, Any]) -> None: _LOGGER.debug("Received message from device: %s", dps) self.status.update_from_dps(dps) self.consumables.update_from_dps(dps) + if RoborockDataProtocol.FAN_POWER in dps or RoborockDataProtocol.WATER_BOX_MODE in dps: + self._schedule_status_refresh() + + def _schedule_status_refresh(self) -> None: + """Schedule a single debounced status read-back unless one is pending.""" + if self._status_refresh_task: + return + self._status_refresh_task = asyncio.create_task(self._refresh_status_after_push()) + + async def _refresh_status_after_push(self) -> None: + """Read status back after a short delay to pick up values that are not pushed.""" + await asyncio.sleep(_STATUS_REFRESH_DELAY) + # Clear first so a push arriving during the refresh schedules another one. + self._status_refresh_task = None + try: + await self.status.refresh() + except RoborockException as err: + _LOGGER.warning("Failed to refresh status after a push: %s", err) async def discover_features(self) -> None: """Populate any supported traits that were not initialized in __init__.""" diff --git a/tests/devices/traits/v1/test_init.py b/tests/devices/traits/v1/test_init.py new file mode 100644 index 00000000..d396dd18 --- /dev/null +++ b/tests/devices/traits/v1/test_init.py @@ -0,0 +1,130 @@ +"""Tests for the V1 trait properties API push handling.""" + +import asyncio +from collections.abc import Callable +from typing import Any +from unittest.mock import AsyncMock, Mock + +import pytest + +from roborock.data import HomeData, HomeDataDevice, HomeDataProduct +from roborock.devices.cache import DeviceCache +from roborock.devices.traits import v1 +from roborock.exceptions import RoborockException +from roborock.roborock_message import RoborockDataProtocol + +DpsListener = Callable[[dict[RoborockDataProtocol, Any]], None] + +DELAY = 0.01 +# Long enough for any scheduled read-back to have run. +SETTLE = DELAY * 8 + + +@pytest.fixture(name="refresh_delay", autouse=True) +def refresh_delay_fixture(monkeypatch: pytest.MonkeyPatch) -> float: + """Shorten the read-back delay so tests run quickly.""" + monkeypatch.setattr(v1, "_STATUS_REFRESH_DELAY", DELAY) + return DELAY + + +@pytest.fixture(name="props") +async def props_fixture( + device_info: HomeDataDevice, + products: list[HomeDataProduct], + trait_home_data: HomeData, + device_cache: DeviceCache, +) -> Any: + """Create a started properties API and expose its DPS listener as `props.push`.""" + product = next(p for p in products if p.id == device_info.product_id) + listeners: list[DpsListener] = [] + + def add_dps_listener(listener: DpsListener) -> Callable[[], None]: + listeners.append(listener) + return Mock() + + api = v1.create( + device_info.duid, + product, + trait_home_data, + AsyncMock(), + AsyncMock(), + AsyncMock(), + AsyncMock(), + add_dps_listener, + AsyncMock(), + device_cache=device_cache, + ) + api.discover_features = AsyncMock() # type: ignore[method-assign] + api.status.refresh = AsyncMock() # type: ignore[method-assign] + await api.start() + api.push = listeners[0] # type: ignore[attr-defined] + yield api + api.close() + + +async def test_fan_and_water_push_reads_status_back(props: Any) -> None: + """A fan power and water mode push triggers one status read-back.""" + props.push({RoborockDataProtocol.FAN_POWER: 101, RoborockDataProtocol.WATER_BOX_MODE: 202}) + props.status.refresh.assert_not_awaited() + + await asyncio.sleep(SETTLE) + props.status.refresh.assert_awaited_once() + + +async def test_repeated_pushes_are_debounced(props: Any) -> None: + """Several pushes before the delay elapses cause a single read-back.""" + props.push({RoborockDataProtocol.FAN_POWER: 101}) + props.push({RoborockDataProtocol.WATER_BOX_MODE: 202}) + props.push({RoborockDataProtocol.FAN_POWER: 102}) + + await asyncio.sleep(SETTLE) + props.status.refresh.assert_awaited_once() + + +async def test_unrelated_push_does_not_read_back(props: Any) -> None: + """Pushes without fan power or water mode do not refresh status.""" + props.push({RoborockDataProtocol.BATTERY: 80}) + + await asyncio.sleep(SETTLE) + props.status.refresh.assert_not_awaited() + + +async def test_refresh_failure_is_contained(props: Any) -> None: + """A failing read-back does not raise and later pushes still read back.""" + props.status.refresh.side_effect = RoborockException("boom") + props.push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.sleep(SETTLE) + assert props.status.refresh.await_count == 1 + + props.push({RoborockDataProtocol.FAN_POWER: 102}) + await asyncio.sleep(SETTLE) + assert props.status.refresh.await_count == 2 + + +async def test_close_cancels_pending_read_back(props: Any) -> None: + """Closing while a read-back is pending prevents it from running.""" + props.push({RoborockDataProtocol.FAN_POWER: 101}) + props.close() + + await asyncio.sleep(SETTLE) + props.status.refresh.assert_not_awaited() + + +async def test_push_during_refresh_schedules_another(props: Any) -> None: + """A push arriving while a read-back is running is followed by another one.""" + started = asyncio.Event() + release = asyncio.Event() + + async def slow_refresh() -> None: + started.set() + await release.wait() + + props.status.refresh.side_effect = slow_refresh + props.push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.wait_for(started.wait(), timeout=1) + + props.push({RoborockDataProtocol.WATER_BOX_MODE: 202}) + release.set() + + await asyncio.sleep(SETTLE) + assert props.status.refresh.await_count == 2 From fff268681763b6da86d807c0f582c0cd6f813a32 Mon Sep 17 00:00:00 2001 From: infy1995 Date: Tue, 17 Nov 2026 21:02:34 +0100 Subject: [PATCH 3/5] fix(v1): keep the status read-back task referenced until it finishes --- roborock/devices/traits/v1/__init__.py | 15 +++++++++++---- tests/devices/traits/v1/test_init.py | 22 ++++++++++++++++++++++ 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/roborock/devices/traits/v1/__init__.py b/roborock/devices/traits/v1/__init__.py index f9935a4e..0578bba5 100644 --- a/roborock/devices/traits/v1/__init__.py +++ b/roborock/devices/traits/v1/__init__.py @@ -218,7 +218,10 @@ def __init__( self._device_cache = device_cache self._region = region self._unsub: Callable[[], None] | None = None + # Read-back task waiting for its delay (debounce) and all live read-back + # tasks (kept referenced until done so they are not garbage collected). self._status_refresh_task: asyncio.Task[None] | None = None + self._status_refresh_tasks: set[asyncio.Task[None]] = set() self._add_dps_listener = add_dps_listener self.device_features = DeviceFeaturesTrait(product, self._device_cache) @@ -271,9 +274,10 @@ def close(self) -> None: if self._unsub: self._unsub() self._unsub = None - if self._status_refresh_task: - self._status_refresh_task.cancel() - self._status_refresh_task = None + self._status_refresh_task = None + for task in self._status_refresh_tasks: + task.cancel() + self._status_refresh_tasks.clear() def _on_dps_update(self, dps: dict[RoborockDataProtocol, Any]) -> None: """Handle incoming messages from the device. @@ -292,7 +296,10 @@ def _schedule_status_refresh(self) -> None: """Schedule a single debounced status read-back unless one is pending.""" if self._status_refresh_task: return - self._status_refresh_task = asyncio.create_task(self._refresh_status_after_push()) + task = asyncio.create_task(self._refresh_status_after_push()) + self._status_refresh_task = task + self._status_refresh_tasks.add(task) + task.add_done_callback(self._status_refresh_tasks.discard) async def _refresh_status_after_push(self) -> None: """Read status back after a short delay to pick up values that are not pushed.""" diff --git a/tests/devices/traits/v1/test_init.py b/tests/devices/traits/v1/test_init.py index d396dd18..afb01259 100644 --- a/tests/devices/traits/v1/test_init.py +++ b/tests/devices/traits/v1/test_init.py @@ -110,6 +110,28 @@ async def test_close_cancels_pending_read_back(props: Any) -> None: props.status.refresh.assert_not_awaited() +async def test_close_cancels_in_flight_read_back(props: Any) -> None: + """Closing while a read-back is running cancels it.""" + started = asyncio.Event() + cancelled = asyncio.Event() + + async def hanging_refresh() -> None: + started.set() + try: + await asyncio.Event().wait() + except asyncio.CancelledError: + cancelled.set() + raise + + props.status.refresh.side_effect = hanging_refresh + props.push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.wait_for(started.wait(), timeout=1) + + props.close() + await asyncio.wait_for(cancelled.wait(), timeout=1) + props.status.refresh.assert_awaited_once() + + async def test_push_during_refresh_schedules_another(props: Any) -> None: """A push arriving while a read-back is running is followed by another one.""" started = asyncio.Event() From 436f986e3604d793d674d94c98b9ed42c25b2038 Mon Sep 17 00:00:00 2001 From: infy1995 Date: Tue, 17 Nov 2026 21:06:39 +0100 Subject: [PATCH 4/5] fix(v1): notify status listeners after the push read-back --- roborock/devices/traits/v1/__init__.py | 20 ++-- roborock/devices/traits/v1/status.py | 7 ++ tests/devices/traits/v1/test_init.py | 159 ++++++++++++++++++------- tests/devices/traits/v1/test_status.py | 43 +++++++ 4 files changed, 176 insertions(+), 53 deletions(-) diff --git a/roborock/devices/traits/v1/__init__.py b/roborock/devices/traits/v1/__init__.py index 0578bba5..c5bdafe1 100644 --- a/roborock/devices/traits/v1/__init__.py +++ b/roborock/devices/traits/v1/__init__.py @@ -218,9 +218,9 @@ def __init__( self._device_cache = device_cache self._region = region self._unsub: Callable[[], None] | None = None - # Read-back task waiting for its delay (debounce) and all live read-back - # tasks (kept referenced until done so they are not garbage collected). - self._status_refresh_task: asyncio.Task[None] | None = None + # True while a read-back is waiting for its delay (debounce). Live read-back + # tasks are kept referenced until done so they are not garbage collected. + self._status_refresh_pending = False self._status_refresh_tasks: set[asyncio.Task[None]] = set() self._add_dps_listener = add_dps_listener @@ -274,7 +274,7 @@ def close(self) -> None: if self._unsub: self._unsub() self._unsub = None - self._status_refresh_task = None + self._status_refresh_pending = False for task in self._status_refresh_tasks: task.cancel() self._status_refresh_tasks.clear() @@ -285,6 +285,9 @@ def _on_dps_update(self, dps: dict[RoborockDataProtocol, Any]) -> None: This will notify all traits of the new values. This can be improved in the future to be dynamic when we have more traits that support dynamic updates but for now we just invoke them manually. + + A push of the fan power or water mode also schedules a debounced status + read-back, since the device never pushes the mop mode. """ _LOGGER.debug("Received message from device: %s", dps) self.status.update_from_dps(dps) @@ -294,10 +297,11 @@ def _on_dps_update(self, dps: dict[RoborockDataProtocol, Any]) -> None: def _schedule_status_refresh(self) -> None: """Schedule a single debounced status read-back unless one is pending.""" - if self._status_refresh_task: + # At most one read-back per delay window. + if self._status_refresh_pending: return + self._status_refresh_pending = True task = asyncio.create_task(self._refresh_status_after_push()) - self._status_refresh_task = task self._status_refresh_tasks.add(task) task.add_done_callback(self._status_refresh_tasks.discard) @@ -305,9 +309,9 @@ async def _refresh_status_after_push(self) -> None: """Read status back after a short delay to pick up values that are not pushed.""" await asyncio.sleep(_STATUS_REFRESH_DELAY) # Clear first so a push arriving during the refresh schedules another one. - self._status_refresh_task = None + self._status_refresh_pending = False try: - await self.status.refresh() + await self.status.refresh_and_notify() except RoborockException as err: _LOGGER.warning("Failed to refresh status after a push: %s", err) diff --git a/roborock/devices/traits/v1/status.py b/roborock/devices/traits/v1/status.py index b3d292f0..6637999e 100644 --- a/roborock/devices/traits/v1/status.py +++ b/roborock/devices/traits/v1/status.py @@ -192,3 +192,10 @@ def update_from_dps(self, decoded_dps: dict[RoborockDataProtocol, Any]) -> None: decoded_dps = _drop_legacy_water_levels(decoded_dps) if _DPS_CONVERTER.update_from_dps(self, decoded_dps): self._notify_update() + + async def refresh_and_notify(self) -> None: + """Refresh the status and notify update listeners if any value changed.""" + before = self.as_dict() + await self.refresh() + if self.as_dict() != before: + self._notify_update() diff --git a/tests/devices/traits/v1/test_init.py b/tests/devices/traits/v1/test_init.py index afb01259..01f14bf0 100644 --- a/tests/devices/traits/v1/test_init.py +++ b/tests/devices/traits/v1/test_init.py @@ -1,7 +1,7 @@ """Tests for the V1 trait properties API push handling.""" import asyncio -from collections.abc import Callable +from collections.abc import AsyncIterator, Callable from typing import Any from unittest.mock import AsyncMock, Mock @@ -16,8 +16,9 @@ DpsListener = Callable[[dict[RoborockDataProtocol, Any]], None] DELAY = 0.01 -# Long enough for any scheduled read-back to have run. +# Long enough for a read-back that should not happen to have run. SETTLE = DELAY * 8 +TIMEOUT = 1 @pytest.fixture(name="refresh_delay", autouse=True) @@ -33,8 +34,8 @@ async def props_fixture( products: list[HomeDataProduct], trait_home_data: HomeData, device_cache: DeviceCache, -) -> Any: - """Create a started properties API and expose its DPS listener as `props.push`.""" +) -> AsyncIterator[tuple[v1.PropertiesApi, DpsListener]]: + """Create a started properties API and the DPS listener it registered.""" product = next(p for p in products if p.id == device_info.product_id) listeners: list[DpsListener] = [] @@ -55,63 +56,101 @@ def add_dps_listener(listener: DpsListener) -> Callable[[], None]: device_cache=device_cache, ) api.discover_features = AsyncMock() # type: ignore[method-assign] - api.status.refresh = AsyncMock() # type: ignore[method-assign] await api.start() - api.push = listeners[0] # type: ignore[attr-defined] - yield api + yield api, listeners[0] api.close() -async def test_fan_and_water_push_reads_status_back(props: Any) -> None: +@pytest.fixture(name="read_back") +def read_back_fixture(props: tuple[v1.PropertiesApi, DpsListener]) -> asyncio.Event: + """Mock the status read-back and return an event set each time it runs.""" + api, _ = props + ran = asyncio.Event() + + async def refresh() -> None: + ran.set() + + api.status.refresh_and_notify = AsyncMock(side_effect=refresh) # type: ignore[method-assign] + return ran + + +async def test_fan_and_water_push_reads_status_back( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """A fan power and water mode push triggers one status read-back.""" - props.push({RoborockDataProtocol.FAN_POWER: 101, RoborockDataProtocol.WATER_BOX_MODE: 202}) - props.status.refresh.assert_not_awaited() + api, push = props + push({RoborockDataProtocol.FAN_POWER: 101, RoborockDataProtocol.WATER_BOX_MODE: 202}) + api.status.refresh_and_notify.assert_not_awaited() # type: ignore[attr-defined] + await asyncio.wait_for(read_back.wait(), timeout=TIMEOUT) await asyncio.sleep(SETTLE) - props.status.refresh.assert_awaited_once() + api.status.refresh_and_notify.assert_awaited_once() # type: ignore[attr-defined] -async def test_repeated_pushes_are_debounced(props: Any) -> None: +async def test_repeated_pushes_are_debounced( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """Several pushes before the delay elapses cause a single read-back.""" - props.push({RoborockDataProtocol.FAN_POWER: 101}) - props.push({RoborockDataProtocol.WATER_BOX_MODE: 202}) - props.push({RoborockDataProtocol.FAN_POWER: 102}) + api, push = props + push({RoborockDataProtocol.FAN_POWER: 101}) + push({RoborockDataProtocol.WATER_BOX_MODE: 202}) + push({RoborockDataProtocol.FAN_POWER: 102}) + await asyncio.wait_for(read_back.wait(), timeout=TIMEOUT) await asyncio.sleep(SETTLE) - props.status.refresh.assert_awaited_once() + api.status.refresh_and_notify.assert_awaited_once() # type: ignore[attr-defined] -async def test_unrelated_push_does_not_read_back(props: Any) -> None: +async def test_unrelated_push_does_not_read_back( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """Pushes without fan power or water mode do not refresh status.""" - props.push({RoborockDataProtocol.BATTERY: 80}) + api, push = props + push({RoborockDataProtocol.BATTERY: 80}) await asyncio.sleep(SETTLE) - props.status.refresh.assert_not_awaited() + api.status.refresh_and_notify.assert_not_awaited() # type: ignore[attr-defined] -async def test_refresh_failure_is_contained(props: Any) -> None: +async def test_refresh_failure_is_contained( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """A failing read-back does not raise and later pushes still read back.""" - props.status.refresh.side_effect = RoborockException("boom") - props.push({RoborockDataProtocol.FAN_POWER: 101}) - await asyncio.sleep(SETTLE) - assert props.status.refresh.await_count == 1 + api, push = props + refresh = api.status.refresh_and_notify + ran = asyncio.Event() - props.push({RoborockDataProtocol.FAN_POWER: 102}) - await asyncio.sleep(SETTLE) - assert props.status.refresh.await_count == 2 + async def failing_refresh() -> None: + ran.set() + raise RoborockException("boom") + + refresh.side_effect = failing_refresh # type: ignore[attr-defined] + push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.wait_for(ran.wait(), timeout=TIMEOUT) + + ran.clear() + push({RoborockDataProtocol.FAN_POWER: 102}) + await asyncio.wait_for(ran.wait(), timeout=TIMEOUT) + assert refresh.await_count == 2 # type: ignore[attr-defined] -async def test_close_cancels_pending_read_back(props: Any) -> None: +async def test_close_cancels_pending_read_back( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """Closing while a read-back is pending prevents it from running.""" - props.push({RoborockDataProtocol.FAN_POWER: 101}) - props.close() + api, push = props + push({RoborockDataProtocol.FAN_POWER: 101}) + api.close() await asyncio.sleep(SETTLE) - props.status.refresh.assert_not_awaited() + api.status.refresh_and_notify.assert_not_awaited() # type: ignore[attr-defined] -async def test_close_cancels_in_flight_read_back(props: Any) -> None: +async def test_close_cancels_in_flight_read_back( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """Closing while a read-back is running cancels it.""" + api, push = props started = asyncio.Event() cancelled = asyncio.Event() @@ -123,30 +162,60 @@ async def hanging_refresh() -> None: cancelled.set() raise - props.status.refresh.side_effect = hanging_refresh - props.push({RoborockDataProtocol.FAN_POWER: 101}) - await asyncio.wait_for(started.wait(), timeout=1) + api.status.refresh_and_notify.side_effect = hanging_refresh # type: ignore[attr-defined] + push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.wait_for(started.wait(), timeout=TIMEOUT) - props.close() - await asyncio.wait_for(cancelled.wait(), timeout=1) - props.status.refresh.assert_awaited_once() + api.close() + await asyncio.wait_for(cancelled.wait(), timeout=TIMEOUT) + api.status.refresh_and_notify.assert_awaited_once() # type: ignore[attr-defined] -async def test_push_during_refresh_schedules_another(props: Any) -> None: +async def test_push_during_refresh_schedules_another( + props: tuple[v1.PropertiesApi, DpsListener], read_back: asyncio.Event +) -> None: """A push arriving while a read-back is running is followed by another one.""" + api, push = props started = asyncio.Event() release = asyncio.Event() + second_ran = asyncio.Event() + calls = 0 async def slow_refresh() -> None: + nonlocal calls + calls += 1 + if calls == 2: + second_ran.set() + return started.set() await release.wait() - props.status.refresh.side_effect = slow_refresh - props.push({RoborockDataProtocol.FAN_POWER: 101}) - await asyncio.wait_for(started.wait(), timeout=1) + api.status.refresh_and_notify.side_effect = slow_refresh # type: ignore[attr-defined] + push({RoborockDataProtocol.FAN_POWER: 101}) + await asyncio.wait_for(started.wait(), timeout=TIMEOUT) - props.push({RoborockDataProtocol.WATER_BOX_MODE: 202}) + push({RoborockDataProtocol.WATER_BOX_MODE: 202}) release.set() - await asyncio.sleep(SETTLE) - assert props.status.refresh.await_count == 2 + await asyncio.wait_for(second_ran.wait(), timeout=TIMEOUT) + assert calls == 2 + + +async def test_read_back_notifies_status_listeners(props: tuple[v1.PropertiesApi, DpsListener]) -> None: + """Status listeners hear about values changed by the read-back.""" + api, push = props + changed = asyncio.Event() + listener = Mock(side_effect=lambda: changed.set()) + api.status.add_update_listener(listener) + + async def refresh() -> None: + api.status.mop_mode = 301 + + api.status.refresh = AsyncMock(side_effect=refresh) # type: ignore[method-assign] + push({RoborockDataProtocol.WATER_BOX_MODE: 202}) + # The push itself notifies once; the read-back's change is the second call. + changed.clear() + + await asyncio.wait_for(changed.wait(), timeout=TIMEOUT) + assert api.status.mop_mode == 301 + assert listener.call_count == 2 diff --git a/tests/devices/traits/v1/test_status.py b/tests/devices/traits/v1/test_status.py index 19a9c464..d553f8d3 100644 --- a/tests/devices/traits/v1/test_status.py +++ b/tests/devices/traits/v1/test_status.py @@ -1003,3 +1003,46 @@ def test_update_listener_ignores_unrelated(status_trait: StatusTrait) -> None: assert not event.is_set() unsubscribe() + + +async def test_refresh_and_notify_notifies_when_values_changed( + status_trait: StatusTrait, mock_rpc_channel: AsyncMock +) -> None: + """Listeners hear about water and mop route values that changed in the read-back.""" + status_trait.water_box_mode = 202 + status_trait.mop_mode = 300 + listener = Mock() + status_trait.add_update_listener(listener) + mock_rpc_channel.send_command.return_value = [{**STATUS, "water_box_mode": 203, "mop_mode": 301}] + + await status_trait.refresh_and_notify() + + assert status_trait.water_box_mode == 203 + assert status_trait.mop_mode == 301 + listener.assert_called_once_with() + + +async def test_refresh_and_notify_silent_when_nothing_changed( + status_trait: StatusTrait, mock_rpc_channel: AsyncMock +) -> None: + """Listeners are not called when the read-back matches the current state.""" + mock_rpc_channel.send_command.return_value = [STATUS] + await status_trait.refresh() + listener = Mock() + status_trait.add_update_listener(listener) + + await status_trait.refresh_and_notify() + + listener.assert_not_called() + + +async def test_refresh_and_notify_propagates_exception(status_trait: StatusTrait, mock_rpc_channel: AsyncMock) -> None: + """Errors from the read-back reach the caller and do not notify.""" + listener = Mock() + status_trait.add_update_listener(listener) + mock_rpc_channel.send_command.side_effect = RoborockException("boom") + + with pytest.raises(RoborockException): + await status_trait.refresh_and_notify() + + listener.assert_not_called() From 67ef4b7e60ee4d49834217df934e9fe6fba3223e Mon Sep 17 00:00:00 2001 From: infy1995 Date: Tue, 17 Nov 2026 21:23:47 +0100 Subject: [PATCH 5/5] fix(v1): ignore any pushed water code the slider cannot name --- roborock/devices/traits/v1/status.py | 20 +++++++++++++------- tests/devices/traits/v1/test_status.py | 15 ++++++++------- 2 files changed, 21 insertions(+), 14 deletions(-) diff --git a/roborock/devices/traits/v1/status.py b/roborock/devices/traits/v1/status.py index 6637999e..344e8e44 100644 --- a/roborock/devices/traits/v1/status.py +++ b/roborock/devices/traits/v1/status.py @@ -32,12 +32,18 @@ _DPS_CONVERTER = DpsDataConverter.from_dataclass(StatusV2) -_LEGACY_WATER_LEVEL_CODES = frozenset({WaterModes.LOW.code, WaterModes.MEDIUM.code, WaterModes.HIGH.code}) +# Non-slider codes that water-slide devices report as valid (custom and smart mode). +_WATER_MODE_CODES_KEPT = frozenset({WaterModes.CUSTOMIZED.code, WaterModes.SMART_MODE.code}) -def _drop_legacy_water_levels(decoded_dps: dict[RoborockDataProtocol, Any]) -> dict[RoborockDataProtocol, Any]: - """Return the pushed data without a legacy water level (low, medium or high).""" - if decoded_dps.get(RoborockDataProtocol.WATER_BOX_MODE) not in _LEGACY_WATER_LEVEL_CODES: +def _drop_unresolvable_water_level(decoded_dps: dict[RoborockDataProtocol, Any]) -> dict[RoborockDataProtocol, Any]: + """Return the pushed data without a water code a water-slide device cannot name. + + Water-slide devices push legacy codes (201-203, 208) that get_status never + returns. Only slider codes, off, smart water, smart mode and custom are kept. + """ + code = decoded_dps.get(RoborockDataProtocol.WATER_BOX_MODE) + if code is None or code in _WATER_MODE_CODES_KEPT or get_water_slide_mode_name(code) is not None: return decoded_dps return {key: value for key, value in decoded_dps.items() if key != RoborockDataProtocol.WATER_BOX_MODE} @@ -186,10 +192,10 @@ def update_from_dps(self, decoded_dps: dict[RoborockDataProtocol, Any]) -> None: This handles unsolicited status updates pushed by the device via RoborockDataProtocol codes (e.g. STATE=121, BATTERY=122). """ - # Water-slide devices push legacy level codes (201-203) while get_status - # returns slider codes, so a pushed legacy level would overwrite the real value. + # Water-slide devices push legacy codes (e.g. 201-203, 208) while get_status + # returns slider codes, so a pushed legacy code would overwrite the real value. if self._device_features_trait.is_water_slide_mode_supported: - decoded_dps = _drop_legacy_water_levels(decoded_dps) + decoded_dps = _drop_unresolvable_water_level(decoded_dps) if _DPS_CONVERTER.update_from_dps(self, decoded_dps): self._notify_update() diff --git a/tests/devices/traits/v1/test_status.py b/tests/devices/traits/v1/test_status.py index d553f8d3..c8d339b0 100644 --- a/tests/devices/traits/v1/test_status.py +++ b/tests/devices/traits/v1/test_status.py @@ -918,9 +918,9 @@ def test_update_from_dps_partial(status_trait: StatusTrait) -> None: assert status_trait.state == RoborockStateCode.charging # Unchanged -@pytest.mark.parametrize("pushed", [201, 202, 203]) -def test_update_from_dps_water_slide_ignores_legacy_levels(pushed: int) -> None: - """Legacy water level codes pushed to a water-slide device do not overwrite the slider value.""" +@pytest.mark.parametrize("pushed", [201, 202, 203, 208, 251, 999]) +def test_update_from_dps_water_slide_ignores_unresolvable_water_codes(pushed: int) -> None: + """Water codes the slider cannot name do not overwrite the slider value.""" status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) status_trait.water_box_mode = 235 listener = Mock() @@ -933,7 +933,7 @@ def test_update_from_dps_water_slide_ignores_legacy_levels(pushed: int) -> None: listener.assert_not_called() -@pytest.mark.parametrize("pushed", [200, 209, 225, 245]) +@pytest.mark.parametrize("pushed", [200, WaterModes.CUSTOMIZED.code, 209, 221, 225, 245, 250]) def test_update_from_dps_water_slide_keeps_other_water_codes(pushed: int) -> None: """Slider codes pushed to a water-slide device are applied.""" status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) @@ -955,13 +955,14 @@ def test_update_from_dps_water_slide_still_applies_other_fields() -> None: assert status_trait.water_box_mode == 235 -def test_update_from_dps_without_water_slide_keeps_legacy_levels() -> None: +@pytest.mark.parametrize("pushed", [201, 202, 203, 208]) +def test_update_from_dps_without_water_slide_keeps_legacy_levels(pushed: int) -> None: """Devices without the water slider use the legacy level codes.""" status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=False) - status_trait.update_from_dps({RoborockDataProtocol.WATER_BOX_MODE: 202}) + status_trait.update_from_dps({RoborockDataProtocol.WATER_BOX_MODE: pushed}) - assert status_trait.water_box_mode == 202 + assert status_trait.water_box_mode == pushed def test_update_listener(status_trait: StatusTrait) -> None: