diff --git a/docs/V1_API_COMMANDS.md b/docs/V1_API_COMMANDS.md index 68776ef41..d77a4f511 100644 --- a/docs/V1_API_COMMANDS.md +++ b/docs/V1_API_COMMANDS.md @@ -933,9 +933,13 @@ Return example: ### set_custom_mode -Description: +Description: Set the fan speed (suction power). Used by `StatusTrait` on models that do not accept the fan speed in `set_clean_motor_mode`. See `set_clean_motor_mode` for the order the commands are sent in. -Parameters: +Parameters: Fan power code in a list, e.g. `[102]`. `105` (`VacuumModes.OFF`) turns the fan off for mop-only cleaning. + +**Supported devices:** + +* Roborock Saros 10R: ✅ (`[102]` from mop-only mode switches to vacuum and mop and resets route `301` to `300`) ### get_customize_clean_mode @@ -1170,9 +1174,9 @@ Example for S8 Pro Ultra: ### set_mop_mode -Description: Set mop mode. +Description: Set the mop route. Used by `StatusTrait` on models that do not accept `mop_mode` in `set_clean_motor_mode`. See `set_clean_motor_mode` for when it is sent. -Parameters: mop_mode 300 +Parameters: Mop route code in a list, e.g. `[300]`. **Supported devices:** @@ -1180,9 +1184,38 @@ Parameters: mop_mode 300 ### set_clean_motor_mode -Description: +Description: Set the fan speed, water mode and (on some models) mop route in one command. `StatusTrait.set_cleaning_mode`, `set_fan_speed`, `set_water_mode` and `set_mop_route` all apply a full set of codes (the settings they do not change keep their current values), and send the commands in the order the model needs (the lists were compared with the Roborock app): -Parameters: +| Model | Commands sent, in order | +| :--- | :--- | +| `is_shake_mop_set_supported` | `set_clean_motor_mode` with `fan_power`, `water_box_mode` and `mop_mode` (`mop_mode` only when a route is sent) | +| `is_set_clean_motor_mode_supported` (feature 118) | `set_clean_motor_mode` with `fan_power` and `water_box_mode`, then `set_mop_mode` when a route is sent | +| Devices without a mop (`is_support_water_mode` false) | `set_custom_mode` (fan) only, whatever the other flags say | +| Other models | `set_custom_mode` (fan), `set_water_box_custom_mode` (water), then `set_mop_mode` when a route is sent | + +A mop route is sent only when the model supports both route setting (`is_clean_route_setting_supported`) and the shake module (`is_shake_mop_set_supported`), because only models with the shake module offer a route choice. Otherwise it is only sent to leave SmartPlan or custom mode: standard `300` is sent when the current route is `306` (SmartPlan) or `302` (custom) and the target mode is not the one that already owns that route (SmartPlan for `306`, custom for `302`), so the robot is not still reported in the mode it left. In every other case the route is not sent, so `set_fan_speed`, `set_water_mode` and `set_mop_route` never send `set_mop_mode` on models without the shake module. (The legacy `get_cleaning_mode_parameters` helper still adds `mop_mode` for every model with route setting.) + +Parameters: List with a dictionary, e.g. `[{"fan_power": 102, "water_box_mode": 202}]`. `mop_mode` is added where the table says so. + +`StatusTrait.supported_cleaning_settings` (helper `get_supported_settings`) lists the cleaning settings a model has at all, independent of the current cleaning mode, so a consumer can decide which settings to offer without combining feature flags. It is the list, in the order fan speed, water mode, mop route, of the settings that are adjustable in at least one regular cleaning mode: the fan speed always; the water mode when the model has a mop (`is_support_water_mode`); the mop route when the model has a mop and the shake module (`is_shake_mop_set_supported`) and either a mop-only mode (`is_pure_clean_mop_supported`) or the fast route outside mopping (`is_clean_route_fast_mode_supported` with route setting). The `fan_speed_options`/`water_mode_options`/`mop_route_options` lists and their `_mapping` dicts are empty for a setting the model does not have (the fan speed is never empty). The cleaning mode select has no entry in the set: it exists exactly when `cleaning_mode_options` is not empty, which is the case when `is_support_water_mode` is true. Whether a setting can be changed right now is still `is_fan_speed_adjustable`, `is_water_mode_adjustable` and `is_mop_route_adjustable`. + +When the robot reports SmartPlan or custom codes (for example `106`/`204`/`302` or `110`/`209`/`306`) the adjustable, display and setter rules treat it as being in that mode, even if the model lacks the SmartPlan or custom support flags and `current_cleaning_mode` is therefore `None` (helper `get_reported_special_mode`). In that state the display options show only the SmartPlan or custom value, the settings are not adjustable and the setters raise `RoborockUnsupportedFeature`. `current_cleaning_mode` itself is unchanged. + +`StatusTrait` setters: `set_fan_speed`, `set_water_mode` and `set_mop_route` only work when the matching `is_fan_speed_adjustable`, `is_water_mode_adjustable` or `is_mop_route_adjustable` is true, and only accept the values valid in the current cleaning mode, which are the same values that `fan_speed_display_options`, `water_mode_display_options` and `mop_route_display_options` list (`fan_speed_options`, `water_mode_options` and `mop_route_options` stay the model's full lists). SmartPlan, custom and unknown modes, and values that are not offered in the current mode, raise `RoborockUnsupportedFeature`; nothing is sent. They raise `RoborockException` when the status has not been loaded yet. Water slide codes `221`-`250` are accepted when the model supports water slide mode. After the commands succeed the local status fields are updated. Devices without a mop (`is_support_water_mode` false) have no water mode: `set_fan_speed` only needs the fan power loaded and sends only `set_custom_mode`. + +The lists depend on the cleaning mode, following the mode tabs of the robot settings: + +| Setting | Offered values | +|---|---| +| Fan speed | Not offered in mop-only mode (mop-only mode always sends fan code `105`). Max+ (`108`) only in vacuum-only mode with `is_max_plus_mode_supported`, never in vacuum and mop. On devices without mode tabs (`is_pure_clean_mop_supported` false) Max+ is offered in every mode with `is_none_pure_clean_mop_with_max_plus`. | +| Water mode | The model's list in every mode where it is offered, without `off` (`200`) when the device has a mop-only tab (`is_pure_clean_mop_supported`). Devices without a mop-only tab have one general tab: the water mode is adjustable in every regular mode, so a water-off state (classified as vacuum) can still turn the water on. | +| Mop route | Needs `is_shake_mop_set_supported`, and outside mop-only mode also `is_clean_route_fast_mode_supported` and `is_clean_route_setting_supported`. In vacuum and mop and in vacuum only only fast (`304`) and standard (`300`); in mop-only mode, and on devices without mode tabs, the model's full list. With `is_clean_efficiency_supported` the full list (which never contains deep, `301`) in every mode, with `is_none_pure_clean_mop_with_max_plus` fast and standard in every mode. | + +Values left over from another tab (for example by an older client) are not sent on: `set_fan_speed`, `set_water_mode`, `set_mop_route` and `set_cleaning_mode` replace a fan speed that is not on the mode's list, such as Max+ (`108`) outside vacuum-only mode or the mop-only code `105` left over outside mop-only mode, with balanced (`102`), and a route that is not on the tab's route list with standard (`300`). The route is replaced even when it is not adjustable in the mode, but only when a route is sent at all (see above); the tab's list is the model's full list where the full list is offered and fast and standard otherwise. The robot rejects deep (`301`) in vacuum and mop with error `-10005`. A setting the device does not have (for example the mop route without route setting) always lists nothing, even in SmartPlan or custom mode; the same holds for the mop route without the shake module. In SmartPlan and custom mode only the SmartPlan or custom value is listed. + +**Supported devices:** + +* Roborock Saros 10R: ✅ (one command with `fan_power`, `water_box_mode` and `mop_mode`; tested in every cleaning mode, including SmartPlan `110`/`209`/`306` and custom `106`/`204`/`302`; deep route `301` returns `-10005` in vacuum and mop) ### get_dust_collection_mode @@ -1751,7 +1784,7 @@ Parameters: None Description: Set the water box / mopping water flow mode. Setting mode `200` turns off water dispensing completely (used for vacuum-only cleaning). To perform mop-only cleaning without vacuuming, pair water mode with turning off the vacuum fan (`set_custom_mode` to `105` / `VacuumModes.OFF`). -Parameters: Integer mode code inside a list or dictionary, e.g. `[200]` or `{'water_box_mode': 200}`. +Parameters: Integer mode code inside a list or dictionary, e.g. `[200]` or `{'water_box_mode': 200}`. On models with water slide support the code can also be in the range `221`-`250`. Models that accept `water_box_mode` in `set_clean_motor_mode` use that command instead, see `set_clean_motor_mode`. CLI Example: diff --git a/docs/V1_DEVICE_FEATURES.md b/docs/V1_DEVICE_FEATURES.md index f9b0b9e10..a90b23a31 100644 --- a/docs/V1_DEVICE_FEATURES.md +++ b/docs/V1_DEVICE_FEATURES.md @@ -1227,6 +1227,14 @@ These features are encoded as individual bits in the `new_feature_info_str` hex These features are checked by verifying if the feature ID exists in the `feature_info` array. +### is_set_clean_motor_mode_supported +**Feature ID:** 118 +**Feature:** Set Clean Motor Mode +**Description:** Models with this flag accept `fan_power` and `water_box_mode` together in `set_clean_motor_mode`; the route goes in `set_mop_mode`. Models with `is_shake_mop_set_supported` send all three in `set_clean_motor_mode`. Other models use `set_custom_mode`, `set_water_box_custom_mode` and `set_mop_mode`. +**Impact:** Decides which commands are used to change the fan speed, water mode and cleaning mode. + +--- + ### is_led_status_switch_supported **Feature ID:** 119 **Feature:** LED Status Switch @@ -1296,7 +1304,8 @@ These features are enabled/disabled based on specific device model whitelists or --- ### is_soft_clean_mode_supported -**Model Whitelist:** TANOSV, TANOSE, TANOS +**Model Whitelist:** TANOSV, TANOSE, TANOS, RUBYSC, RUBYSLITE, RUBYSE +**Source:** Roborock app `isSoftCleanModeSupportedInMain` **Feature:** Soft Clean Mode **Description:** Gentle cleaning mode for delicate floors. **Impact:** Reduced suction and brush speed for sensitive surfaces. @@ -1304,7 +1313,8 @@ These features are enabled/disabled based on specific device model whitelists or --- ### is_custom_mode_supported -**Model Blacklist:** TANOS (all except TANOS) +**Model Blacklist:** TANOS, RUBYPLUS, RUBYSC, RUBYSE (all except these) +**Source:** Roborock app `isCustomModeSupported` **Feature:** Custom Cleaning Mode **Description:** User-defined custom cleaning modes. **Impact:** Create personalized cleaning modes with specific parameters. diff --git a/roborock/data/v1/v1_clean_modes.py b/roborock/data/v1/v1_clean_modes.py index 7d1e1fe05..7c92b10c3 100644 --- a/roborock/data/v1/v1_clean_modes.py +++ b/roborock/data/v1/v1_clean_modes.py @@ -2,9 +2,10 @@ import typing from enum import StrEnum -from typing import TypeVar +from typing import TypeVar, cast from ...exceptions import RoborockUnsupportedFeature +from ...roborock_typing import RoborockCommand from ..code_mappings import RoborockModeEnum if typing.TYPE_CHECKING: @@ -115,6 +116,22 @@ class CleaningMode(StrEnum): ModeEnumT = TypeVar("ModeEnumT", bound=RoborockModeEnum) +class CleaningSetting(StrEnum): + """A cleaning setting that can be changed independently of the high-level mode.""" + + FAN_SPEED = "fan_speed" + WATER_MODE = "water_mode" + MOP_ROUTE = "mop_route" + + +# SmartPlan and custom values of each setting, shown while the cleaning mode locks the setting. +_SMART_AND_CUSTOM_VALUES: dict[CleaningSetting, tuple[RoborockModeEnum, RoborockModeEnum]] = { + CleaningSetting.FAN_SPEED: (VacuumModes.SMART_MODE, VacuumModes.CUSTOMIZED), + CleaningSetting.WATER_MODE: (WaterModes.SMART_MODE, WaterModes.CUSTOMIZED), + CleaningSetting.MOP_ROUTE: (CleanRoutes.SMART_MODE, CleanRoutes.CUSTOMIZED), +} + + def get_wash_towel_modes(features: DeviceFeatures) -> list[WashTowelModes]: """Get the valid wash towel modes for the device""" modes = [WashTowelModes.LIGHT, WashTowelModes.BALANCED, WashTowelModes.DEEP] @@ -131,16 +148,8 @@ def get_clean_modes(features: DeviceFeatures) -> list[VacuumModes]: if features.is_max_plus_mode_supported or features.is_none_pure_clean_mop_with_max_plus: # If the vacuum has max plus mode supported modes.append(VacuumModes.MAX_PLUS) - if features.is_pure_clean_mop_supported: - # If the vacuum is capable of 'pure mop clean' aka no vacuum - modes.append(VacuumModes.OFF) - else: - # If not, we can add gentle + if features.is_soft_clean_mode_supported: modes.append(VacuumModes.GENTLE) - if features.is_smart_clean_mode_set_supported: - modes.append(VacuumModes.SMART_MODE) - if features.is_customized_clean_supported: - modes.append(VacuumModes.CUSTOMIZED) return modes @@ -165,10 +174,6 @@ def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes] if features.is_clean_route_fast_mode_supported: supported.append(CleanRoutes.FAST) - if features.is_smart_clean_mode_set_supported: - supported.append(CleanRoutes.SMART_MODE) - if features.is_customized_clean_supported: - supported.append(CleanRoutes.CUSTOMIZED) return supported @@ -190,14 +195,173 @@ def get_water_modes(features: DeviceFeatures) -> list[WaterModes]: supported_modes.append(WaterModes.CUSTOM) if features.is_mop_shake_module_supported and features.is_mop_shake_water_max_supported: supported_modes.append(WaterModes.EXTREME) - if features.is_smart_clean_mode_set_supported: - supported_modes.append(WaterModes.SMART_MODE) - if features.is_customized_clean_supported: - supported_modes.append(WaterModes.CUSTOMIZED) return supported_modes +def get_adjustable_settings(mode: CleaningMode | None, features: DeviceFeatures) -> frozenset[CleaningSetting]: + """Return the cleaning settings the user can change while the given cleaning mode is active. + + SmartPlan and custom modes decide every setting themselves. A mode of None means + the current mode is unknown: devices without a mop only have the fan speed, + otherwise the cleaning mode has to be chosen first. The mop route + needs the shake module (only those models offer a route choice), and outside mopping only also the fast route. + """ + if mode is None: + return frozenset() if features.is_support_water_mode else frozenset({CleaningSetting.FAN_SPEED}) + if mode in (CleaningMode.SMART_MODE, CleaningMode.CUSTOM): + return frozenset() + settings: set[CleaningSetting] = set() + if mode in (CleaningMode.VACUUM, CleaningMode.VAC_AND_MOP): + settings.add(CleaningSetting.FAN_SPEED) + # Models without a mop-only mode have one general setting group that includes water in every regular mode. + has_water_tab = mode in (CleaningMode.VAC_AND_MOP, CleaningMode.MOP) or not features.is_pure_clean_mop_supported + if has_water_tab and features.is_support_water_mode: + settings.add(CleaningSetting.WATER_MODE) + if features.is_shake_mop_set_supported and ( + mode == CleaningMode.MOP + or (features.is_clean_route_fast_mode_supported and features.is_clean_route_setting_supported) + ): + settings.add(CleaningSetting.MOP_ROUTE) + return frozenset(settings) + + +def get_supported_settings(features: DeviceFeatures) -> frozenset[CleaningSetting]: + """Return the cleaning settings the model has at all, whatever the current cleaning mode. + + This is the set of settings that can be adjusted in at least one regular cleaning + mode. The fan speed is on every model. The water mode needs a mop module. The mop + route needs water mode, the shake module, and either the mop-only tab or fast mode + with the route setting. + """ + settings = {CleaningSetting.FAN_SPEED} + if not features.is_support_water_mode: + return frozenset(settings) + settings.add(CleaningSetting.WATER_MODE) + if features.is_shake_mop_set_supported and ( + features.is_pure_clean_mop_supported + or (features.is_clean_route_fast_mode_supported and features.is_clean_route_setting_supported) + ): + settings.add(CleaningSetting.MOP_ROUTE) + return frozenset(settings) + + +def get_mode_options( + setting: CleaningSetting, + mode: CleaningMode | None, + features: DeviceFeatures, + options: list[ModeEnumT], +) -> list[ModeEnumT]: + """Return the values of a setting that are offered in the given cleaning mode. + + The options are the values the model supports for the setting (the *_options lists). + This keeps the values valid in that mode: Max+ only in vacuum only (or on devices + without tabs, by the other flag), the short route list outside mopping only, and no water + off on devices that have a mop-only tab. The result is empty when the setting cannot be + changed in the mode. It is also the list of values the setters accept. + """ + if setting not in get_adjustable_settings(mode, features): + return [] + if setting == CleaningSetting.FAN_SPEED: + return [option for option in options if _is_fan_speed_offered(option.code, mode, features)] + if setting == CleaningSetting.WATER_MODE: + if features.is_pure_clean_mop_supported: + return [option for option in options if option.code != WaterModes.OFF.code] + return list(options) + if _offers_all_routes(mode, features): + return list(options) + return [option for option in options if option.code in (CleanRoutes.FAST.code, CleanRoutes.STANDARD.code)] + + +def _is_fan_speed_offered(code: int, mode: CleaningMode | None, features: DeviceFeatures) -> bool: + """Whether the fan speed is offered in the mode: only Max+ depends on it.""" + if code != VacuumModes.MAX_PLUS.code or mode is None: + return True + if not features.is_pure_clean_mop_supported: + return features.is_none_pure_clean_mop_with_max_plus + return mode == CleaningMode.VACUUM and features.is_max_plus_mode_supported + + +def _offers_all_routes(mode: CleaningMode | None, features: DeviceFeatures) -> bool: + """Whether the mop route list of the mode is the model's full list.""" + return ( + features.is_none_pure_clean_mop_with_max_plus # the model list is only fast and standard + or features.is_clean_efficiency_supported + or mode == CleaningMode.MOP + or not features.is_pure_clean_mop_supported + ) + + +def get_display_options( + setting: CleaningSetting, + mode: CleaningMode | None, + features: DeviceFeatures, + options: list[ModeEnumT], +) -> list[ModeEnumT]: + """Return the values of a setting to show for the current cleaning mode. + + In SmartPlan only its SmartPlan value is shown and in custom mode only its custom value. + A setting that can be changed shows the values of the mode (see get_mode_options) + and any other setting shows nothing. + A setting the device does not have (no options) always shows nothing, and so does the + mop route without the shake module, SmartPlan and custom values included. + """ + if not options: + return [] + if setting == CleaningSetting.MOP_ROUTE and not features.is_shake_mop_set_supported: + return [] + smart_value, custom_value = _SMART_AND_CUSTOM_VALUES[setting] + if mode == CleaningMode.SMART_MODE: + return [cast(ModeEnumT, smart_value)] + if mode == CleaningMode.CUSTOM: + return [cast(ModeEnumT, custom_value)] + return get_mode_options(setting, mode, features, options) + + +def get_fan_speed_name(code: int, features: DeviceFeatures) -> str | None: + """Name a fan power code: selectable modes first, then SmartPlan, custom and code 105.""" + for mode in get_clean_modes(features): + if mode.code == code: + return mode.value + if code == VacuumModes.SMART_MODE.code: + return VacuumModes.SMART_MODE.value + if code == VacuumModes.CUSTOMIZED.code: + return VacuumModes.CUSTOMIZED.value + if code == VacuumModes.GENTLE.code: + # 105 is the mop-only code on pure-mop devices and "gentle" elsewhere. + return VacuumModes.OFF.value if features.is_pure_clean_mop_supported else VacuumModes.GENTLE.value + return None + + +def get_water_mode_name(code: int, features: DeviceFeatures) -> str | None: + """Name a water box code: selectable modes (or slide ranges) first, then SmartPlan and custom.""" + if features.is_water_slide_mode_supported: + slide_mode = _resolve_water_slide_mode(code) + if slide_mode is not None: + return slide_mode.display_name + else: + for mode in get_water_modes(features): + if mode.code == code: + return mode.display_name + if code == WaterModes.SMART_MODE.code: + return WaterModes.SMART_MODE.display_name + if code == WaterModes.CUSTOMIZED.code: + return WaterModes.CUSTOMIZED.display_name + return None + + +def get_mop_route_name(code: int, features: DeviceFeatures, region: str) -> str | None: + """Name a mop route code: selectable routes first, then SmartPlan and custom.""" + for route in get_clean_routes(features, region): + if route.code == code: + return route.display_name + if code == CleanRoutes.SMART_MODE.code: + return CleanRoutes.SMART_MODE.display_name + if code == CleanRoutes.CUSTOMIZED.code: + return CleanRoutes.CUSTOMIZED.display_name + return None + + def get_water_slide_mode_name(code: int) -> str | None: """Get the app's range name for a water slide code, or None if out of range.""" mode = _resolve_water_slide_mode(code) @@ -239,13 +403,14 @@ def get_cleaning_mode_options(features: DeviceFeatures) -> list[CleaningMode]: if not features.is_support_water_mode: return [] - supported_water_modes = get_water_modes(features) options = [CleaningMode.VACUUM, CleaningMode.VAC_AND_MOP] if features.is_pure_clean_mop_supported: options.append(CleaningMode.MOP) - if features.is_customized_clean_supported and WaterModes.CUSTOMIZED in supported_water_modes: + # The customized-clean flag stays required until the app's custom switch + # condition is verified; without it electronic-mop models would gain CUSTOM. + if features.is_custom_mode_supported and features.is_customized_clean_supported: options.append(CleaningMode.CUSTOM) - if features.is_smart_clean_mode_set_supported and WaterModes.SMART_MODE in supported_water_modes: + if features.is_smart_clean_mode_set_supported: options.append(CleaningMode.SMART_MODE) return options @@ -300,11 +465,47 @@ def resolve_cleaning_mode(cleaning_mode: str | CleaningMode) -> CleaningMode: raise RoborockUnsupportedFeature(f"Cleaning mode {cleaning_mode!r} is not supported") from err +MotorModeCommand = tuple[RoborockCommand, list[int] | list[dict[str, int]]] + + +def get_cleaning_mode_codes( + mode: CleaningMode, + features: DeviceFeatures, + current_mop_mode: int | None, +) -> tuple[int, int, int | None]: + """Return the (fan_power, water_box_mode, mop_mode) codes that switch to a cleaning mode. + + The mop route is None when there is nothing to send: the device has no route + setting or no shake module (the route is only sent with it) and its current + route does not need to change. When the current route is + SmartPlan (306) or custom (302) it is reset to standard (300), so the robot is not + still recognized as being in that mode, unless the target mode is the one that + owns the current route (SmartPlan for 306, custom for 302). + """ + if mode not in get_cleaning_mode_options(features): + raise RoborockUnsupportedFeature(f"Cleaning mode {mode.value!r} is not supported") + + fan_power, water_box_mode, mop_mode = _get_clean_motor_mode_params(mode, features) + if features.is_clean_route_setting_supported and features.is_shake_mop_set_supported: + route: int | None = mop_mode.code + elif current_mop_mode == CleanRoutes.SMART_MODE.code and mode != CleaningMode.SMART_MODE: + route = CleanRoutes.STANDARD.code + elif current_mop_mode == CleanRoutes.CUSTOMIZED.code and mode != CleaningMode.CUSTOM: + route = CleanRoutes.STANDARD.code + else: + route = None + return fan_power.code, water_box_mode.code, route + + def get_cleaning_mode_parameters(cleaning_mode: CleaningMode, features: DeviceFeatures) -> list[dict[str, int]]: - """Get the RPC payload for switching the high-level cleaning mode.""" + """Get the combined set_clean_motor_mode payload for switching the high-level cleaning mode. + + This does not reflect the per-model command sequencing or the reset of the current + route; see get_motor_mode_commands and get_cleaning_mode_codes for what is sent. + """ if cleaning_mode not in get_cleaning_mode_options(features): raise RoborockUnsupportedFeature(f"Cleaning mode {cleaning_mode.value!r} is not supported") - + # Unlike get_cleaning_mode_codes this keeps the route of every model with a route setting. fan_power, water_box_mode, mop_mode = _get_clean_motor_mode_params(cleaning_mode, features) params: dict[str, int] = {"fan_power": fan_power.code, "water_box_mode": water_box_mode.code} if features.is_clean_route_setting_supported: @@ -312,6 +513,112 @@ def get_cleaning_mode_parameters(cleaning_mode: CleaningMode, features: DeviceFe return [params] +def get_motor_mode_commands( + fan_power: int, + water_box_mode: int | None, + mop_mode: int | None, + features: DeviceFeatures, +) -> list[MotorModeCommand]: + """Return the commands, in order, that apply the codes in the order the model needs. + + A device without a mop (no water mode support) only has a fan speed, so it only gets + set_custom_mode. The water mode is None only for such devices. + """ + if not features.is_support_water_mode or water_box_mode is None: + return [(RoborockCommand.SET_CUSTOM_MODE, [fan_power])] + if features.is_shake_mop_set_supported: + params = {"fan_power": fan_power, "water_box_mode": water_box_mode} + if mop_mode is not None: + params["mop_mode"] = mop_mode + return [(RoborockCommand.SET_CLEAN_MOTOR_MODE, [params])] + if features.is_set_clean_motor_mode_supported: + commands: list[MotorModeCommand] = [ + (RoborockCommand.SET_CLEAN_MOTOR_MODE, [{"fan_power": fan_power, "water_box_mode": water_box_mode}]) + ] + else: + commands = [ + (RoborockCommand.SET_CUSTOM_MODE, [fan_power]), + (RoborockCommand.SET_WATER_BOX_CUSTOM_MODE, [water_box_mode]), + ] + if mop_mode is not None: + commands.append((RoborockCommand.SET_MOP_MODE, [mop_mode])) + return commands + + +def _get_model_options(setting: CleaningSetting, features: DeviceFeatures, region: str) -> list[RoborockModeEnum]: + """Return every value the model supports for a setting, regardless of the cleaning mode.""" + if setting == CleaningSetting.FAN_SPEED: + return list(get_clean_modes(features)) + if setting == CleaningSetting.WATER_MODE: + return list(get_water_modes(features)) + return list(get_clean_routes(features, region)) + + +def _get_mode_codes( + setting: CleaningSetting, mode: CleaningMode | None, features: DeviceFeatures, region: str +) -> set[int]: + """Return the codes of a setting that are offered in the mode (see get_mode_options).""" + options = get_mode_options(setting, mode, features, _get_model_options(setting, features, region)) + return {option.code for option in options} + + +def _get_tab_route_codes(mode: CleaningMode | None, features: DeviceFeatures, region: str) -> set[int]: + """Return the route codes on the mode's tab, whether or not the route is adjustable in it.""" + if _offers_all_routes(mode, features): + return {route.code for route in get_clean_routes(features, region)} + return {CleanRoutes.FAST.code, CleanRoutes.STANDARD.code} + + +def get_setting_change_codes( + setting: CleaningSetting, + code: int, + mode: CleaningMode | None, + features: DeviceFeatures, + region: str, + *, + fan_power: int, + water_box_mode: int | None, + mop_mode: int | None, +) -> tuple[int, int | None, int | None]: + """Return the (fan_power, water_box_mode, mop_mode) codes that change one cleaning setting. + + The setting must be adjustable in the current cleaning mode and the code must be one + of the values allowed in that mode (get_mode_options), otherwise + RoborockUnsupportedFeature is raised. The other two settings keep their current codes, + except that a value left over from another tab is replaced when + switching modes: a fan speed that is not on the mode's list (Max+, the mop-only 105) + becomes balanced (102) and a mop route that is not on the tab's list becomes standard + (300). Mopping only always uses the mop-only fan code. + The mop route is None when the device has no route setting or no shake module, + because the route is only sent with the shake module. + The water mode is None only for devices without a mop, which have no water mode. + """ + if setting not in get_adjustable_settings(mode, features): + raise RoborockUnsupportedFeature(f"The {setting.value} cannot be changed in the current cleaning mode") + selectable = _get_mode_codes(setting, mode, features, region) + if setting == CleaningSetting.WATER_MODE and features.is_water_slide_mode_supported: + selectable.update(range(221, 251)) + if code not in selectable: + raise RoborockUnsupportedFeature(f"The {setting.value} code {code} is not supported in the current mode") + + fan_codes = _get_mode_codes(CleaningSetting.FAN_SPEED, mode, features, region) + if fan_codes and fan_power not in fan_codes: + fan_power = VacuumModes.BALANCED.code + if mop_mode is not None and mop_mode not in _get_tab_route_codes(mode, features, region): + mop_mode = CleanRoutes.STANDARD.code + + if setting == CleaningSetting.FAN_SPEED: + fan_power = code + elif setting == CleaningSetting.WATER_MODE: + water_box_mode = code + else: + mop_mode = code + if mode == CleaningMode.MOP: + fan_power = get_mop_only_vacuum_mode(features).code + sends_route = features.is_clean_route_setting_supported and features.is_shake_mop_set_supported + return fan_power, water_box_mode, mop_mode if sends_route else None + + def _resolve_mode_code(value: int | ModeEnumT | None, mode_cls: type[ModeEnumT]) -> ModeEnumT | None: """Resolve a raw code or enum into a RoborockModeEnum.""" if value is None: @@ -347,7 +654,10 @@ def get_current_cleaning_mode( mop_mode: int | CleanRoutes | None, features: DeviceFeatures, ) -> CleaningMode | None: - """Classify the current high-level cleaning mode from individual mode codes.""" + """Classify the current high-level cleaning mode from individual mode codes. + + The result is None when the classified mode is not in get_cleaning_mode_options(features). + """ if not features.is_support_water_mode: return None clean_mode_enum = _resolve_clean_mode(clean_mode, features) @@ -356,21 +666,60 @@ def get_current_cleaning_mode( if clean_mode_enum is None or water_mode_enum is None: return None - if is_smart_mode_set(water_mode_enum, clean_mode_enum, mop_mode_enum): - return CleaningMode.SMART_MODE - if is_mode_customized(clean_mode_enum, water_mode_enum, mop_mode_enum): + mode = _classify_cleaning_mode(clean_mode_enum, water_mode_enum, mop_mode_enum, features) + if mode not in get_cleaning_mode_options(features): + return None + return mode + + +def _classify_cleaning_mode( + clean_mode: VacuumModes, + water_mode: WaterModes, + mop_mode: CleanRoutes | None, + features: DeviceFeatures, +) -> CleaningMode: + """Classify resolved mode enums, checking custom before SmartPlan like the app.""" + if is_mode_customized(clean_mode, water_mode, mop_mode): return CleaningMode.CUSTOM - if water_mode_enum != WaterModes.OFF: + if is_smart_mode_set(water_mode, clean_mode, mop_mode): + return CleaningMode.SMART_MODE + if water_mode != WaterModes.OFF: try: - if clean_mode_enum == get_mop_only_vacuum_mode(features): + if clean_mode == get_mop_only_vacuum_mode(features): return CleaningMode.MOP except RoborockUnsupportedFeature: pass - if water_mode_enum == WaterModes.OFF: + if water_mode == WaterModes.OFF: return CleaningMode.VACUUM return CleaningMode.VAC_AND_MOP +def get_reported_special_mode( + clean_mode: int | VacuumModes | None, + water_mode: int | WaterModes | None, + mop_mode: int | CleanRoutes | None, + features: DeviceFeatures, +) -> CleaningMode | None: + """Return CUSTOM or SMART_MODE when the reported codes say the robot is in that mode. + + The codes decide, whatever the model's support flags say: a robot that reports + custom or SmartPlan values is in that mode, even if get_current_cleaning_mode + returns None because the mode is not in get_cleaning_mode_options. Custom is + checked before SmartPlan. Devices without a mop only report the fan power. + """ + clean_enum = _resolve_clean_mode(clean_mode, features) + if not features.is_support_water_mode: + water_enum, mop_enum = None, None + else: + water_enum = _resolve_water_mode(water_mode, features) + mop_enum = _resolve_mode_code(mop_mode, CleanRoutes) + if is_mode_customized(clean_enum, water_enum, mop_enum): + return CleaningMode.CUSTOM + if is_smart_mode_set(water_enum, clean_enum, mop_enum): + return CleaningMode.SMART_MODE + return None + + def is_mode_customized( clean_mode: VacuumModes | None, water_mode: WaterModes | None, diff --git a/roborock/device_features.py b/roborock/device_features.py index 160d14cc5..1e65cdc0a 100644 --- a/roborock/device_features.py +++ b/roborock/device_features.py @@ -478,6 +478,7 @@ class DeviceFeatures(RoborockBase): is_roller_mop_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.ROLLER_MOP}) # Features from feature_info list + is_set_clean_motor_mode_supported: bool = field(metadata={"robot_features": 118}) is_led_status_switch_supported: bool = field(metadata={"robot_features": 119}) is_multi_floor_supported: bool = field(metadata={"robot_features": 120}) is_support_fetch_timer_summary: bool = field(metadata={"robot_features": 122}) @@ -511,10 +512,22 @@ class DeviceFeatures(RoborockBase): RoborockProductNickname.TANOSV, RoborockProductNickname.TANOSE, RoborockProductNickname.TANOS, + RoborockProductNickname.RUBYSC, + RoborockProductNickname.RUBYSLITE, + RoborockProductNickname.RUBYSE, + ] + } + ) + is_custom_mode_supported: bool = field( + metadata={ + "model_blacklist": [ + RoborockProductNickname.TANOS, + RoborockProductNickname.RUBYPLUS, + RoborockProductNickname.RUBYSC, + RoborockProductNickname.RUBYSE, ] } ) - is_custom_mode_supported: bool = field(metadata={"model_blacklist": [RoborockProductNickname.TANOS]}) is_support_custom_carpet: bool = field(metadata={"model_whitelist": [RoborockProductNickname.ULTRONLITE]}) is_show_general_obstacle_supported: bool = field(metadata={"model_whitelist": [RoborockProductNickname.TANOSSPLUS]}) is_show_obstacle_photo_supported: bool = field( diff --git a/roborock/devices/traits/v1/status.py b/roborock/devices/traits/v1/status.py index 01eed9a55..6328083d5 100644 --- a/roborock/devices/traits/v1/status.py +++ b/roborock/devices/traits/v1/status.py @@ -4,23 +4,33 @@ from roborock import ( CleaningMode, + CleaningSetting, CleanRoutes, RoborockDockState, StatusV2, VacuumModes, WaterModes, + get_adjustable_settings, get_clean_modes, get_clean_routes, + get_cleaning_mode_codes, get_cleaning_mode_options, - get_cleaning_mode_parameters, get_current_cleaning_mode, + get_display_options, get_dock_state, + get_fan_speed_name, + get_mop_route_name, + get_motor_mode_commands, + get_reported_special_mode, + get_setting_change_codes, + get_supported_settings, get_water_mode_mapping, + get_water_mode_name, get_water_modes, - get_water_slide_mode_name, resolve_cleaning_mode, ) from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener +from roborock.exceptions import RoborockException from roborock.roborock_message import RoborockDataProtocol from roborock.roborock_typing import RoborockCommand @@ -50,11 +60,12 @@ class StatusTrait(StatusV2, common.V1TraitMixin, TraitUpdateListener): - Water Mode - Mop Route - You should use the _options version of the attribute to know which are - supported for your device (i.e. fan_speed_options) - Then you can use the _mapping to convert an int value to the actual Enum. - (i.e. fan_speed_mapping) - You can use the _name property to get the str value of the enum. (i.e. fan_speed_name) + The _options and _mapping versions of the attribute (i.e. fan_speed_options, + fan_speed_mapping) hold only the user-selectable values, i.e. what you can + write to the device. They do not include SmartPlan or custom codes. + Use the _name property (i.e. fan_speed_name), or get_fan_speed_name, + get_water_mode_name and get_mop_route_name, to name the current value, + including SmartPlan and custom codes. """ @@ -91,16 +102,37 @@ def fan_speed_options(self) -> list[VacuumModes]: def fan_speed_mapping(self) -> dict[int, str]: return {fan.code: fan.value for fan in self.fan_speed_options} + @property + def supported_cleaning_settings(self) -> list[CleaningSetting]: + """The cleaning settings this model has at all, independent of the current cleaning mode. + + Use it to decide which settings to offer. Whether a setting can be changed right + now is is_fan_speed_adjustable, is_water_mode_adjustable and is_mop_route_adjustable. + The options and mapping of a setting the model does not have are empty. The cleaning + mode has no entry here: it exists exactly when cleaning_mode_options is not empty, + which is the case for models with a mop (is_support_water_mode). + + The list is in the definition order of CleaningSetting, so it is stable across runs. + """ + supported = get_supported_settings(self._device_features_trait) + return [setting for setting in CleaningSetting if setting in supported] + @cached_property def water_mode_options(self) -> list[WaterModes]: + if CleaningSetting.WATER_MODE not in self.supported_cleaning_settings: + return [] return get_water_modes(self._device_features_trait) @cached_property def water_mode_mapping(self) -> dict[int, str]: + if CleaningSetting.WATER_MODE not in self.supported_cleaning_settings: + return {} return get_water_mode_mapping(self._device_features_trait) @cached_property def mop_route_options(self) -> list[CleanRoutes]: + if CleaningSetting.MOP_ROUTE not in self.supported_cleaning_settings: + return [] return get_clean_routes(self._device_features_trait, self._region or "us") @cached_property @@ -115,21 +147,19 @@ def cleaning_mode_options(self) -> list[CleaningMode]: def fan_speed_name(self) -> str | None: if self.fan_power is None: return None - return self.fan_speed_mapping.get(self.fan_power) + return get_fan_speed_name(self.fan_power, self._device_features_trait) @property def water_mode_name(self) -> str | None: if self.water_box_mode is None: return None - if self._device_features_trait.is_water_slide_mode_supported: - return get_water_slide_mode_name(self.water_box_mode) - return self.water_mode_mapping.get(self.water_box_mode) + return get_water_mode_name(self.water_box_mode, self._device_features_trait) @property def mop_route_name(self) -> str | None: if self.mop_mode is None: return None - return self.mop_route_mapping.get(self.mop_mode) + return get_mop_route_name(self.mop_mode, self._device_features_trait, self._region or "us") @property def current_cleaning_mode(self) -> CleaningMode | None: @@ -146,12 +176,108 @@ def current_cleaning_mode_name(self) -> str | None: return None return cleaning_mode.value + @property + def _rules_mode(self) -> CleaningMode | None: + """The mode the adjustable, display and setter rules use. + + A reported SmartPlan or custom state counts even when the model lacks the support + flags that would make current_cleaning_mode report it. + """ + special = get_reported_special_mode( + self.fan_power, self.water_box_mode, self.mop_mode, self._device_features_trait + ) + return special or self.current_cleaning_mode + + @property + def is_fan_speed_adjustable(self) -> bool: + """Whether the fan speed can be changed in the current cleaning mode.""" + adjustable = get_adjustable_settings(self._rules_mode, self._device_features_trait) + return CleaningSetting.FAN_SPEED in adjustable + + @property + def is_water_mode_adjustable(self) -> bool: + """Whether the water mode can be changed in the current cleaning mode.""" + adjustable = get_adjustable_settings(self._rules_mode, self._device_features_trait) + return CleaningSetting.WATER_MODE in adjustable + + @property + def is_mop_route_adjustable(self) -> bool: + """Whether the mop route can be changed in the current cleaning mode.""" + adjustable = get_adjustable_settings(self._rules_mode, self._device_features_trait) + return CleaningSetting.MOP_ROUTE in adjustable + + @property + def fan_speed_display_options(self) -> list[VacuumModes]: + """Fan speeds to show for the current cleaning mode.""" + return get_display_options( + CleaningSetting.FAN_SPEED, self._rules_mode, self._device_features_trait, self.fan_speed_options + ) + + @property + def water_mode_display_options(self) -> list[WaterModes]: + """Water modes to show for the current cleaning mode.""" + return get_display_options( + CleaningSetting.WATER_MODE, self._rules_mode, self._device_features_trait, self.water_mode_options + ) + + @property + def mop_route_display_options(self) -> list[CleanRoutes]: + """Mop routes to show for the current cleaning mode.""" + return get_display_options( + CleaningSetting.MOP_ROUTE, self._rules_mode, self._device_features_trait, self.mop_route_options + ) + async def set_cleaning_mode(self, cleaning_mode: str | CleaningMode) -> None: """Set the preferred high-level cleaning mode for the device.""" - await self.rpc_channel.send_command( - RoborockCommand.SET_CLEAN_MOTOR_MODE, - params=get_cleaning_mode_parameters(resolve_cleaning_mode(cleaning_mode), self._device_features_trait), + fan_power, water_box_mode, mop_mode = get_cleaning_mode_codes( + resolve_cleaning_mode(cleaning_mode), self._device_features_trait, self.mop_mode + ) + await self._apply_motor_mode(fan_power, water_box_mode, mop_mode) + + async def set_fan_speed(self, mode: VacuumModes) -> None: + """Set the fan speed while keeping the water mode and mop route.""" + await self._set_cleaning_setting(CleaningSetting.FAN_SPEED, mode.code) + + async def set_water_mode(self, mode: WaterModes) -> None: + """Set the water mode while keeping the fan speed and mop route.""" + await self._set_cleaning_setting(CleaningSetting.WATER_MODE, mode.code) + + async def set_mop_route(self, route: CleanRoutes) -> None: + """Set the mop route while keeping the fan speed and water mode.""" + await self._set_cleaning_setting(CleaningSetting.MOP_ROUTE, route.code) + + async def _set_cleaning_setting(self, setting: CleaningSetting, code: int) -> None: + features = self._device_features_trait + # A device without a mop has no water mode, so only the fan power has to be loaded. + if self.fan_power is None or (features.is_support_water_mode and self.water_box_mode is None): + raise RoborockException("Status is not loaded, call refresh() first") + fan_power, water_box_mode, mop_mode = get_setting_change_codes( + setting, + code, + self._rules_mode, + features, + self._region or "us", + fan_power=self.fan_power, + water_box_mode=self.water_box_mode, + mop_mode=self.mop_mode, ) + await self._apply_motor_mode(fan_power, water_box_mode, mop_mode) + + async def _apply_motor_mode(self, fan_power: int, water_box_mode: int | None, mop_mode: int | None) -> None: + """Send the codes in the order the model needs, then update the cached status. + + The cached fields are updated and listeners are notified once, only after all + commands have succeeded. A None water mode or mop route leaves that field as it is. + """ + commands = get_motor_mode_commands(fan_power, water_box_mode, mop_mode, self._device_features_trait) + for command, params in commands: + await self.rpc_channel.send_command(command, params=params) + self.fan_power = fan_power + if water_box_mode is not None: + self.water_box_mode = water_box_mode + if mop_mode is not None: + self.mop_mode = mop_mode + self._notify_update() async def resolve_error(self, error_code: int | None = None) -> None: """Resolve an error, like tapping "Resolved" in the Roborock app. diff --git a/tests/__snapshots__/test_supported_features.ambr b/tests/__snapshots__/test_supported_features.ambr index 834cc350e..b0d85bf9e 100644 --- a/tests/__snapshots__/test_supported_features.ambr +++ b/tests/__snapshots__/test_supported_features.ambr @@ -112,6 +112,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': True, @@ -291,6 +292,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -470,6 +472,7 @@ 'is_rpc_retry_supported': False, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': False, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': False, 'is_should_show_arm_over_load_supported': False, @@ -649,6 +652,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -828,6 +832,7 @@ 'is_rpc_retry_supported': False, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': False, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': False, 'is_should_show_arm_over_load_supported': False, @@ -1007,6 +1012,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -1186,6 +1192,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': True, @@ -1365,6 +1372,7 @@ 'is_rpc_retry_supported': False, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': False, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': False, 'is_should_show_arm_over_load_supported': False, @@ -1375,7 +1383,7 @@ 'is_small_side_mop_supported': False, 'is_smart_clean_mode_set_supported': False, 'is_soak_and_wash_supported': False, - 'is_soft_clean_mode_supported': False, + 'is_soft_clean_mode_supported': True, 'is_sr_map_supported': False, 'is_super_deep_wash_supported': False, 'is_support_api_app_stop_grasp_supported': False, @@ -1544,6 +1552,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -1723,6 +1732,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -1902,6 +1912,7 @@ 'is_rpc_retry_supported': True, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': True, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': True, 'is_shake_mop_set_supported': True, 'is_should_show_arm_over_load_supported': False, @@ -2081,6 +2092,7 @@ 'is_rpc_retry_supported': False, 'is_rubber_brush_carpet_supported': False, 'is_set_child_supported': False, + 'is_set_clean_motor_mode_supported': False, 'is_setting_carpet_first_supported': False, 'is_shake_mop_set_supported': False, 'is_should_show_arm_over_load_supported': False, diff --git a/tests/data/v1/test_v1_clean_modes.py b/tests/data/v1/test_v1_clean_modes.py new file mode 100644 index 000000000..c13ca3f96 --- /dev/null +++ b/tests/data/v1/test_v1_clean_modes.py @@ -0,0 +1,663 @@ +"""Tests for the pure V1 cleaning mode helpers.""" + +import itertools + +import pytest + +from roborock.data.v1.v1_clean_modes import ( + CleaningMode, + CleaningSetting, + CleanRoutes, + MotorModeCommand, + VacuumModes, + WaterModes, + get_adjustable_settings, + get_clean_modes, + get_clean_routes, + get_cleaning_mode_codes, + get_cleaning_mode_options, + get_display_options, + get_motor_mode_commands, + get_reported_special_mode, + get_setting_change_codes, + get_supported_settings, + get_water_modes, +) +from roborock.device_features import DeviceFeatures +from roborock.exceptions import RoborockUnsupportedFeature +from roborock.roborock_typing import RoborockCommand + + +def _features(**overrides: bool) -> DeviceFeatures: + features = DeviceFeatures.from_feature_flags( + new_feature_info=0, new_feature_info_str="", feature_info=[], product_nickname=None + ) + features.is_support_water_mode = True + features.is_clean_route_setting_supported = True + features.is_shake_mop_set_supported = True + features.is_clean_route_fast_mode_supported = True + for name, value in overrides.items(): + setattr(features, name, value) + return features + + +_ALL = frozenset(CleaningSetting) + + +@pytest.mark.parametrize( + ("mode", "overrides", "expected"), + [ + (CleaningMode.SMART_MODE, {}, frozenset()), + (CleaningMode.CUSTOM, {}, frozenset()), + (CleaningMode.VACUUM, {}, frozenset({CleaningSetting.FAN_SPEED, CleaningSetting.MOP_ROUTE})), + (CleaningMode.VAC_AND_MOP, {}, _ALL), + (CleaningMode.VAC_AND_MOP, {"is_clean_route_setting_supported": False}, _ALL - {CleaningSetting.MOP_ROUTE}), + (CleaningMode.MOP, {}, _ALL - {CleaningSetting.FAN_SPEED}), + # The route needs the shake module in every mode. + (CleaningMode.VACUUM, {"is_shake_mop_set_supported": False}, frozenset({CleaningSetting.FAN_SPEED})), + ( + CleaningMode.VAC_AND_MOP, + {"is_shake_mop_set_supported": False}, + frozenset({CleaningSetting.FAN_SPEED, CleaningSetting.WATER_MODE}), + ), + (CleaningMode.MOP, {"is_shake_mop_set_supported": False}, frozenset({CleaningSetting.WATER_MODE})), + # Without the fast route the route is only adjustable while mopping only. + (CleaningMode.VACUUM, {"is_clean_route_fast_mode_supported": False}, frozenset({CleaningSetting.FAN_SPEED})), + ( + CleaningMode.VAC_AND_MOP, + {"is_clean_route_fast_mode_supported": False}, + frozenset({CleaningSetting.FAN_SPEED, CleaningSetting.WATER_MODE}), + ), + (CleaningMode.MOP, {"is_clean_route_fast_mode_supported": False}, _ALL - {CleaningSetting.FAN_SPEED}), + (None, {}, frozenset()), + (None, {"is_support_water_mode": False}, frozenset({CleaningSetting.FAN_SPEED})), + ], +) +def test_get_adjustable_settings( + mode: CleaningMode | None, overrides: dict[str, bool], expected: frozenset[CleaningSetting] +) -> None: + features = _features(**{"is_pure_clean_mop_supported": True, **overrides}) + assert get_adjustable_settings(mode, features) == expected + + +@pytest.mark.parametrize( + ("mode", "overrides", "expected"), + [ + # Without mode tabs the robot has one general setting group: water is offered even when the water is off. + (CleaningMode.VACUUM, {}, _ALL), + (CleaningMode.VAC_AND_MOP, {}, _ALL), + (CleaningMode.VACUUM, {"is_shake_mop_set_supported": False}, _ALL - {CleaningSetting.MOP_ROUTE}), + ( + CleaningMode.VACUUM, + {"is_clean_route_fast_mode_supported": False}, + _ALL - {CleaningSetting.MOP_ROUTE}, + ), + ( + CleaningMode.VACUUM, + {"is_support_water_mode": False}, + _ALL - {CleaningSetting.WATER_MODE}, + ), + (CleaningMode.SMART_MODE, {}, frozenset()), + (CleaningMode.CUSTOM, {}, frozenset()), + ], +) +def test_get_adjustable_settings_without_mode_tabs( + mode: CleaningMode, overrides: dict[str, bool], expected: frozenset[CleaningSetting] +) -> None: + features = _features(**{"is_pure_clean_mop_supported": False, **overrides}) + assert get_adjustable_settings(mode, features) == expected + + +@pytest.mark.parametrize( + ("mode", "expected"), + [ + (CleaningMode.SMART_MODE, [VacuumModes.SMART_MODE]), + (CleaningMode.CUSTOM, [VacuumModes.CUSTOMIZED]), + (CleaningMode.VACUUM, [VacuumModes.QUIET, VacuumModes.BALANCED]), + (CleaningMode.MOP, []), + ], +) +def test_get_display_options_kinds(mode: CleaningMode, expected: list[VacuumModes]) -> None: + options = [VacuumModes.QUIET, VacuumModes.BALANCED] + assert get_display_options(CleaningSetting.FAN_SPEED, mode, _features(), options) == expected + + +@pytest.mark.parametrize("mode", [CleaningMode.SMART_MODE, CleaningMode.CUSTOM, CleaningMode.VACUUM, None]) +def test_get_display_options_empty_options_show_nothing(mode: CleaningMode | None) -> None: + """A setting the device does not have shows nothing, even in SmartPlan or custom mode.""" + assert get_display_options(CleaningSetting.MOP_ROUTE, mode, _features(), []) == [] + + +@pytest.mark.parametrize( + ("shake", "f118", "mop", "expected"), + [ + ( + True, + False, + 300, + [(RoborockCommand.SET_CLEAN_MOTOR_MODE, [{"fan_power": 102, "water_box_mode": 202, "mop_mode": 300}])], + ), + (True, True, None, [(RoborockCommand.SET_CLEAN_MOTOR_MODE, [{"fan_power": 102, "water_box_mode": 202}])]), + (False, True, None, [(RoborockCommand.SET_CLEAN_MOTOR_MODE, [{"fan_power": 102, "water_box_mode": 202}])]), + ( + False, + True, + 300, + [ + (RoborockCommand.SET_CLEAN_MOTOR_MODE, [{"fan_power": 102, "water_box_mode": 202}]), + (RoborockCommand.SET_MOP_MODE, [300]), + ], + ), + ( + False, + False, + None, + [(RoborockCommand.SET_CUSTOM_MODE, [102]), (RoborockCommand.SET_WATER_BOX_CUSTOM_MODE, [202])], + ), + ( + False, + False, + 300, + [ + (RoborockCommand.SET_CUSTOM_MODE, [102]), + (RoborockCommand.SET_WATER_BOX_CUSTOM_MODE, [202]), + (RoborockCommand.SET_MOP_MODE, [300]), + ], + ), + ], +) +def test_get_motor_mode_commands(shake: bool, f118: bool, mop: int | None, expected: list[MotorModeCommand]) -> None: + features = _features(is_shake_mop_set_supported=shake, is_set_clean_motor_mode_supported=f118) + assert get_motor_mode_commands(102, 202, mop, features) == expected + + +@pytest.mark.parametrize("mop", [None, 300]) +@pytest.mark.parametrize(("shake", "f118"), [(False, False), (True, False), (False, True), (True, True)]) +def test_get_motor_mode_commands_vacuum_only(shake: bool, f118: bool, mop: int | None) -> None: + """Devices without a mop only ever get the fan command.""" + features = _features( + is_support_water_mode=False, is_shake_mop_set_supported=shake, is_set_clean_motor_mode_supported=f118 + ) + assert get_motor_mode_commands(104, None, mop, features) == [(RoborockCommand.SET_CUSTOM_MODE, [104])] + + +@pytest.mark.parametrize( + ("mode", "overrides", "current_mop_mode", "expected"), + [ + (CleaningMode.VACUUM, {}, None, (102, 200, 300)), + (CleaningMode.VAC_AND_MOP, {}, 302, (102, 202, 300)), + (CleaningMode.MOP, {}, None, (105, 202, 300)), + (CleaningMode.CUSTOM, {}, None, (106, 204, 302)), + (CleaningMode.SMART_MODE, {"is_smart_clean_mode_set_supported": True}, None, (110, 209, 306)), + (CleaningMode.VAC_AND_MOP, {"is_water_slide_mode_supported": True}, None, (102, 235, 300)), + # Without a route setting the route is only sent to leave SmartPlan or custom. + (CleaningMode.VACUUM, {"is_clean_route_setting_supported": False}, None, (102, 200, None)), + (CleaningMode.VACUUM, {"is_clean_route_setting_supported": False}, 300, (102, 200, None)), + (CleaningMode.VACUUM, {"is_clean_route_setting_supported": False}, 302, (102, 200, 300)), + (CleaningMode.VAC_AND_MOP, {"is_clean_route_setting_supported": False}, 306, (102, 202, 300)), + (CleaningMode.VAC_AND_MOP, {"is_clean_route_setting_supported": False}, 302, (102, 202, 300)), + # The route of the mode is only sent with the shake module; without it only the reset remains. + (CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}, None, (102, 202, None)), + (CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}, 301, (102, 202, None)), + (CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}, 306, (102, 202, 300)), + (CleaningMode.MOP, {"is_shake_mop_set_supported": False}, 302, (105, 202, 300)), + (CleaningMode.CUSTOM, {"is_shake_mop_set_supported": False}, None, (106, 204, None)), + (CleaningMode.CUSTOM, {"is_shake_mop_set_supported": False}, 302, (106, 204, None)), + ], +) +def test_get_cleaning_mode_codes( + mode: CleaningMode, + overrides: dict[str, bool], + current_mop_mode: int | None, + expected: tuple[int, int, int | None], +) -> None: + features = _features(is_pure_clean_mop_supported=True, is_customized_clean_supported=True, **overrides) + features.is_custom_mode_supported = True + assert get_cleaning_mode_codes(mode, features, current_mop_mode) == expected + + +@pytest.mark.parametrize( + ("mode", "fan_water", "current_mop_mode", "expected_route"), + [ + (CleaningMode.SMART_MODE, (110, 209), None, None), + (CleaningMode.SMART_MODE, (110, 209), 300, None), + (CleaningMode.SMART_MODE, (110, 209), 302, 300), + (CleaningMode.SMART_MODE, (110, 209), 306, None), + (CleaningMode.CUSTOM, (106, 204), None, None), + (CleaningMode.CUSTOM, (106, 204), 300, None), + (CleaningMode.CUSTOM, (106, 204), 302, None), + (CleaningMode.CUSTOM, (106, 204), 306, 300), + ], +) +def test_get_cleaning_mode_codes_special_targets_without_route_setting( + mode: CleaningMode, + fan_water: tuple[int, int], + current_mop_mode: int | None, + expected_route: int | None, +) -> None: + """SmartPlan and custom keep the route they already own and only reset the other special one.""" + features = _features( + is_pure_clean_mop_supported=True, + is_customized_clean_supported=True, + is_custom_mode_supported=True, + is_smart_clean_mode_set_supported=True, + is_clean_route_setting_supported=False, + ) + assert get_cleaning_mode_codes(mode, features, current_mop_mode) == (*fan_water, expected_route) + + +def test_get_cleaning_mode_codes_unsupported_mode() -> None: + with pytest.raises(RoborockUnsupportedFeature, match="not supported"): + get_cleaning_mode_codes(CleaningMode.SMART_MODE, _features(), None) + + +@pytest.mark.parametrize( + ("setting", "code", "mode", "status", "overrides", "expected"), + [ + (CleaningSetting.FAN_SPEED, 104, CleaningMode.VAC_AND_MOP, (102, 202, 300), {}, (104, 202, 300)), + (CleaningSetting.WATER_MODE, 203, CleaningMode.MOP, (105, 202, 300), {}, (105, 203, 300)), + (CleaningSetting.MOP_ROUTE, 301, CleaningMode.MOP, (105, 202, 300), {}, (105, 202, 301)), + # Without a route setting the route is not sent. + ( + CleaningSetting.FAN_SPEED, + 103, + CleaningMode.VACUUM, + (102, 200, 300), + {"is_clean_route_setting_supported": False}, + (103, 200, None), + ), + # Without the shake module the route is not sent either. + ( + CleaningSetting.FAN_SPEED, + 103, + CleaningMode.VACUUM, + (102, 200, 300), + {"is_shake_mop_set_supported": False}, + (103, 200, None), + ), + # Water slide devices accept every slider position. + ( + CleaningSetting.WATER_MODE, + 233, + CleaningMode.VAC_AND_MOP, + (102, 225, 300), + {"is_water_slide_mode_supported": True}, + (102, 233, 300), + ), + ], +) +def test_get_setting_change_codes( + setting: CleaningSetting, + code: int, + mode: CleaningMode, + status: tuple[int, int, int], + overrides: dict[str, bool], + expected: tuple[int, int, int | None], +) -> None: + features = _features(is_pure_clean_mop_supported=True, **overrides) + assert ( + get_setting_change_codes( + setting, code, mode, features, "us", fan_power=status[0], water_box_mode=status[1], mop_mode=status[2] + ) + == expected + ) + + +@pytest.mark.parametrize( + ("setting", "code", "mode", "overrides"), + [ + (CleaningSetting.FAN_SPEED, 104, CleaningMode.SMART_MODE, {}), + (CleaningSetting.FAN_SPEED, 104, CleaningMode.CUSTOM, {}), + (CleaningSetting.FAN_SPEED, 104, None, {}), + (CleaningSetting.FAN_SPEED, 104, CleaningMode.MOP, {}), + (CleaningSetting.WATER_MODE, 203, CleaningMode.VACUUM, {}), + (CleaningSetting.FAN_SPEED, 110, CleaningMode.VAC_AND_MOP, {}), + (CleaningSetting.FAN_SPEED, 999, CleaningMode.VAC_AND_MOP, {}), + (CleaningSetting.WATER_MODE, 220, CleaningMode.VAC_AND_MOP, {"is_water_slide_mode_supported": True}), + (CleaningSetting.WATER_MODE, 251, CleaningMode.VAC_AND_MOP, {"is_water_slide_mode_supported": True}), + (CleaningSetting.MOP_ROUTE, 302, CleaningMode.VAC_AND_MOP, {}), + # Mopping without water is not mopping. + (CleaningSetting.WATER_MODE, 200, CleaningMode.MOP, {}), + ], +) +def test_get_setting_change_codes_refused( + setting: CleaningSetting, code: int, mode: CleaningMode | None, overrides: dict[str, bool] +) -> None: + features = _features(is_pure_clean_mop_supported=True, **overrides) + with pytest.raises(RoborockUnsupportedFeature): + get_setting_change_codes(setting, code, mode, features, "us", fan_power=102, water_box_mode=202, mop_mode=300) + + +@pytest.mark.parametrize("route_supported", [True, False]) +def test_get_setting_change_codes_vacuum_only(route_supported: bool) -> None: + """Without a mop there is no water mode or route to carry along.""" + features = _features(is_support_water_mode=False, is_clean_route_setting_supported=route_supported) + assert get_setting_change_codes( + CleaningSetting.FAN_SPEED, 104, None, features, "us", fan_power=102, water_box_mode=None, mop_mode=None + ) == (104, None, None) + + +_SAROS_10R = { + "is_soft_clean_mode_supported": False, + "is_pure_clean_mop_supported": True, + "is_shake_mop_set_supported": True, + "is_clean_route_setting_supported": True, + "is_clean_route_fast_mode_supported": True, + "is_careful_slow_mop_supported": True, + "is_max_plus_mode_supported": True, + "is_water_slide_mode_supported": True, +} +_FAN_BASE = [VacuumModes.QUIET, VacuumModes.BALANCED, VacuumModes.TURBO, VacuumModes.MAX] +_ROUTES_FULL = {CleanRoutes.STANDARD, CleanRoutes.DEEP, CleanRoutes.DEEP_PLUS, CleanRoutes.FAST} +_ROUTES_SHORT = {CleanRoutes.FAST, CleanRoutes.STANDARD} +_ROUTES_EFFICIENCY = {CleanRoutes.STANDARD, CleanRoutes.DEEP_PLUS, CleanRoutes.FAST} + + +def _mode_display_options( + setting: CleaningSetting, mode: CleaningMode, overrides: dict[str, bool] +) -> list[VacuumModes] | list[WaterModes] | list[CleanRoutes]: + """The display options of a setting for a device with the Saros 10R flags changed by overrides.""" + features = _features(**{**_SAROS_10R, **overrides}) + if setting == CleaningSetting.FAN_SPEED: + return get_display_options(setting, mode, features, get_clean_modes(features)) + if setting == CleaningSetting.WATER_MODE: + return get_display_options(setting, mode, features, get_water_modes(features)) + return get_display_options(setting, mode, features, get_clean_routes(features, "us")) + + +@pytest.mark.parametrize( + ("mode", "overrides", "expected"), + [ + (CleaningMode.VAC_AND_MOP, {}, _FAN_BASE), + (CleaningMode.VACUUM, {}, [*_FAN_BASE, VacuumModes.MAX_PLUS]), + (CleaningMode.MOP, {}, []), + # Max+ in the vacuum tab needs is_max_plus_mode_supported; the other flag alone does not add it. + ( + CleaningMode.VACUUM, + {"is_max_plus_mode_supported": False, "is_none_pure_clean_mop_with_max_plus": True}, + _FAN_BASE, + ), + # Without sub-tabs the other flag decides. + ( + CleaningMode.VAC_AND_MOP, + { + "is_pure_clean_mop_supported": False, + "is_max_plus_mode_supported": False, + "is_none_pure_clean_mop_with_max_plus": True, + }, + [*_FAN_BASE, VacuumModes.MAX_PLUS], + ), + (CleaningMode.VACUUM, {"is_pure_clean_mop_supported": False}, _FAN_BASE), + (CleaningMode.VAC_AND_MOP, {"is_soft_clean_mode_supported": True}, [*_FAN_BASE, VacuumModes.GENTLE]), + ], +) +def test_fan_speed_display_options_per_mode( + mode: CleaningMode, overrides: dict[str, bool], expected: list[VacuumModes] +) -> None: + assert _mode_display_options(CleaningSetting.FAN_SPEED, mode, overrides) == expected + + +@pytest.mark.parametrize( + ("mode", "overrides", "expected"), + [ + (CleaningMode.VAC_AND_MOP, {}, _ROUTES_SHORT), + (CleaningMode.VACUUM, {}, _ROUTES_SHORT), + (CleaningMode.MOP, {}, _ROUTES_FULL), + # Efficiency devices show the full list without deep in every mode. + (CleaningMode.VAC_AND_MOP, {"is_clean_efficiency_supported": True}, _ROUTES_EFFICIENCY), + (CleaningMode.MOP, {"is_clean_efficiency_supported": True}, _ROUTES_EFFICIENCY), + (CleaningMode.MOP, {"is_none_pure_clean_mop_with_max_plus": True}, _ROUTES_SHORT), + (CleaningMode.VAC_AND_MOP, {"is_none_pure_clean_mop_with_max_plus": True}, _ROUTES_SHORT), + # Without sub-tabs the full list is shown. + (CleaningMode.VAC_AND_MOP, {"is_pure_clean_mop_supported": False}, _ROUTES_FULL), + (CleaningMode.VAC_AND_MOP, {"is_clean_route_fast_mode_supported": False}, set()), + (CleaningMode.VACUUM, {"is_clean_route_fast_mode_supported": False}, set()), + (CleaningMode.MOP, {"is_clean_route_fast_mode_supported": False}, _ROUTES_FULL - {CleanRoutes.FAST}), + (CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}, set()), + (CleaningMode.VACUUM, {"is_shake_mop_set_supported": False}, set()), + (CleaningMode.MOP, {"is_shake_mop_set_supported": False}, set()), + ], +) +def test_mop_route_display_options_per_mode( + mode: CleaningMode, overrides: dict[str, bool], expected: set[CleanRoutes] +) -> None: + assert set(_mode_display_options(CleaningSetting.MOP_ROUTE, mode, overrides)) == expected + + +@pytest.mark.parametrize("mode", [CleaningMode.VAC_AND_MOP, CleaningMode.MOP]) +@pytest.mark.parametrize("slide", [True, False]) +def test_water_mode_display_options_without_off_when_pure_mop(mode: CleaningMode, slide: bool) -> None: + options = _mode_display_options(CleaningSetting.WATER_MODE, mode, {"is_water_slide_mode_supported": slide}) + assert options + assert WaterModes.OFF not in options + + +def test_water_mode_display_options_keep_off_without_sub_tabs() -> None: + options = _mode_display_options( + CleaningSetting.WATER_MODE, CleaningMode.VAC_AND_MOP, {"is_pure_clean_mop_supported": False} + ) + assert WaterModes.OFF in options + + +@pytest.mark.parametrize( + ("setting", "code", "mode", "overrides"), + [ + (CleaningSetting.MOP_ROUTE, 301, CleaningMode.VAC_AND_MOP, {}), + (CleaningSetting.MOP_ROUTE, 303, CleaningMode.VACUUM, {}), + (CleaningSetting.FAN_SPEED, 108, CleaningMode.VAC_AND_MOP, {}), + (CleaningSetting.FAN_SPEED, 108, CleaningMode.VACUUM, {"is_max_plus_mode_supported": False}), + (CleaningSetting.WATER_MODE, 200, CleaningMode.VAC_AND_MOP, {}), + (CleaningSetting.MOP_ROUTE, 300, CleaningMode.VAC_AND_MOP, {"is_shake_mop_set_supported": False}), + ], +) +def test_get_setting_change_codes_refuses_values_outside_mode_list( + setting: CleaningSetting, code: int, mode: CleaningMode, overrides: dict[str, bool] +) -> None: + features = _features(**{**_SAROS_10R, **overrides}) + with pytest.raises(RoborockUnsupportedFeature): + get_setting_change_codes(setting, code, mode, features, "us", fan_power=102, water_box_mode=235, mop_mode=300) + + +@pytest.mark.parametrize( + ("setting", "code", "mode", "status", "expected", "overrides"), + [ + (CleaningSetting.FAN_SPEED, 108, CleaningMode.VACUUM, (102, 200, 300), (108, 200, 300), {}), + (CleaningSetting.MOP_ROUTE, 304, CleaningMode.VACUUM, (108, 200, 300), (108, 200, 304), {}), + (CleaningSetting.MOP_ROUTE, 301, CleaningMode.MOP, (105, 235, 300), (105, 235, 301), {}), + # A route or fan speed set in another tab by an older client is not carried along. + (CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (102, 235, 301), (102, 240, 300), {}), + (CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (108, 235, 300), (102, 240, 300), {}), + (CleaningSetting.MOP_ROUTE, 304, CleaningMode.VAC_AND_MOP, (108, 235, 300), (102, 235, 304), {}), + (CleaningSetting.WATER_MODE, 240, CleaningMode.MOP, (105, 235, 301), (105, 240, 301), {}), + # The mop-only fan code left behind outside mopping only becomes balanced, like Max+. + (CleaningSetting.MOP_ROUTE, 304, CleaningMode.VACUUM, (105, 200, 300), (102, 200, 304), {}), + (CleaningSetting.WATER_MODE, 240, CleaningMode.VAC_AND_MOP, (105, 235, 300), (102, 240, 300), {}), + # Gentle is on the fan list of soft-clean models, so code 105 stays there. + ( + CleaningSetting.WATER_MODE, + 240, + CleaningMode.VAC_AND_MOP, + (105, 235, 300), + (105, 240, 300), + {"is_soft_clean_mode_supported": True}, + ), + # A leftover route is replaced even when the mode has no adjustable route. + ( + CleaningSetting.WATER_MODE, + 240, + CleaningMode.VAC_AND_MOP, + (102, 235, 301), + (102, 240, 300), + {"is_clean_route_fast_mode_supported": False}, + ), + # Fast is on the tab's short list and stays. + ( + CleaningSetting.WATER_MODE, + 240, + CleaningMode.VAC_AND_MOP, + (102, 235, 304), + (102, 240, 304), + {"is_clean_route_fast_mode_supported": False}, + ), + ], +) +def test_get_setting_change_codes_replaces_values_outside_mode_list( + setting: CleaningSetting, + code: int, + mode: CleaningMode, + status: tuple[int, int, int], + expected: tuple[int, int, int], + overrides: dict[str, bool], +) -> None: + features = _features(**{**_SAROS_10R, **overrides}) + assert ( + get_setting_change_codes( + setting, code, mode, features, "us", fan_power=status[0], water_box_mode=status[1], mop_mode=status[2] + ) + == expected + ) + + +@pytest.mark.parametrize("mode", [CleaningMode.SMART_MODE, CleaningMode.CUSTOM]) +@pytest.mark.parametrize("shake", [True, False]) +def test_get_display_options_route_special_values_need_shake(mode: CleaningMode, shake: bool) -> None: + features = _features(is_shake_mop_set_supported=shake) + options = get_clean_routes(features, "us") + assert options + shown = get_display_options(CleaningSetting.MOP_ROUTE, mode, features, options) + assert bool(shown) is shake + + +def test_water_mode_display_options_include_off_when_turning_water_on_without_mode_tabs() -> None: + options = _mode_display_options( + CleaningSetting.WATER_MODE, CleaningMode.VACUUM, {"is_pure_clean_mop_supported": False} + ) + assert WaterModes.OFF in options + assert len(options) > 1 + + +def test_get_setting_change_codes_turns_water_on_without_mode_tabs() -> None: + features = _features(**{**_SAROS_10R, "is_pure_clean_mop_supported": False}) + assert get_setting_change_codes( + CleaningSetting.WATER_MODE, + 240, + CleaningMode.VACUUM, + features, + "us", + fan_power=102, + water_box_mode=200, + mop_mode=300, + ) == (102, 240, 300) + + +def test_fan_speed_display_options_keep_full_list_without_a_mop() -> None: + """Devices without a mop have no mode tabs at all and keep every fan speed the model lists, Max+ included.""" + features = _features(is_support_water_mode=False, is_max_plus_mode_supported=True) + options = get_clean_modes(features) + assert VacuumModes.MAX_PLUS in options + assert get_display_options(CleaningSetting.FAN_SPEED, None, features, options) == options + + +_FAN = CleaningSetting.FAN_SPEED +_WATER = CleaningSetting.WATER_MODE +_ROUTE = CleaningSetting.MOP_ROUTE + + +@pytest.mark.parametrize( + ("overrides", "expected"), + [ + # Vacuum-only: no mop module, so only the fan speed. + ({"is_support_water_mode": False}, frozenset({_FAN})), + # Saros-like: shake module with fast route, mop-only tab and water slide. + ( + {"is_pure_clean_mop_supported": True, "is_water_slide_mode_supported": True}, + frozenset({_FAN, _WATER, _ROUTE}), + ), + # Shake module without fast route but with a mop-only tab: the route exists in mop mode. + ( + {"is_pure_clean_mop_supported": True, "is_clean_route_fast_mode_supported": False}, + frozenset({_FAN, _WATER, _ROUTE}), + ), + # Shake module without mop-only tab and without fast route: the route is never adjustable. + ( + {"is_pure_clean_mop_supported": False, "is_clean_route_fast_mode_supported": False}, + frozenset({_FAN, _WATER}), + ), + # Spin or roller mop: route setting without the shake module. + ({"is_shake_mop_set_supported": False, "is_pure_clean_mop_supported": True}, frozenset({_FAN, _WATER})), + ({"is_shake_mop_set_supported": False}, frozenset({_FAN, _WATER})), + # Clean efficiency only changes the route values. + ( + {"is_pure_clean_mop_supported": True, "is_clean_efficiency_supported": True}, + frozenset({_FAN, _WATER, _ROUTE}), + ), + # Max+ without a mop-only tab only changes the route values. + ({"is_none_pure_clean_mop_with_max_plus": True}, frozenset({_FAN, _WATER, _ROUTE})), + ], +) +def test_get_supported_settings(overrides: dict[str, bool], expected: frozenset[CleaningSetting]) -> None: + assert get_supported_settings(_features(**overrides)) == expected + + +_GRID_FLAGS = ( + "is_shake_mop_set_supported", + "is_clean_route_fast_mode_supported", + "is_pure_clean_mop_supported", + "is_support_water_mode", + "is_clean_route_setting_supported", + "is_clean_efficiency_supported", + "is_none_pure_clean_mop_with_max_plus", +) + + +@pytest.mark.parametrize("values", list(itertools.product((False, True), repeat=len(_GRID_FLAGS)))) +def test_supported_settings_match_adjustable_settings(values: tuple[bool, ...]) -> None: + """A setting is supported exactly when it can be adjusted in at least one reachable cleaning mode.""" + features = _features(**dict(zip(_GRID_FLAGS, values, strict=True))) + reachable: list[CleaningMode | None] = [ + mode + for mode in get_cleaning_mode_options(features) + if mode not in (CleaningMode.SMART_MODE, CleaningMode.CUSTOM) + ] or [None] + adjustable_somewhere: set[CleaningSetting] = set() + for mode in reachable: + adjustable_somewhere |= get_adjustable_settings(mode, features) + assert get_supported_settings(features) == adjustable_somewhere + + +@pytest.mark.parametrize( + ("fan", "water", "route", "expected"), + [ + # Custom wins over SmartPlan when both are reported. + (106, 202, 300, CleaningMode.CUSTOM), + (102, 204, 300, CleaningMode.CUSTOM), + (102, 202, 302, CleaningMode.CUSTOM), + (106, 209, 300, CleaningMode.CUSTOM), + (110, 202, 300, CleaningMode.SMART_MODE), + (102, 209, 300, CleaningMode.SMART_MODE), + (102, 202, 306, CleaningMode.SMART_MODE), + # Regular codes, including a water slide position and the fast route, are not special. + (102, 202, 300, None), + (102, 235, 304, None), + ], +) +def test_get_reported_special_mode(fan: int, water: int, route: int, expected: CleaningMode | None) -> None: + features = _features(is_pure_clean_mop_supported=True) + assert get_reported_special_mode(fan, water, route, features) == expected + + +@pytest.mark.parametrize( + ("fan", "water", "route", "expected"), + [ + # Without a mop only the fan power is read, so water and route codes do not count. + (102, 204, 300, None), + (102, 209, 306, None), + (110, 204, 302, CleaningMode.SMART_MODE), + (106, 209, 306, CleaningMode.CUSTOM), + ], +) +def test_get_reported_special_mode_ignores_water_and_route_without_mop( + fan: int, water: int, route: int, expected: CleaningMode | None +) -> None: + features = _features(is_support_water_mode=False) + assert get_reported_special_mode(fan, water, route, features) == expected diff --git a/tests/devices/__snapshots__/test_device_manager.ambr b/tests/devices/__snapshots__/test_device_manager.ambr index dadae5983..20747e4a3 100644 --- a/tests/devices/__snapshots__/test_device_manager.ambr +++ b/tests/devices/__snapshots__/test_device_manager.ambr @@ -294,6 +294,7 @@ 'isRpcRetrySupported': False, 'isRubberBrushCarpetSupported': False, 'isSetChildSupported': False, + 'isSetCleanMotorModeSupported': True, 'isSettingCarpetFirstSupported': False, 'isShakeMopSetSupported': False, 'isShouldShowArmOverLoadSupported': False, diff --git a/tests/devices/__snapshots__/test_file_cache.ambr b/tests/devices/__snapshots__/test_file_cache.ambr index b2025e5c2..13b92647b 100644 --- a/tests/devices/__snapshots__/test_file_cache.ambr +++ b/tests/devices/__snapshots__/test_file_cache.ambr @@ -1,6 +1,6 @@ # serializer version: 1 # name: test_set_and_flush_and_get[default-all_fields_cache] - CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) + CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_set_clean_motor_mode_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) # --- # name: test_set_and_flush_and_get[default-empty_cache] CacheData(home_data=None, device_info={}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) @@ -12,7 +12,7 @@ CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) # --- # name: test_set_and_flush_and_get[json-all_fields_cache] - CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) + CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_set_clean_motor_mode_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) # --- # name: test_set_and_flush_and_get[json-empty_cache] CacheData(home_data=None, device_info={}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) @@ -24,7 +24,7 @@ CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) # --- # name: test_set_and_flush_and_get[pickle-all_fields_cache] - CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) + CacheData(home_data=HomeData(id=123456, name='My Home', products=[HomeDataProduct(id='product-id-s7-maxv', name='Roborock S7 MaxV', model='roborock.vacuum.a27', category=, code='a27', icon_url=None, attribute=None, capability=0, schema=[HomeDataProductSchema(id='101', name='rpc_request', code='rpc_request_code', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='102', name='rpc_response', code='rpc_response', mode='rw', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='120', name='错误代码', code='error_code', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='121', name='设备状态', code='state', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='122', name='设备电量', code='battery', mode='ro', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='123', name='清扫模式', code='fan_power', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='124', name='拖地模式', code='water_box_mode', mode='rw', type='ENUM', product_property=None, property='{"range": []}', desc=None), HomeDataProductSchema(id='125', name='主刷寿命', code='main_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='126', name='边刷寿命', code='side_brush_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='127', name='滤网寿命', code='filter_life', mode='rw', type='VALUE', product_property=None, property='{"max": 100, "min": 0, "step": 1, "unit": null, "scale": 1}', desc=None), HomeDataProductSchema(id='128', name='额外状态', code='additional_props', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='130', name='完成事件', code='task_complete', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='131', name='电量不足任务取消', code='task_cancel_low_power', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='132', name='运动中任务取消', code='task_cancel_in_motion', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='133', name='充电状态', code='charge_status', mode='ro', type='RAW', product_property=None, property=None, desc=None), HomeDataProductSchema(id='134', name='烘干状态', code='drying_status', mode='ro', type='RAW', product_property=None, property=None, desc=None)])], devices=[HomeDataDevice(duid='abc123', name='Roborock S7 MaxV', local_key='key123key123key1', product_id='product-id-s7-maxv', fv='02.56.02', attribute=None, active_time=1672364449, runtime_env=None, time_zone_id='America/Los_Angeles', icon_url='no_url', lon=None, lat=None, share=False, share_time=None, online=True, pv='1.0', room_id=2362003, tuya_uuid=None, tuya_migrated=False, extra='{"RRPhotoPrivacyVersion": "1"}', sn='abc123', feature_set='2234201184108543', new_feature_set='0000000000002041', device_status={'121': 8, '122': 100, '123': 102, '124': 203, '125': 94, '126': 90, '127': 87, '128': 0, '133': 1, '120': 0}, silent_ota_switch=True, setting=None, f=None, create_time=None, cid=None, share_type=None, share_expired_time=None)], received_devices=[], lon=None, lat=None, geo_name=None, rooms=[HomeDataRoom(id=2362048, name='Example room 1'), HomeDataRoom(id=2362044, name='Example room 2'), HomeDataRoom(id=2362041, name='Example room 3')]), device_info={'device1': DeviceCacheData(network_info=NetworkInfo(ip='1.1.1.1', ssid='test_wifi', mac='aa:bb:cc:dd:ee:ff', bssid='aa:bb:cc:dd:ee:ff', rssi=-50), home_map_info={1: CombinedMapInfo(map_flag=1, name='Test Map 1', rooms=[NamedRoomMapping(segment_id=1023, iot_id='4321', raw_name='Living Room'), NamedRoomMapping(segment_id=1024, iot_id='4322', raw_name='Starship')]), 2: CombinedMapInfo(map_flag=2, name='Test Map 2', rooms=[NamedRoomMapping(segment_id=2047, iot_id='5432', raw_name='Bedroom')])}, home_map_content_base64={1: 'ZHVtbXlfbWFwX2NvbnRlbnQ=', 2: 'bW9yZV9kdW1teV9jb250ZW50'}, device_features=DeviceFeatures(is_show_clean_finish_reason_supported=True, is_re_segment_supported=False, is_video_monitor_supported=False, is_any_state_transit_goto_supported=False, is_fw_filter_obstacle_supported=False, is_video_setting_supported=False, is_ignore_unknown_map_object_supported=False, is_set_child_supported=False, is_carpet_supported=False, is_record_allowed=False, is_mop_path_supported=False, is_multi_map_segment_timer_supported=False, is_current_map_restore_enabled=False, is_room_name_supported=False, is_shake_mop_set_supported=False, is_map_beautify_internal_debug_supported=False, is_new_data_for_clean_history=False, is_new_data_for_clean_history_detail=False, is_flow_led_setting_supported=False, is_dust_collection_setting_supported=False, is_rpc_retry_supported=False, is_avoid_collision_supported=False, is_support_set_switch_map_mode=False, is_map_carpet_add_support=False, is_custom_water_box_distance_supported=False, is_support_smart_scene=False, is_support_floor_edit=False, is_support_furniture=False, is_wash_then_charge_cmd_supported=False, is_support_room_tag=False, is_support_quick_map_builder=False, is_support_smart_global_clean_with_custom_mode=False, is_careful_slow_mop_supported=False, is_egg_mode_supported_from_new_features=False, is_carpet_show_on_map=False, is_supported_valley_electricity=False, is_unsave_map_reason_supported=False, is_supported_drying=False, is_supported_download_test_voice=False, is_support_backup_map=False, is_support_custom_mode_in_cleaning=False, is_support_remote_control_in_call=False, is_support_set_volume_in_call=True, is_support_clean_estimate=False, is_support_custom_dnd=False, is_carpet_deep_clean_supported=False, is_support_stuck_zone=False, is_support_custom_door_sill=False, is_wifi_manage_supported=False, is_clean_route_fast_mode_supported=False, is_support_cliff_zone=False, is_support_smart_door_sill=False, is_support_floor_direction=False, is_back_charge_auto_wash_supported=False, is_support_incremental_map=False, is_offline_map_supported=False, is_super_deep_wash_supported=False, is_ces_2022_supported=False, is_dss_believable=False, is_main_brush_up_down_supported_from_str=False, is_goto_pure_clean_path_supported=False, is_water_up_down_drain_supported=False, is_setting_carpet_first_supported=False, is_clean_route_deep_slow_plus_supported=False, is_dynamically_skip_clean_zone_supported=False, is_dynamically_add_clean_zones_supported=False, is_left_water_drain_supported=False, is_clean_count_setting_supported=False, is_corner_clean_mode_supported=False, is_two_key_real_time_video_supported=False, is_two_key_rtv_in_charging_supported=False, is_dirty_replenish_clean_supported=False, is_auto_delivery_field_in_global_status_supported=False, is_avoid_collision_mode_supported=False, is_voice_control_supported=False, is_new_endpoint_supported=False, is_pumping_water_supported=False, is_corner_mop_stretch_supported=False, is_hot_wash_towel_supported=False, is_floor_dir_clean_any_time_supported=False, is_pet_supplies_deep_clean_supported=False, is_mop_shake_water_max_supported=False, is_exact_custom_mode_supported=False, is_video_patrol_supported=False, is_carpet_custom_clean_supported=False, is_pet_snapshot_supported=False, is_custom_clean_mode_count_supported=False, is_new_ai_recognition_supported=False, is_auto_collection_2_supported=False, is_right_brush_stretch_supported=False, is_smart_clean_mode_set_supported=False, is_dirty_object_detect_supported=False, is_no_need_carpet_press_set_supported=False, is_voice_control_led_supported=False, is_water_leak_check_supported=False, is_min_battery_15_to_clean_task_supported=False, is_gap_deep_clean_supported=False, is_object_detect_check_supported=False, is_identify_room_supported=False, is_matter_supported=False, is_workday_holiday_supported=False, is_clean_direct_status_supported=False, is_map_eraser_supported=False, is_optimize_battery_supported=False, is_activate_video_charging_and_standby_supported=False, is_carpet_long_haired_supported=False, is_clean_history_time_line_supported=False, is_max_zone_opened_supported=False, is_exhibition_function_supported=False, is_lds_lifting_supported=False, is_auto_tear_down_mop_supported=False, is_small_side_mop_supported=False, is_support_side_brush_up_down_supported=False, is_dry_interval_timer_supported=False, is_uvc_sterilize_supported=False, is_midway_back_to_dock_supported=False, is_support_main_brush_up_down_supported=False, is_egg_dance_mode_supported=False, is_mechanical_arm_mode_supported=False, is_tidyup_zones_supported=False, is_clean_time_line_supported=False, is_clean_then_mop_mode_supported=False, is_type_identify_supported=False, is_support_get_particular_status_supported=False, is_three_d_mapping_inner_test_supported=False, is_sync_server_name_supported=False, is_should_show_arm_over_load_supported=False, is_collect_dust_count_show_supported=False, is_support_api_app_stop_grasp_supported=False, is_ctm_with_repeat_supported=False, is_side_brush_lift_carpet_supported=False, is_detect_wire_carpet_supported=False, is_water_slide_mode_supported=False, is_soak_and_wash_supported=False, is_clean_efficiency_supported=False, is_back_wash_new_smart_supported=False, is_dual_band_wi_fi_supported=False, is_program_mode_supported=False, is_clean_fluid_delivery_supported=False, is_carpet_long_haired_ex_supported=False, is_over_sea_ctm_supported=False, is_full_duples_switch_supported=False, is_low_area_access_supported=False, is_follow_low_obs_supported=False, is_two_gears_no_collision_supported=False, is_carpet_shape_type_supported=False, is_sr_map_supported=False, is_roller_mop_supported=False, is_set_clean_motor_mode_supported=False, is_led_status_switch_supported=False, is_multi_floor_supported=False, is_support_fetch_timer_summary=False, is_order_clean_supported=False, is_analysis_supported=False, is_remote_supported=False, is_support_voice_control_debug=False, is_mop_forbidden_supported=True, is_soft_clean_mode_supported=True, is_custom_mode_supported=True, is_support_custom_carpet=True, is_show_general_obstacle_supported=True, is_show_obstacle_photo_supported=True, is_rubber_brush_carpet_supported=True, is_carpet_pressure_use_origin_paras_supported=True, is_support_mop_back_pwm_set=True, is_collect_dust_mode_supported=True, is_support_water_mode=False, is_ai_recognition_setting_supported=False, is_ai_recognition_obstacle_supported=False, is_pure_clean_mop_supported=False, is_new_remote_view_supported=False, is_max_plus_mode_supported=False, is_none_pure_clean_mop_with_max_plus=False, is_clean_route_setting_supported=False, is_mop_shake_module_supported=False, is_customized_clean_supported=False), trait_data={'test_trait': {'key': 'value', 'number': 42}}), 'device2': DeviceCacheData(network_info=None, home_map_info=None, home_map_content_base64=None, device_features=None, trait_data=None)}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) # --- # name: test_set_and_flush_and_get[pickle-empty_cache] CacheData(home_data=None, device_info={}, network_info={}, home_map_info={}, home_map_content={}, home_map_content_base64={}, device_features=None, trait_data=None) diff --git a/tests/devices/__snapshots__/test_v1_device.ambr b/tests/devices/__snapshots__/test_v1_device.ambr index bc0d8fdb3..2912e0a5b 100644 --- a/tests/devices/__snapshots__/test_v1_device.ambr +++ b/tests/devices/__snapshots__/test_v1_device.ambr @@ -322,6 +322,7 @@ 'isRpcRetrySupported': False, 'isRubberBrushCarpetSupported': False, 'isSetChildSupported': False, + 'isSetCleanMotorModeSupported': True, 'isSettingCarpetFirstSupported': False, 'isShakeMopSetSupported': False, 'isShouldShowArmOverLoadSupported': False, @@ -743,6 +744,7 @@ 'isRpcRetrySupported': False, 'isRubberBrushCarpetSupported': False, 'isSetChildSupported': False, + 'isSetCleanMotorModeSupported': True, 'isSettingCarpetFirstSupported': False, 'isShakeMopSetSupported': False, 'isShouldShowArmOverLoadSupported': False, @@ -876,7 +878,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, cleaning_mode_options=[, , , ], clear_water_box_status=None, collision_avoid_status=None, command=, common_status=None, converter=DefaultConverter, corner_clean_mode=None, current_cleaning_mode=, current_cleaning_mode_name='custom', 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_state=, dock_type=None, dry_status=None, dss=None, dust_bag_status=None, dust_collection_status=None, error_code=, 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=[, , , , , , ], has_am=None, hatch_door_status=None, home_sec_enable_password=None, home_sec_status=None, in_cleaning=, in_fresh_state=1, in_returning=0, in_warmup=None, is_battery_charging=False, 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=[, , ], msg_seq=515, msg_ver=2, rdt=None, repeat=None, replenish_mode=None, rss=None, square_meter_clean_area=91.3, state=, 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=[, , , , , ], 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, cleaning_mode_options=[, , , ], clear_water_box_status=None, collision_avoid_status=None, command=, common_status=None, converter=DefaultConverter, corner_clean_mode=None, current_cleaning_mode=, current_cleaning_mode_name='custom', 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_state=, dock_type=None, dry_status=None, dss=None, dust_bag_status=None, dust_collection_status=None, error_code=, error_code_name='none', fan_power=106, fan_speed_display_options=[], fan_speed_mapping={101: 'quiet', 102: 'balanced', 103: 'turbo', 104: 'max', 108: 'max_plus'}, fan_speed_name='custom', fan_speed_options=[, , , , ], has_am=None, hatch_door_status=None, home_sec_enable_password=None, home_sec_status=None, in_cleaning=, in_fresh_state=1, in_returning=0, in_warmup=None, is_battery_charging=False, is_exploring=None, is_fan_speed_adjustable=False, is_locating=0, is_mop_route_adjustable=False, is_water_mode_adjustable=False, 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_display_options=[], mop_route_mapping={}, mop_route_name=None, mop_route_options=[], msg_seq=515, msg_ver=2, rdt=None, repeat=None, replenish_mode=None, rss=None, square_meter_clean_area=91.3, state=, state_name='charging', subdivision_sets=None, supported_cleaning_settings=[, ], 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_display_options=[], water_mode_mapping={200: 'off', 201: 'mild', 202: 'standard', 203: 'intense', 207: 'custom_water_flow'}, water_mode_name='custom', water_mode_options=[, , , , ], water_shortage_status=None) # --- # name: test_device_trait_command_parsing[status].1 dict({ @@ -1171,6 +1173,7 @@ 'isRpcRetrySupported': False, 'isRubberBrushCarpetSupported': False, 'isSetChildSupported': False, + 'isSetCleanMotorModeSupported': True, 'isSettingCarpetFirstSupported': False, 'isShakeMopSetSupported': False, 'isShouldShowArmOverLoadSupported': False, @@ -1569,6 +1572,7 @@ 'isRpcRetrySupported': False, 'isRubberBrushCarpetSupported': False, 'isSetChildSupported': False, + 'isSetCleanMotorModeSupported': True, 'isSettingCarpetFirstSupported': False, 'isShakeMopSetSupported': False, 'isShouldShowArmOverLoadSupported': False, diff --git a/tests/devices/traits/v1/test_status.py b/tests/devices/traits/v1/test_status.py index 72274ca68..f4e449d0e 100644 --- a/tests/devices/traits/v1/test_status.py +++ b/tests/devices/traits/v1/test_status.py @@ -9,6 +9,7 @@ from roborock import ( CleaningMode, + CleaningSetting, CleanRoutes, VacuumModes, WaterModes, @@ -56,6 +57,8 @@ def _create_cleaning_mode_status_trait(**feature_overrides: bool) -> StatusTrait features.is_pure_clean_mop_supported = True features.is_customized_clean_supported = True features.is_clean_route_setting_supported = True + features.is_shake_mop_set_supported = True + features.is_clean_route_fast_mode_supported = True for feature_name, value in feature_overrides.items(): if not hasattr(features, feature_name): raise AttributeError(f"Unknown DeviceFeatures override: {feature_name}") @@ -285,9 +288,99 @@ def test_feature_aware_dock_and_charging_state( assert status_trait.is_battery_charging is expected_is_battery_charging +@pytest.mark.parametrize( + ("fan", "water", "mop", "expected"), + [ + (110, 209, 306, (False, False, False)), + (106, 204, 302, (False, False, False)), + (102, 200, 300, (True, False, True)), + (102, 202, 300, (True, True, True)), + (105, 202, 300, (False, True, True)), + ], +) +def test_adjustable_settings_per_mode(fan: int, water: int, mop: int, expected: tuple[bool, bool, bool]) -> None: + trait = _create_cleaning_mode_status_trait(is_smart_clean_mode_set_supported=True, is_shake_mop_set_supported=True) + trait.fan_power, trait.water_box_mode, trait.mop_mode = fan, water, mop + assert (trait.is_fan_speed_adjustable, trait.is_water_mode_adjustable, trait.is_mop_route_adjustable) == expected + + +@pytest.mark.parametrize( + ("route_flag", "shake", "expected_options", "expected_adjustable"), + [ + (True, True, True, True), + (False, True, False, True), + # The route is only offered with the shake module, even when the model lists routes. + (True, False, False, False), + (False, False, False, False), + ], +) +def test_mop_route_needs_shake_module( + route_flag: bool, shake: bool, expected_options: bool, expected_adjustable: bool +) -> None: + trait = _create_cleaning_mode_status_trait( + is_shake_mop_set_supported=shake, is_clean_route_setting_supported=route_flag + ) + trait.fan_power, trait.water_box_mode, trait.mop_mode = 105, 202, 300 # MOP + assert trait.is_mop_route_adjustable is expected_adjustable + assert bool(trait.mop_route_options) is expected_options + assert bool(trait.mop_route_display_options) is (expected_adjustable and expected_options) + + +@pytest.mark.parametrize( + ("codes", "expected"), + [ + ((110, 209, 306), ([VacuumModes.SMART_MODE], [WaterModes.SMART_MODE], [CleanRoutes.SMART_MODE])), + ((106, 204, 302), ([VacuumModes.CUSTOMIZED], [WaterModes.CUSTOMIZED], [CleanRoutes.CUSTOMIZED])), + ], +) +def test_display_options_locked_in_special_modes( + codes: tuple[int, int, int], + expected: tuple[list[VacuumModes], list[WaterModes], list[CleanRoutes]], +) -> None: + trait = _create_cleaning_mode_status_trait(is_smart_clean_mode_set_supported=True, is_custom_mode_supported=True) + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + assert ( + trait.fan_speed_display_options, + trait.water_mode_display_options, + trait.mop_route_display_options, + ) == expected + # The current value's name is among the options to show (HA SelectEntity.state). + assert trait.water_mode_name in {m.display_name for m in trait.water_mode_display_options} + + +def test_display_options_regular_and_hidden() -> None: + trait = _create_cleaning_mode_status_trait() + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 200, 300 # VACUUM + assert trait.fan_speed_display_options == trait.fan_speed_options + assert trait.water_mode_display_options == [] + + +@pytest.mark.parametrize("codes", [(110, 209, 306), (106, 204, 302)]) +def test_mop_route_display_options_empty_without_route_setting(codes: tuple[int, int, int]) -> None: + """A device without a route setting shows no routes, even in SmartPlan or custom mode.""" + trait = _create_cleaning_mode_status_trait( + is_smart_clean_mode_set_supported=True, + is_custom_mode_supported=True, + is_clean_route_setting_supported=False, + ) + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + assert trait.mop_route_display_options == [] + assert trait.water_mode_display_options != [] + + +def test_vacuum_only_device_fan_adjustable() -> None: + trait = _create_cleaning_mode_status_trait(is_support_water_mode=False) + trait.fan_power = 102 + assert (trait.is_fan_speed_adjustable, trait.is_water_mode_adjustable) == (True, False) + + def test_options(status_trait: StatusTrait) -> None: """Test that fan_speed_options returns a list of options.""" - status_trait._device_features_trait.is_clean_route_setting_supported = True + features = status_trait._device_features_trait + features.is_support_water_mode = True + features.is_shake_mop_set_supported = True + features.is_pure_clean_mop_supported = True + features.is_clean_route_setting_supported = True assert isinstance(status_trait.fan_speed_options, list) assert len(status_trait.fan_speed_options) > 0 assert isinstance(status_trait.water_mode_options, list) @@ -351,8 +444,10 @@ def test_spin_mop_without_runtime_shake_has_mop_route_options() -> None: assert not features.is_shake_mop_set_supported assert features.is_clean_route_setting_supported - assert CleanRoutes.STANDARD in status_trait.mop_route_options - assert CleanRoutes.DEEP in status_trait.mop_route_options + # Without the shake module the route is never offered, so no route list is reported. + assert status_trait.mop_route_options == [] + assert status_trait.mop_route_mapping == {} + assert CleaningSetting.MOP_ROUTE not in status_trait.supported_cleaning_settings assert get_cleaning_mode_parameters(CleaningMode.VAC_AND_MOP, features)[0]["mop_mode"] == 300 @@ -595,7 +690,7 @@ def test_get_cleaning_mode_parameters_qrevo_edge_2() -> None: "mop_mode": CleanRoutes.STANDARD.code, } ] - assert VacuumModes.OFF in status_trait.fan_speed_options + assert 105 not in {mode.code for mode in status_trait.fan_speed_options} assert VacuumModes.OFF_RAISE_MAIN_BRUSH not in status_trait.fan_speed_options @@ -688,7 +783,9 @@ def test_current_cleaning_mode_water_slide_legacy_codes( water_box_mode: int | None, expected_mode: CleaningMode | None ) -> None: """Keep legacy and unknown status decoding on water-slide devices.""" - status_trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + status_trait = _create_cleaning_mode_status_trait( + is_water_slide_mode_supported=True, is_smart_clean_mode_set_supported=True + ) status_trait.fan_power = 102 status_trait.water_box_mode = water_box_mode status_trait.mop_mode = 300 @@ -787,21 +884,80 @@ async def test_set_cleaning_mode_water_slide_wire_payload( mock_rpc_channel.send_command.assert_called_once_with(RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[expected]) -def test_cleaning_mode_options_water_slide_device() -> None: - """Water-slide devices should not expose unsupported custom or smart water modes.""" +@pytest.mark.parametrize("water_slide", [False, True]) +@pytest.mark.parametrize( + ("custom", "smart", "extra"), + [ + (True, True, [CleaningMode.CUSTOM, CleaningMode.SMART_MODE]), + (False, True, [CleaningMode.SMART_MODE]), + (True, False, [CleaningMode.CUSTOM]), + (False, False, []), + ], +) +def test_cleaning_mode_options_follow_app_flags( + water_slide: bool, custom: bool, smart: bool, extra: list[CleaningMode] +) -> None: + """Custom and SmartPlan options depend only on their feature flags, also on water-slide devices.""" status_trait = _create_cleaning_mode_status_trait( - is_water_slide_mode_supported=True, - is_customized_clean_supported=True, - is_smart_clean_mode_set_supported=True, + is_water_slide_mode_supported=water_slide, + is_custom_mode_supported=custom, # the helper keeps is_customized_clean_supported=True + is_smart_clean_mode_set_supported=smart, ) assert status_trait.cleaning_mode_options == [ CleaningMode.VACUUM, CleaningMode.VAC_AND_MOP, CleaningMode.MOP, + *extra, ] +def test_cleaning_mode_options_custom_needs_customized_clean() -> None: + """Custom mode is not offered without the customized-clean feature, even if the model allows it.""" + status_trait = _create_cleaning_mode_status_trait( + is_custom_mode_supported=True, + is_customized_clean_supported=False, + ) + + assert CleaningMode.CUSTOM not in status_trait.cleaning_mode_options + + +def test_mixed_custom_and_smart_codes_are_custom() -> None: + """Custom wins over SmartPlan when the codes mix both.""" + trait = _create_cleaning_mode_status_trait(is_custom_mode_supported=True, is_smart_clean_mode_set_supported=True) + trait.fan_power, trait.water_box_mode, trait.mop_mode = 106, 209, 300 + + assert trait.current_cleaning_mode == CleaningMode.CUSTOM + + +@pytest.mark.parametrize( + ("features", "codes"), + [ + ({"is_custom_mode_supported": False}, (106, 204, 302)), + ({"is_smart_clean_mode_set_supported": False}, (110, 209, 306)), + ], +) +def test_current_mode_outside_options_is_none(features: dict[str, bool], codes: tuple[int, int, int]) -> None: + """A mode that the device does not offer is not reported as the current mode.""" + trait = _create_cleaning_mode_status_trait(**features) + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + + assert trait.current_cleaning_mode is None + + +def test_saros_10r_smartplan_is_listed() -> None: + """The Saros 10R SmartPlan codes classify as SmartPlan, which is among the options.""" + trait = _create_cleaning_mode_status_trait( + is_water_slide_mode_supported=True, + is_custom_mode_supported=True, + is_smart_clean_mode_set_supported=True, + ) + trait.fan_power, trait.water_box_mode, trait.mop_mode = 110, 209, 306 + + assert trait.current_cleaning_mode == CleaningMode.SMART_MODE + assert trait.current_cleaning_mode in trait.cleaning_mode_options + + def test_current_cleaning_mode_gentle_not_mop_without_pure_mop() -> None: """Test code 105 is not treated as mop-only on devices without pure mop.""" status_trait = _create_cleaning_mode_status_trait(is_pure_clean_mop_supported=False) @@ -884,6 +1040,66 @@ def test_water_slide_mode_name_covers_slider_positions(water_box_mode: int, expe assert status_trait.water_mode_name == expected_name +def test_option_lists_exclude_special_codes() -> None: + """SmartPlan and custom codes are never offered as fan, water or mop route choices.""" + trait = _create_cleaning_mode_status_trait(is_smart_clean_mode_set_supported=True) + special = {106, 110, 204, 209, 302, 306} + assert special.isdisjoint(m.code for m in trait.fan_speed_options) + assert special.isdisjoint(m.code for m in trait.water_mode_options) + assert special.isdisjoint(m.code for m in trait.mop_route_options) + assert special.isdisjoint(trait.fan_speed_mapping) + assert special.isdisjoint(trait.water_mode_mapping) + assert special.isdisjoint(trait.mop_route_mapping) + + +@pytest.mark.parametrize("water_slide", [False, True]) +@pytest.mark.parametrize( + ("fan", "water", "mop", "names"), + [ + (110, 209, 306, ("smart_mode", "smart_mode", "smart_mode")), + (106, 204, 302, ("custom", "custom", "custom")), + ], +) +def test_special_code_names(water_slide: bool, fan: int, water: int, mop: int, names: tuple[str, str, str]) -> None: + """Special codes are still named even though they are not selectable.""" + trait = _create_cleaning_mode_status_trait( + is_smart_clean_mode_set_supported=True, is_water_slide_mode_supported=water_slide + ) + trait.fan_power, trait.water_box_mode, trait.mop_mode = fan, water, mop + assert (trait.fan_speed_name, trait.water_mode_name, trait.mop_route_name) == names + + +def test_water_slide_raw_position_name_unchanged() -> None: + """Raw slider positions keep resolving to their app range name.""" + trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + trait.water_box_mode = 227 + assert trait.water_mode_name == "low" + + +@pytest.mark.parametrize( + ("soft", "pure_mop", "in_list", "name"), + [ + (True, False, True, "gentle"), + (True, True, True, "gentle"), + (False, True, False, "off"), + (False, False, False, "gentle"), + ], +) +def test_fan_code_105(soft: bool, pure_mop: bool, in_list: bool, name: str) -> None: + """Code 105 is only selectable as gentle on soft-clean devices but is always named.""" + trait = _create_cleaning_mode_status_trait(is_soft_clean_mode_supported=soft, is_pure_clean_mop_supported=pure_mop) + trait.fan_power = 105 + assert (105 in {m.code for m in trait.fan_speed_options}) is in_list + assert trait.fan_speed_name == name + + +def test_unknown_codes_have_no_name() -> None: + """Codes that are neither selectable nor special have no name.""" + trait = _create_cleaning_mode_status_trait() + trait.fan_power, trait.water_box_mode, trait.mop_mode = 999, 999, 999 + assert (trait.fan_speed_name, trait.water_mode_name, trait.mop_route_name) == (None, None, None) + + def test_update_from_dps(status_trait: StatusTrait) -> None: """Test updating status from data protocol push message.""" assert status_trait.battery is None @@ -956,3 +1172,520 @@ def test_update_listener_ignores_unrelated(status_trait: StatusTrait) -> None: assert not event.is_set() unsubscribe() + + +async def test_leave_smartplan_without_shake_resets_route(mock_rpc_channel: AsyncMock) -> None: + """Without a route setting the route is still reset to standard when leaving SmartPlan.""" + trait = _create_cleaning_mode_status_trait( + is_smart_clean_mode_set_supported=True, + is_shake_mop_set_supported=False, + is_set_clean_motor_mode_supported=False, + is_clean_route_setting_supported=False, + ) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 110, 209, 306 + await trait.set_cleaning_mode(CleaningMode.VAC_AND_MOP) + + assert mock_rpc_channel.send_command.call_args_list == [ + call(RoborockCommand.SET_CUSTOM_MODE, params=[102]), + call(RoborockCommand.SET_WATER_BOX_CUSTOM_MODE, params=[202]), + call(RoborockCommand.SET_MOP_MODE, params=[300]), + ] + assert trait.current_cleaning_mode == CleaningMode.VAC_AND_MOP + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (102, 202, 300) + + +async def test_set_cleaning_mode_without_route_keeps_mop_mode(mock_rpc_channel: AsyncMock) -> None: + """When no route is sent the cached route is left alone.""" + trait = _create_cleaning_mode_status_trait(is_clean_route_setting_supported=False, is_shake_mop_set_supported=False) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.mop_mode = 300 + await trait.set_cleaning_mode(CleaningMode.VACUUM) + + assert mock_rpc_channel.send_command.call_args_list == [ + call(RoborockCommand.SET_CUSTOM_MODE, params=[102]), + call(RoborockCommand.SET_WATER_BOX_CUSTOM_MODE, params=[200]), + ] + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (102, 200, 300) + + +async def test_set_cleaning_mode_notifies_listeners_once(mock_rpc_channel: AsyncMock) -> None: + """Every command is sent first and listeners are notified a single time afterwards.""" + trait = _create_cleaning_mode_status_trait(is_shake_mop_set_supported=False, is_set_clean_motor_mode_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.mop_mode = 306 # SmartPlan route, reset to standard + updates: list[None] = [] + trait.add_update_listener(lambda: updates.append(None)) + await trait.set_cleaning_mode(CleaningMode.VAC_AND_MOP) + + assert mock_rpc_channel.send_command.call_args_list == [ + call(RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 202}]), + call(RoborockCommand.SET_MOP_MODE, params=[300]), + ] + assert len(updates) == 1 + + +async def test_set_cleaning_mode_failure_keeps_fields(mock_rpc_channel: AsyncMock) -> None: + """An exception mid-sequence stops sending and leaves the cached status unchanged.""" + trait = _create_cleaning_mode_status_trait( + is_shake_mop_set_supported=False, is_set_clean_motor_mode_supported=False + ) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 110, 209, 306 + updates: list[None] = [] + trait.add_update_listener(lambda: updates.append(None)) + mock_rpc_channel.send_command.side_effect = ["ok", RoborockException("boom"), "ok"] + + with pytest.raises(RoborockException, match="boom"): + await trait.set_cleaning_mode(CleaningMode.VAC_AND_MOP) + + assert mock_rpc_channel.send_command.call_count == 2 + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (110, 209, 306) + assert updates == [] + + +async def test_set_water_mode_saros_vac_and_mop(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 103, 225, 301 + updates: list[None] = [] + trait.add_update_listener(lambda: updates.append(None)) + await trait.set_water_mode(WaterModes.PURE_WATER_FLOW_MIDDLE) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 103, "water_box_mode": 235, "mop_mode": 300}] + ) + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (103, 235, 300) + assert len(updates) == 1 + + +@pytest.mark.parametrize( + ("call_name", "arg"), + [("set_fan_speed", VacuumModes.MAX), ("set_water_mode", WaterModes.HIGH), ("set_mop_route", CleanRoutes.DEEP)], +) +async def test_setters_refuse_in_smartplan(mock_rpc_channel: AsyncMock, call_name: str, arg: VacuumModes) -> None: + trait = _create_cleaning_mode_status_trait(is_smart_clean_mode_set_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 110, 209, 306 + with pytest.raises(RoborockUnsupportedFeature): + await getattr(trait, call_name)(arg) + mock_rpc_channel.send_command.assert_not_called() + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (110, 209, 306) + + +async def test_mop_only_water_change_keeps_105_and_fan_refused(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 105, 202, 300 + + await trait.set_water_mode(WaterModes.HIGH) + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 105, "water_box_mode": 203, "mop_mode": 300}] + ) + + mock_rpc_channel.send_command.reset_mock() + with pytest.raises(RoborockUnsupportedFeature): + await trait.set_fan_speed(VacuumModes.MAX) + mock_rpc_channel.send_command.assert_not_called() + + +async def test_set_water_mode_accepts_aliased_code(mock_rpc_channel: AsyncMock) -> None: + """HIGH shares code 203 with INTENSE, which is what the shake-mop model lists.""" + trait = _create_cleaning_mode_status_trait() + assert WaterModes.HIGH not in trait.water_mode_options + assert WaterModes.INTENSE in trait.water_mode_options + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + + await trait.set_water_mode(WaterModes.HIGH) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 203, "mop_mode": 300}] + ) + assert trait.water_box_mode == 203 + + +async def test_set_water_mode_slide_accepts_any_slider_code(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait(is_water_slide_mode_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 225, 300 + + await trait.set_water_mode(WaterModes.PURE_WATER_FLOW_START) # 221, the lowest slider position + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 221, "mop_mode": 300}] + ) + + +async def test_set_mop_route_refused_without_shake(mock_rpc_channel: AsyncMock) -> None: + """Without the shake module the model offers no route choice, so the library does not send it.""" + trait = _create_cleaning_mode_status_trait(is_shake_mop_set_supported=False, is_set_clean_motor_mode_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + + with pytest.raises(RoborockUnsupportedFeature): + await trait.set_mop_route(CleanRoutes.DEEP) + + mock_rpc_channel.send_command.assert_not_called() + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (102, 202, 300) + + +_SAROS_10R_FEATURES = { + "is_water_slide_mode_supported": True, + "is_careful_slow_mop_supported": True, + "is_max_plus_mode_supported": True, +} + + +_SLIDE_WATER_WITHOUT_OFF = [ + WaterModes.PURE_WATER_FLOW_START, + WaterModes.PURE_WATER_FLOW_SMALL, + WaterModes.PURE_WATER_FLOW_GENTLE, + WaterModes.PURE_WATER_FLOW_MIDDLE, + WaterModes.PURE_WATER_FLOW_LARGE, + WaterModes.PURE_WATER_SUPER_BEGIN, + WaterModes.PURE_WATER_FLOW_END, +] + + +@pytest.mark.parametrize( + ("codes", "expected"), + [ + # VAC_AND_MOP: no Max+, routes fast and standard only, no OFF. + ( + (102, 235, 300), + ( + [VacuumModes.QUIET, VacuumModes.BALANCED, VacuumModes.TURBO, VacuumModes.MAX], + {CleanRoutes.FAST, CleanRoutes.STANDARD}, + _SLIDE_WATER_WITHOUT_OFF, + ), + ), + # VACUUM: Max+ is offered, routes fast and standard only. + ( + (102, 200, 300), + ( + [VacuumModes.QUIET, VacuumModes.BALANCED, VacuumModes.TURBO, VacuumModes.MAX, VacuumModes.MAX_PLUS], + {CleanRoutes.FAST, CleanRoutes.STANDARD}, + [], + ), + ), + # MOP: no fan speed, the full route list. + ( + (105, 235, 300), + ( + [], + {CleanRoutes.STANDARD, CleanRoutes.DEEP, CleanRoutes.DEEP_PLUS, CleanRoutes.FAST}, + _SLIDE_WATER_WITHOUT_OFF, + ), + ), + ], +) +def test_display_options_follow_the_cleaning_mode( + codes: tuple[int, int, int], + expected: tuple[list[VacuumModes], set[CleanRoutes], list[WaterModes]], +) -> None: + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + assert trait.fan_speed_display_options == expected[0] + assert set(trait.mop_route_display_options) == expected[1] + assert trait.water_mode_display_options == expected[2] + + +@pytest.mark.parametrize( + ("overrides", "expected_fan"), + [ + ({"is_pure_clean_mop_supported": False, "is_none_pure_clean_mop_with_max_plus": True}, True), + ({"is_pure_clean_mop_supported": False, "is_max_plus_mode_supported": True}, False), + ], +) +def test_max_plus_without_sub_tabs(overrides: dict[str, bool], expected_fan: bool) -> None: + trait = _create_cleaning_mode_status_trait(**overrides) + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + assert (VacuumModes.MAX_PLUS in trait.fan_speed_display_options) is expected_fan + + +@pytest.mark.parametrize( + ("call_name", "arg", "codes"), + [ + ("set_mop_route", CleanRoutes.DEEP, (102, 235, 300)), + ("set_fan_speed", VacuumModes.MAX_PLUS, (102, 235, 300)), + ("set_water_mode", WaterModes.OFF, (102, 235, 300)), + ("set_mop_route", CleanRoutes.DEEP, (102, 200, 300)), + ("set_fan_speed", VacuumModes.MAX_PLUS, (105, 235, 300)), + ], +) +async def test_setters_refuse_values_outside_the_mode_list( + mock_rpc_channel: AsyncMock, call_name: str, arg: VacuumModes | CleanRoutes | WaterModes, codes: tuple[int, ...] +) -> None: + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + with pytest.raises(RoborockUnsupportedFeature): + await getattr(trait, call_name)(arg) + mock_rpc_channel.send_command.assert_not_called() + + +async def test_set_fan_speed_max_plus_in_vacuum(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 200, 300 + + await trait.set_fan_speed(VacuumModes.MAX_PLUS) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 108, "water_box_mode": 200, "mop_mode": 300}] + ) + + +async def test_set_mop_route_fast_in_vacuum(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 103, 200, 300 + + await trait.set_mop_route(CleanRoutes.FAST) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 103, "water_box_mode": 200, "mop_mode": 304}] + ) + assert trait.mop_mode == 304 + + +async def test_set_water_mode_replaces_deep_route_left_by_older_client(mock_rpc_channel: AsyncMock) -> None: + """The robot rejects route 301 in vacuum and mop, so it is sent as standard.""" + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 235, 301 + + await trait.set_water_mode(WaterModes.PURE_WATER_FLOW_LARGE) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 240, "mop_mode": 300}] + ) + assert trait.mop_mode == 300 + + +async def test_set_cleaning_mode_replaces_values_from_the_previous_tab(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 108, 200, 300 + + await trait.set_cleaning_mode(CleaningMode.VAC_AND_MOP) + + sent = mock_rpc_channel.send_command.call_args.kwargs["params"][0] + assert sent["fan_power"] == 102 + assert sent["mop_mode"] == 300 + + +async def test_set_fan_speed_vac_and_mop(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + + await trait.set_fan_speed(VacuumModes.MAX) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 104, "water_box_mode": 202, "mop_mode": 300}] + ) + assert trait.fan_power == 104 + + +@pytest.mark.parametrize( + ("call_name", "arg"), [("set_fan_speed", VacuumModes.SMART_MODE), ("set_mop_route", CleanRoutes.CUSTOMIZED)] +) +async def test_setters_refuse_special_values(mock_rpc_channel: AsyncMock, call_name: str, arg: VacuumModes) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + with pytest.raises(RoborockUnsupportedFeature): + await getattr(trait, call_name)(arg) + mock_rpc_channel.send_command.assert_not_called() + + +@pytest.mark.parametrize( + ("call_name", "arg"), + [("set_fan_speed", VacuumModes.MAX), ("set_water_mode", WaterModes.HIGH), ("set_mop_route", CleanRoutes.DEEP)], +) +async def test_setters_require_loaded_status(mock_rpc_channel: AsyncMock, call_name: str, arg: VacuumModes) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + with pytest.raises(RoborockException, match="Status is not loaded"): + await getattr(trait, call_name)(arg) + mock_rpc_channel.send_command.assert_not_called() + + +async def test_setter_failure_keeps_fields(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 + updates: list[None] = [] + trait.add_update_listener(lambda: updates.append(None)) + mock_rpc_channel.send_command.side_effect = RoborockException("boom") + + with pytest.raises(RoborockException, match="boom"): + await trait.set_fan_speed(VacuumModes.MAX) + + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (102, 202, 300) + assert updates == [] + + +async def test_set_fan_speed_vacuum_only(mock_rpc_channel: AsyncMock) -> None: + """A vacuum without a mop has no water mode and only receives the fan command.""" + trait = _create_cleaning_mode_status_trait(is_support_water_mode=False, is_shake_mop_set_supported=True) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power = 102 + assert trait.water_box_mode is None + + await trait.set_fan_speed(VacuumModes.MAX) + + mock_rpc_channel.send_command.assert_called_once_with(RoborockCommand.SET_CUSTOM_MODE, params=[104]) + assert trait.fan_power == 104 + assert trait.water_box_mode is None + + +async def test_set_water_mode_refuses_off_while_mopping_only(mock_rpc_channel: AsyncMock) -> None: + trait = _create_cleaning_mode_status_trait() + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 105, 202, 300 + with pytest.raises(RoborockUnsupportedFeature): + await trait.set_water_mode(WaterModes.OFF) + mock_rpc_channel.send_command.assert_not_called() + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (105, 202, 300) + + +async def test_water_can_be_turned_on_without_mode_tabs(mock_rpc_channel: AsyncMock) -> None: + """Without a mop-only tab a water-off state is still the general tab, so water stays adjustable.""" + trait = _create_cleaning_mode_status_trait(is_pure_clean_mop_supported=False) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 200, 300 + assert trait.current_cleaning_mode == CleaningMode.VACUUM + assert trait.is_water_mode_adjustable + assert WaterModes.OFF in trait.water_mode_display_options + + await trait.set_water_mode(WaterModes.HIGH) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 203, "mop_mode": 300}] + ) + + +def test_vacuum_without_a_mop_keeps_max_plus() -> None: + trait = _create_cleaning_mode_status_trait(is_support_water_mode=False, is_max_plus_mode_supported=True) + trait.fan_power = 102 + assert VacuumModes.MAX_PLUS in trait.fan_speed_display_options + + +async def test_setters_send_no_route_without_shake(mock_rpc_channel: AsyncMock) -> None: + """Without the shake module no route is sent, even when the model has a route setting.""" + trait = _create_cleaning_mode_status_trait( + is_shake_mop_set_supported=False, is_set_clean_motor_mode_supported=True, is_clean_route_setting_supported=True + ) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 102, 202, 300 # VAC_AND_MOP + + await trait.set_water_mode(WaterModes.HIGH) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 203}] + ) + assert (trait.fan_power, trait.water_box_mode, trait.mop_mode) == (102, 203, 300) + + +async def test_set_mop_route_replaces_the_mop_only_fan_code_left_in_vacuum(mock_rpc_channel: AsyncMock) -> None: + """Fan code 105 outside mopping only is replaced by balanced, like Max+.""" + trait = _create_cleaning_mode_status_trait(**_SAROS_10R_FEATURES) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = 105, 200, 300 + assert trait.current_cleaning_mode == CleaningMode.VACUUM + + await trait.set_mop_route(CleanRoutes.FAST) + + mock_rpc_channel.send_command.assert_called_once_with( + RoborockCommand.SET_CLEAN_MOTOR_MODE, params=[{"fan_power": 102, "water_box_mode": 200, "mop_mode": 304}] + ) + + +@pytest.mark.parametrize("codes", [(110, 209, 306), (106, 204, 302)]) +def test_mop_route_special_values_need_shake(codes: tuple[int, int, int]) -> None: + """Without the shake module no route is listed, not even the SmartPlan or custom value.""" + trait = _create_cleaning_mode_status_trait( + is_smart_clean_mode_set_supported=True, is_custom_mode_supported=True, is_shake_mop_set_supported=False + ) + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + assert trait.mop_route_options == [] + assert trait.mop_route_display_options == [] + assert trait.water_mode_display_options != [] + + +_FAN = CleaningSetting.FAN_SPEED +_WATER = CleaningSetting.WATER_MODE +_ROUTE = CleaningSetting.MOP_ROUTE + + +@pytest.mark.parametrize( + ("overrides", "expected"), + [ + ({"is_support_water_mode": False}, {_FAN}), + ({"is_water_slide_mode_supported": True}, {_FAN, _WATER, _ROUTE}), + ({"is_clean_route_fast_mode_supported": False}, {_FAN, _WATER, _ROUTE}), + ({"is_pure_clean_mop_supported": False, "is_clean_route_fast_mode_supported": False}, {_FAN, _WATER}), + ({"is_shake_mop_set_supported": False}, {_FAN, _WATER}), + ({"is_clean_efficiency_supported": True}, {_FAN, _WATER, _ROUTE}), + ( + {"is_pure_clean_mop_supported": False, "is_none_pure_clean_mop_with_max_plus": True}, + {_FAN, _WATER, _ROUTE}, + ), + ], +) +def test_supported_cleaning_settings(overrides: dict[str, bool], expected: set[CleaningSetting]) -> None: + """The option lists and mappings are empty exactly for the settings the model does not have.""" + trait = _create_cleaning_mode_status_trait(**overrides) + assert trait.supported_cleaning_settings == [setting for setting in CleaningSetting if setting in expected] + assert bool(trait.fan_speed_options) and bool(trait.fan_speed_mapping) + assert bool(trait.water_mode_options) is (_WATER in expected) + assert bool(trait.water_mode_mapping) is (_WATER in expected) + assert bool(trait.mop_route_options) is (_ROUTE in expected) + assert bool(trait.mop_route_mapping) is (_ROUTE in expected) + # The cleaning mode select exists exactly when the model has a mop. + assert bool(trait.cleaning_mode_options) is (_WATER in expected) + + +@pytest.mark.parametrize( + ("codes", "expected_fan", "expected_water", "expected_route"), + [ + ((106, 204, 302), VacuumModes.CUSTOMIZED, WaterModes.CUSTOMIZED, CleanRoutes.CUSTOMIZED), + ((110, 209, 306), VacuumModes.SMART_MODE, WaterModes.SMART_MODE, CleanRoutes.SMART_MODE), + ], +) +@pytest.mark.parametrize( + ("setter_name", "value"), + [ + ("set_fan_speed", VacuumModes.TURBO), + ("set_water_mode", WaterModes.STANDARD), + ("set_mop_route", CleanRoutes.STANDARD), + ], +) +async def test_reported_special_mode_without_support_flags( + mock_rpc_channel: AsyncMock, + codes: tuple[int, int, int], + expected_fan: VacuumModes, + expected_water: WaterModes, + expected_route: CleanRoutes, + setter_name: str, + value: VacuumModes | WaterModes | CleanRoutes, +) -> None: + """SmartPlan or custom codes put the robot in that mode, even when the model lacks the support flags.""" + trait = _create_cleaning_mode_status_trait(is_smart_clean_mode_set_supported=False, is_custom_mode_supported=False) + trait._rpc_channel = mock_rpc_channel # type: ignore[assignment] + trait.fan_power, trait.water_box_mode, trait.mop_mode = codes + + assert trait.current_cleaning_mode is None + assert trait.fan_speed_display_options == [expected_fan] + assert trait.water_mode_display_options == [expected_water] + assert trait.mop_route_display_options == [expected_route] + assert not trait.is_fan_speed_adjustable + assert not trait.is_water_mode_adjustable + assert not trait.is_mop_route_adjustable + setter = getattr(trait, setter_name) + with pytest.raises(RoborockUnsupportedFeature): + await setter(value) + mock_rpc_channel.send_command.assert_not_called() diff --git a/tests/test_supported_features.py b/tests/test_supported_features.py index b427ccc5d..c6ead35da 100644 --- a/tests/test_supported_features.py +++ b/tests/test_supported_features.py @@ -416,3 +416,33 @@ def test_device_features_from_home_data( ) feature_dict = {k: v for k, v in asdict(device_features).items() if isinstance(v, bool)} assert feature_dict == snapshot + + +@pytest.mark.parametrize( + ("nickname", "custom", "soft"), + [ + (RoborockProductNickname.TANOS, False, True), + (RoborockProductNickname.RUBYPLUS, False, False), + (RoborockProductNickname.RUBYSC, False, True), + (RoborockProductNickname.RUBYSE, False, True), + (RoborockProductNickname.RUBYSLITE, True, True), + (RoborockProductNickname.TANOSV, True, True), + (RoborockProductNickname.PEARL, True, False), + ], +) +def test_custom_and_soft_clean_mode_model_lists(nickname: RoborockProductNickname, custom: bool, soft: bool) -> None: + """Custom and soft clean mode model lists match the Roborock app.""" + features = DeviceFeatures.from_feature_flags( + new_feature_info=0, new_feature_info_str="", feature_info=[], product_nickname=nickname + ) + assert features.is_custom_mode_supported is custom + assert features.is_soft_clean_mode_supported is soft + + +@pytest.mark.parametrize(("feature_info", "expected"), [([118], True), ([], False)]) +def test_set_clean_motor_mode_supported(feature_info: list[int], expected: bool) -> None: + """Robot feature 118 means fan_power and water_box_mode are sent together in set_clean_motor_mode.""" + features = DeviceFeatures.from_feature_flags( + new_feature_info=0, new_feature_info_str="", feature_info=feature_info, product_nickname=None + ) + assert features.is_set_clean_motor_mode_supported is expected