chore: more debug logs and error handling

Author: Lash-L

roborock/devices/b01_channel.py

@@ -33,8 +33,14 @@ async def send_decoded_command(
 
     Note: B01 "set" commands may return a scalar (e.g. 0/"ok") rather than a dict.
     """
-    _LOGGER.debug("Sending MQTT command: %s", params)
     msg_id = str(get_next_int(100000000000, 999999999999))
+    _LOGGER.debug(
+        "Sending B01 MQTT command: dps=%s method=%s msg_id=%s params=%s",
+        dps,
+        command,
+        msg_id,
+        params,
+    )
     roborock_message = encode_mqtt_payload(dps, command, params, msg_id)
     future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
 
@@ -43,7 +49,13 @@ def find_response(response_message: RoborockMessage) -> None:
         try:
             decoded_dps = decode_rpc_response(response_message)
         except RoborockException as ex:
-            _LOGGER.info("Failed to decode b01 message: %s: %s", response_message, ex)
+            _LOGGER.debug(
+                "Failed to decode B01 RPC response (expecting method=%s msg_id=%s): %s: %s",
+                command,
+                msg_id,
+                response_message,
+                ex,
+            )
             return
 
         for dps_value in decoded_dps.values():
@@ -60,11 +72,27 @@ def find_response(response_message: RoborockMessage) -> None:
 
             if isinstance(inner, dict) and inner.get("msgId") == msg_id:
                 _LOGGER.debug("Received query response: %s", inner)
+                # Check for error code (0 = success, non-zero = error)
+                code = inner.get("code", 0)
+                if code != 0:
+                    error_msg = (
+                        f"B01 command failed with code {code} "
+                        f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                    )
+                    _LOGGER.debug("B01 error response: %s", error_msg)
+                    if not future.done():
+                        future.set_exception(RoborockException(error_msg))
+                    return
                 data = inner.get("data")
                 # All get commands should be dicts
                 if command.endswith(".get") and not isinstance(data, dict):
                     if not future.done():
-                        future.set_exception(RoborockException("Unexpected data type for response"))
+                        future.set_exception(
+                            RoborockException(
+                                f"Unexpected data type for response "
+                                f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                            )
+                        )
                     return
                 if not future.done():
                     future.set_result(data)
@@ -76,9 +104,18 @@ def find_response(response_message: RoborockMessage) -> None:
         await mqtt_channel.publish(roborock_message)
         return await asyncio.wait_for(future, timeout=_TIMEOUT)
     except TimeoutError as ex:
-        raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
+        raise RoborockException(
+            f"B01 command timed out after {_TIMEOUT}s (method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+        ) from ex
     except Exception as ex:
-        _LOGGER.exception("Error sending decoded command: %s", ex)
+        _LOGGER.exception(
+            "Error sending B01 decoded command (method=%s msg_id=%s dps=%s params=%s): %s",
+            command,
+            msg_id,
+            dps,
+            params,
+            ex,
+        )
         raise
     finally:
         unsub()

tests/devices/traits/b01/test_init.py

@@ -172,6 +172,39 @@ async def test_send_decoded_command_non_dict_response(fake_channel: FakeChannel)
             await send_decoded_command(fake_channel, 10000, "prop.get", [])  # type: ignore[arg-type]
 
 
+async def test_send_decoded_command_error_code(fake_channel: FakeChannel):
+    """Test that non-zero error codes from device are properly handled."""
+    msg_id = "999888777"
+    error_code = 5001
+
+    dps_payload = {
+        "dps": {
+            "10000": json.dumps(
+                {
+                    "msgId": msg_id,
+                    "code": error_code,
+                    "data": {},
+                }
+            )
+        }
+    }
+    message = RoborockMessage(
+        protocol=RoborockMessageProtocol.RPC_RESPONSE,
+        payload=pad(
+            json.dumps(dps_payload).encode(),
+            AES.block_size,
+        ),
+        version=b"B01",
+        seq=2022,
+    )
+
+    fake_channel.response_queue.append(message)
+
+    with patch("roborock.devices.b01_channel.get_next_int", return_value=int(msg_id)):
+        with pytest.raises(RoborockException, match=f"B01 command failed with code {error_code}"):
+            await send_decoded_command(fake_channel, 10000, "prop.get", [])  # type: ignore[arg-type]
+
+
 async def test_q7_api_set_fan_speed(q7_api: Q7PropertiesApi, fake_channel: FakeChannel):
     """Test setting fan speed."""
     msg_id = "12345"