chore: add testing

Author: Lash-L

roborock/data/code_mappings.py

@@ -3,7 +3,7 @@
 import logging
 from collections import namedtuple
 from enum import Enum, IntEnum, StrEnum
-from typing import Self
+from typing import Any, Self
 
 _LOGGER = logging.getLogger(__name__)
 completed_warnings = set()
@@ -104,6 +104,13 @@ def keys(cls) -> list[str]:
         """Returns a list of all member values."""
         return [member.value for member in cls]
 
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str):
+            return self.value == other or self.name == other
+        if isinstance(other, int):
+            return self.code == other
+        return super().__eq__(other)
+
 
 ProductInfo = namedtuple("ProductInfo", ["nickname", "short_models"])
 

roborock/devices/traits/v1/__init__.py

@@ -190,14 +190,13 @@ def __init__(
         self._device_cache = device_cache
         self._region = region
 
-        self.device_features = DeviceFeaturesTrait(product.product_nickname, self._device_cache)
+        self.device_features = DeviceFeaturesTrait(product, self._device_cache)
         self.status = StatusTrait(self.device_features, region=self._region)
         self.consumables = ConsumableTrait()
         self.rooms = RoomsTrait(home_data)
         self.maps = MapsTrait(self.status)
         self.map_content = MapContentTrait(map_parser_config)
         self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, self._device_cache)
-        self.device_features = DeviceFeaturesTrait(product, self._device_cache)
         self.network_info = NetworkInfoTrait(device_uid, self._device_cache)
         self.routines = RoutinesTrait(device_uid, web_api)
 

roborock/devices/traits/v1/status.py

@@ -25,23 +25,23 @@ def fan_speed_options(self) -> list[VacuumModes]:
 
     @cached_property
     def fan_speed_mapping(self) -> dict[int, str]:
-        return {fan.code: fan.name for fan in self.fan_speed_options}
+        return {fan.code: fan.value for fan in self.fan_speed_options}
 
     @cached_property
     def water_mode_options(self) -> list[WaterModes]:
         return get_water_modes(self._device_features_trait)
 
     @cached_property
     def water_mode_mapping(self) -> dict[int, str]:
-        return {mop.code: mop.name for mop in self.water_mode_options}
+        return {mop.code: mop.value for mop in self.water_mode_options}
 
     @cached_property
     def mop_route_options(self) -> list[CleanRoutes]:
         return get_clean_routes(self._device_features_trait, self._region or "us")
 
     @cached_property
     def mop_route_mapping(self) -> dict[int, str]:
-        return {route.code: route.name for route in self.mop_route_options}
+        return {route.code: route.value for route in self.mop_route_options}
 
     @property
     def fan_speed_name(self) -> str | None:

tests/data/v1/test_v1_containers.py

@@ -12,7 +12,15 @@
     RoborockMopModeS7,
     RoborockStateCode,
 )
-from roborock.data.v1.v1_containers import AppInitStatus, CleanRecord, CleanSummary, Consumable, DnDTimer, S7MaxVStatus
+from roborock.data.v1.v1_containers import (
+    AppInitStatus,
+    CleanRecord,
+    CleanSummary,
+    Consumable,
+    DnDTimer,
+    S7MaxVStatus,
+    StatusV2,
+)
 from tests.mock_data import (
     CLEAN_RECORD,
     CLEAN_SUMMARY,
@@ -101,6 +109,45 @@ def test_current_map() -> None:
     assert not s.current_map
 
 
+def test_status_v2() -> None:
+    """Test that StatusV2 can be created from a dictionary."""
+    s = StatusV2.from_dict(STATUS)
+    assert s.msg_ver == 2
+    assert s.msg_seq == 458
+    assert s.state == RoborockStateCode.charging
+    assert s.battery == 100
+    assert s.clean_time == 1176
+    assert s.clean_area == 20965000
+    assert s.square_meter_clean_area == 21.0
+    assert s.error_code == RoborockErrorCode.none
+    assert s.error_code_name == "none"
+    assert s.state_name == "charging"
+    assert s.map_present == 1
+    assert s.in_cleaning == 0
+    assert s.fan_power == 102
+    assert s.water_box_mode == 203
+    assert s.mop_mode == 300
+    assert s.dock_type == RoborockDockTypeCode.empty_wash_fill_dock
+    assert s.dock_error_status == RoborockDockErrorCode.ok
+    assert s.current_map == 0
+
+
+def test_status_v2_current_map() -> None:
+    """Test the current map logic based on map status for StatusV2."""
+    s = StatusV2.from_dict(STATUS)
+    assert s.map_status == 3
+    assert s.current_map == 0
+
+    s.map_status = 7
+    assert s.current_map == 1
+
+    s.map_status = 11
+    assert s.current_map == 2
+
+    s.map_status = None
+    assert s.current_map is None
+
+
 def test_dnd_timer():
     dnd = DnDTimer.from_dict(DND_TIMER)
     assert dnd.start_hour == 22

tests/devices/__snapshots__/test_v1_device.ambr

@@ -832,7 +832,7 @@
   })
 # ---
 # name: test_device_trait_command_parsing[status]
-  StatusTrait(adbumper_status=None, auto_dust_collection=None, avoid_count=None, back_type=None, battery=100, camera_status=None, charge_status=None, clean_area=91287500, clean_fluid_status=None, clean_percent=None, clean_time=5405, clear_water_box_status=None, collision_avoid_status=None, command=<RoborockCommand.GET_STATUS: 'get_status'>, common_status=None, corner_clean_mode=None, current_map=0, debug_mode=None, dirty_water_box_status=None, distance_off=0, dnd_enabled=1, dock_cool_fan_status=None, dock_error_status=None, dock_type=None, dry_status=None, dss=None, dust_bag_status=None, dust_collection_status=None, error_code=<RoborockErrorCode.none: 0>, error_code_name='none', fan_power=106, fan_speed_mapping={101: 'QUIET', 102: 'BALANCED', 103: 'TURBO', 104: 'MAX', 105: 'GENTLE'}, fan_speed_name=None, fan_speed_options=[<VacuumModes.QUIET: 'quiet'>, <VacuumModes.BALANCED: 'balanced'>, <VacuumModes.TURBO: 'turbo'>, <VacuumModes.MAX: 'max'>, <VacuumModes.GENTLE: 'gentle'>], hatch_door_status=None, home_sec_enable_password=None, home_sec_status=None, in_cleaning=<RoborockInCleaning.complete: 0>, in_fresh_state=1, in_returning=0, in_warmup=None, is_exploring=None, is_locating=0, kct=None, lab_status=1, last_clean_t=None, lock_status=0, map_present=1, map_status=3, mop_forbidden_enable=0, mop_mode=None, mop_route_mapping={300: 'STANDARD', 301: 'DEEP'}, mop_route_name=None, mop_route_options=[<CleanRoutes.STANDARD: 'standard'>, <CleanRoutes.DEEP: 'deep'>], msg_seq=515, msg_ver=2, rdt=None, repeat=None, replenish_mode=None, rss=None, square_meter_clean_area=91.3, state=<RoborockStateCode.charging: 8>, state_name='charging', subdivision_sets=None, switch_map_mode=None, unsave_map_flag=0, unsave_map_reason=4, wash_phase=None, wash_ready=None, wash_status=None, water_box_carriage_status=0, water_box_filter_status=None, water_box_mode=204, water_box_status=0, water_mode_mapping={200: 'OFF', 201: 'LOW', 202: 'MEDIUM', 203: 'HIGH'}, water_mode_name=None, water_mode_options=[<WaterModes.OFF: 'off'>, <WaterModes.LOW: 'low'>, <WaterModes.MEDIUM: 'medium'>, <WaterModes.HIGH: 'high'>], water_shortage_status=None)
+  StatusTrait(adbumper_status=None, auto_dust_collection=None, avoid_count=None, back_type=None, battery=100, camera_status=None, charge_status=None, clean_area=91287500, clean_fluid_status=None, clean_percent=None, clean_time=5405, clear_water_box_status=None, collision_avoid_status=None, command=<RoborockCommand.GET_STATUS: 'get_status'>, common_status=None, corner_clean_mode=None, current_map=0, debug_mode=None, dirty_water_box_status=None, distance_off=0, dnd_enabled=1, dock_cool_fan_status=None, dock_error_status=None, dock_type=None, dry_status=None, dss=None, dust_bag_status=None, dust_collection_status=None, error_code=<RoborockErrorCode.none: 0>, error_code_name='none', fan_power=106, fan_speed_mapping={101: 'quiet', 102: 'balanced', 103: 'turbo', 104: 'max', 108: 'max_plus', 105: 'off', 106: 'custom'}, fan_speed_name='custom', fan_speed_options=[<VacuumModes.QUIET: 'quiet'>, <VacuumModes.BALANCED: 'balanced'>, <VacuumModes.TURBO: 'turbo'>, <VacuumModes.MAX: 'max'>, <VacuumModes.MAX_PLUS: 'max_plus'>, <VacuumModes.OFF: 'off'>, <VacuumModes.CUSTOMIZED: 'custom'>], hatch_door_status=None, home_sec_enable_password=None, home_sec_status=None, in_cleaning=<RoborockInCleaning.complete: 0>, in_fresh_state=1, in_returning=0, in_warmup=None, is_exploring=None, is_locating=0, kct=None, lab_status=1, last_clean_t=None, lock_status=0, map_present=1, map_status=3, mop_forbidden_enable=0, mop_mode=None, mop_route_mapping={300: 'standard', 301: 'deep', 302: 'custom'}, mop_route_name=None, mop_route_options=[<CleanRoutes.STANDARD: 'standard'>, <CleanRoutes.DEEP: 'deep'>, <CleanRoutes.CUSTOMIZED: 'custom'>], msg_seq=515, msg_ver=2, rdt=None, repeat=None, replenish_mode=None, rss=None, square_meter_clean_area=91.3, state=<RoborockStateCode.charging: 8>, state_name='charging', subdivision_sets=None, switch_map_mode=None, unsave_map_flag=0, unsave_map_reason=4, wash_phase=None, wash_ready=None, wash_status=None, water_box_carriage_status=0, water_box_filter_status=None, water_box_mode=204, water_box_status=0, water_mode_mapping={200: 'off', 201: 'mild', 202: 'standard', 203: 'intense', 207: 'custom_water_flow', 204: 'custom'}, water_mode_name='custom', water_mode_options=[<WaterModes.OFF: 'off'>, <WaterModes.MILD: 'mild'>, <WaterModes.STANDARD: 'standard'>, <WaterModes.INTENSE: 'intense'>, <WaterModes.CUSTOM: 'custom_water_flow'>, <WaterModes.CUSTOMIZED: 'custom'>], water_shortage_status=None)
 # ---
 # name: test_device_trait_command_parsing[status].1
   dict({

tests/devices/traits/v1/test_status.py

@@ -0,0 +1,82 @@
+"""Tests for the StatusTrait class."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from roborock.data.v1 import (
+    RoborockStateCode,
+)
+from roborock.devices.device import RoborockDevice
+from roborock.devices.traits.v1.status import StatusTrait
+from roborock.exceptions import RoborockException
+from roborock.roborock_typing import RoborockCommand
+from tests.mock_data import STATUS
+
+
+@pytest.fixture
+def status_trait(device: RoborockDevice) -> StatusTrait:
+    """Create a StatusTrait instance with mocked dependencies."""
+    assert device.v1_properties
+    return device.v1_properties.status
+
+
+async def test_refresh_status(status_trait: StatusTrait, mock_rpc_channel: AsyncMock) -> None:
+    """Test successfully refreshing status."""
+    mock_rpc_channel.send_command.return_value = [STATUS]
+
+    await status_trait.refresh()
+
+    assert status_trait.battery == 100
+    assert status_trait.state == RoborockStateCode.charging
+    assert status_trait.fan_power == 102
+    assert status_trait.fan_speed_name == "balanced"
+    assert status_trait.fan_speed_name in status_trait.fan_speed_options
+    mock_rpc_channel.send_command.assert_called_once_with(RoborockCommand.GET_STATUS)
+
+
+async def test_refresh_status_dict_response(status_trait: StatusTrait, mock_rpc_channel: AsyncMock) -> None:
+    """Test refreshing status when response is a dict instead of list."""
+    mock_rpc_channel.send_command.return_value = STATUS
+
+    await status_trait.refresh()
+
+    assert status_trait.battery == 100
+    assert status_trait.state == RoborockStateCode.charging
+    mock_rpc_channel.send_command.assert_called_once_with(RoborockCommand.GET_STATUS)
+
+
+async def test_refresh_status_propagates_exception(status_trait: StatusTrait, mock_rpc_channel: AsyncMock) -> None:
+    """Test that exceptions from RPC channel are propagated."""
+    mock_rpc_channel.send_command.side_effect = RoborockException("Communication error")
+
+    with pytest.raises(RoborockException, match="Communication error"):
+        await status_trait.refresh()
+
+
+async def test_refresh_status_invalid_format(status_trait: StatusTrait, mock_rpc_channel: AsyncMock) -> None:
+    """Test that invalid response format raises ValueError."""
+    mock_rpc_channel.send_command.return_value = "invalid"
+
+    with pytest.raises(ValueError, match="Unexpected status format"):
+        await status_trait.refresh()
+
+
+def test_none_values(status_trait: StatusTrait) -> None:
+    """Test that none values are returned correctly."""
+    status_trait.fan_power = None
+    status_trait.water_box_mode = None
+    status_trait.mop_mode = None
+    assert status_trait.fan_speed_name is None
+    assert status_trait.water_mode_name is None
+    assert status_trait.mop_route_name is None
+
+
+def test_options(status_trait: StatusTrait) -> None:
+    """Test that fan_speed_options returns a list of options."""
+    assert isinstance(status_trait.fan_speed_options, list)
+    assert len(status_trait.fan_speed_options) > 0
+    assert isinstance(status_trait.water_mode_options, list)
+    assert len(status_trait.water_mode_options) > 0
+    assert isinstance(status_trait.mop_route_options, list)
+    assert len(status_trait.mop_route_options) > 0