pyheltycloud 0.2.0__tar.gz → 0.2.2__tar.gz

{pyheltycloud-0.2.0/src/pyheltycloud.egg-info → pyheltycloud-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyheltycloud
-Version: 0.2.0
+Version: 0.2.2
 Summary: Async client for the Helty cloud (hcloud) of Helty Flow VMC units
 Author: Ermanno Baschiera
 License-Expression: MIT

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyheltycloud"
-version = "0.2.0"
+version = "0.2.2"
 description = "Async client for the Helty cloud (hcloud) of Helty Flow VMC units"
 readme = "README.md"
 requires-python = ">=3.12"

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2}/src/pyheltycloud/auth.py

@@ -26,6 +26,19 @@ import aiohttp
 
 from .exceptions import HeltyCloudAuthError, HeltyCloudConnectionError
 
+#: Cognito errors that mean the credentials themselves were refused. Anything
+#: else it answers with, like throttling or its own internal errors, is a
+#: passing failure: reporting it as bad credentials would send the user to
+#: re-enter a password that is still right.
+CREDENTIAL_ERRORS = frozenset(
+    {
+        "NotAuthorizedException",
+        "PasswordResetRequiredException",
+        "UserNotConfirmedException",
+        "UserNotFoundException",
+    }
+)
+
 # 3072-bit prime and generator, fixed by the Cognito protocol.
 N_HEX = (
     "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74"
@@ -195,8 +208,11 @@ class CognitoSrpAuth:
             raise HeltyCloudConnectionError(f"{target}: unexpected answer {text[:200]}")
 
         if status != 200:
-            message = body.get("message") or body.get("__type") or str(body)
-            raise HeltyCloudAuthError(f"{target}: {message}")
+            error_type = str(body.get("__type", "")).rpartition("#")[2]
+            message = body.get("message") or error_type or str(body)
+            if error_type in CREDENTIAL_ERRORS:
+                raise HeltyCloudAuthError(f"{target}: {message}")
+            raise HeltyCloudConnectionError(f"{target}: {message}")
         return body
 
     def _password_key(self, username: str, password: str, srp_b_hex: str, salt_hex: str) -> bytes:

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2}/src/pyheltycloud/client.py

@@ -51,9 +51,16 @@ REFRESH_TIMEOUT = 15.0
 #: always find something without asking the cloud to scan a long window.
 DEFAULT_HISTORY_HOURS = 2
 
-#: Rows to ask for. Only the newest is used; a few spare ones cover the
-#: acks and other commands that share the history.
-HISTORY_PAGE_SIZE = 5
+#: How long to wait before reading the history once more to confirm a
+#: command. The two telemetries that answer a command can share a second
+#: and need not become visible together: a second read lets the late one
+#: show up.
+CONFIRM_SETTLE_DELAY = 2.0
+
+#: Rows to ask for. Only the newest second is used, but it can hold the
+#: acks of the commands next to two telemetries: a command sent seconds
+#: after another left five rows in a row on a live board.
+HISTORY_PAGE_SIZE = 10
 
 
 class HeltyCloud:
@@ -85,6 +92,7 @@ class HeltyCloud:
         )
         self._tokens: Tokens | None = None
         self._lock = asyncio.Lock()
+        self._command_locks: dict[str, asyncio.Lock] = {}
 
     def _ensure_started(self) -> tuple[aiohttp.ClientSession, CognitoSrpAuth]:
         """Session and auth, created lazily inside the current event loop."""
@@ -203,6 +211,20 @@ class HeltyCloud:
         self, serial_number: str, hours: int = DEFAULT_HISTORY_HOURS
     ) -> HeltyState:
         """Last state from the raw history: includes fans and alarms."""
+        return (await self._newest_telemetry(serial_number, hours))[0]
+
+    async def _newest_telemetry(
+        self, serial_number: str, hours: int = DEFAULT_HISTORY_HOURS
+    ) -> list[HeltyState]:
+        """Every telemetry that carries the newest timestamp, in cloud order.
+
+        The cloud stamps the history to the second and gives the rows no id,
+        and the board answers a command with two telemetries, one of its own
+        and one for the refresh that follows: when they land in the same
+        second there is no telling which came last. They normally agree, but
+        a board that drops a command can leave one with the new mode and one
+        with the old, so callers that confirm a command must see them all.
+        """
         now = int(time.time() * 1000)
         page = await self._post(
             EP_COMMAND_LOGS,
@@ -226,8 +248,12 @@ class HeltyCloud:
         # The cloud happens to return the newest first, but nothing documents
         # it, and update() decides whether the board answered by comparing
         # timestamps: pick the newest explicitly.
-        newest = max(rows, key=lambda row: row.get("timestamp") or 0)
-        return HeltyState.from_telemetry(newest["data"], newest.get("timestamp"))
+        newest = max(row.get("timestamp") or 0 for row in rows)
+        return [
+            HeltyState.from_telemetry(row["data"], row.get("timestamp"))
+            for row in rows
+            if (row.get("timestamp") or 0) == newest
+        ]
 
     async def update(self, device: HeltyDevice) -> HeltyState:
         """Fetch the current state: ask the board to report, then read.
@@ -239,23 +265,13 @@ class HeltyCloud:
         to read at all.
         """
         try:
-            last = await self.get_last_telemetry(device.serial_number)
+            last: HeltyState | None = await self.get_last_telemetry(device.serial_number)
         except HeltyCloudNoDataError:
             last = None
 
-        await self.refresh(device.board_serial)
-
-        loop = asyncio.get_running_loop()
-        deadline = loop.time() + REFRESH_TIMEOUT
-        while loop.time() < deadline:
-            await asyncio.sleep(REFRESH_POLL_INTERVAL)
-            try:
-                state = await self.get_last_telemetry(device.serial_number)
-            except HeltyCloudNoDataError:
-                continue
-            if last is None or (state.timestamp or 0) > (last.timestamp or 0):
-                return state
-
+        states = await self._fresh_telemetry(device, after=_timestamp(last))
+        if states is not None:
+            return states[0]
         if last is not None:
             _LOGGER.debug(
                 "Board %s did not answer the refresh: using the last known data",
@@ -266,6 +282,28 @@ class HeltyCloud:
             f"No telemetry for {device.serial_number}, even after a refresh"
         )
 
+    async def _fresh_telemetry(
+        self, device: HeltyDevice, after: int | None
+    ) -> list[HeltyState] | None:
+        """Ask the board to report and wait for a second newer than `after`.
+
+        `after` None accepts any telemetry. Returns None if nothing newer
+        arrives within REFRESH_TIMEOUT.
+        """
+        await self.refresh(device.board_serial)
+
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + REFRESH_TIMEOUT
+        while loop.time() < deadline:
+            await asyncio.sleep(REFRESH_POLL_INTERVAL)
+            try:
+                states = await self._newest_telemetry(device.serial_number)
+            except HeltyCloudNoDataError:
+                continue
+            if after is None or (_timestamp(states[0]) or 0) > after:
+                return states
+        return None
+
     # -- writing -----------------------------------------------------------
 
     async def send_command(self, board_serial: str, command: Command) -> None:
@@ -300,17 +338,47 @@ class HeltyCloud:
 
         Returns the state reflecting the requested mode. Raises
         HeltyCloudError if after `attempts` sends the VMC has not applied it.
+
+        Only telemetry newer than what the history held before the send
+        counts, and every telemetry of its second must carry the mode, on
+        two reads CONFIRM_SETTLE_DELAY apart: an old report, or one half of
+        a pair that disagrees, says nothing about this command. Calls for
+        the same board run one at a time, so the retries of an older call
+        never land after a newer command.
         """
-        for attempt in range(1, attempts + 1):
-            await self.set_mode(device.board_serial, mode)
-            state = await self.update(device)
-            if state.mode is mode:
-                return state
-            _LOGGER.debug(
-                "Command %s not applied by %s (attempt %d/%d)",
-                mode.name,
-                device.serial_number,
-                attempt,
-                attempts,
-            )
+        lock = self._command_locks.setdefault(device.board_serial, asyncio.Lock())
+        async with lock:
+            try:
+                seen = _timestamp(await self.get_last_telemetry(device.serial_number))
+            except HeltyCloudNoDataError:
+                seen = None
+
+            for attempt in range(1, attempts + 1):
+                await self.set_mode(device.board_serial, mode)
+                states = await self._fresh_telemetry(device, after=seen)
+                if states is not None:
+                    seen = _timestamp(states[0])
+                    if _all_in_mode(states, mode):
+                        await asyncio.sleep(CONFIRM_SETTLE_DELAY)
+                        states = await self._newest_telemetry(device.serial_number)
+                        seen = _timestamp(states[0])
+                        if _all_in_mode(states, mode):
+                            return states[0]
+                _LOGGER.debug(
+                    "Command %s not confirmed by %s (attempt %d/%d)",
+                    mode.name,
+                    device.serial_number,
+                    attempt,
+                    attempts,
+                )
         raise HeltyCloudError(f"The VMC did not apply mode {mode.name} after {attempts} attempts")
+
+
+def _timestamp(state: HeltyState | None) -> int | None:
+    """Timestamp of a state, None when there is no state."""
+    return None if state is None else state.timestamp or 0
+
+
+def _all_in_mode(states: list[HeltyState], mode: VmcMode) -> bool:
+    """Whether every telemetry of a second reports the mode."""
+    return all(state.mode is mode for state in states)

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2/src/pyheltycloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyheltycloud
-Version: 0.2.0
+Version: 0.2.2
 Summary: Async client for the Helty cloud (hcloud) of Helty Flow VMC units
 Author: Ermanno Baschiera
 License-Expression: MIT

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2}/tests/test_auth_flow.py

@@ -94,6 +94,38 @@ async def test_wrong_password_is_auth_error(auth: CognitoSrpAuth, cloud: FakeClo
         await auth.authenticate("user@example.com", "wrong")
 
 
+@pytest.mark.parametrize(
+    ("status", "error_type"),
+    [
+        (400, "TooManyRequestsException"),
+        (400, "LimitExceededException"),
+        (500, "InternalErrorException"),
+        (500, "com.amazonaws.cognito#InternalErrorException"),
+    ],
+)
+async def test_passing_cognito_failure_is_not_an_auth_error(
+    auth: CognitoSrpAuth, cloud: FakeCloud, status: int, error_type: str
+) -> None:
+    """Throttling or an outage must not look like a wrong password."""
+    cloud.reply_sequence(
+        COGNITO_PATH, [(200, CHALLENGE), (status, {"__type": error_type, "message": "busy"})]
+    )
+    with pytest.raises(HeltyCloudConnectionError, match="busy"):
+        await auth.authenticate("user@example.com", "secret")
+
+
+@pytest.mark.parametrize(
+    "error_type",
+    ["UserNotFoundException", "PasswordResetRequiredException", "UserNotConfirmedException"],
+)
+async def test_refused_account_is_auth_error(
+    auth: CognitoSrpAuth, cloud: FakeCloud, error_type: str
+) -> None:
+    cloud.reply(COGNITO_PATH, {"__type": error_type, "message": "refused"}, status=400)
+    with pytest.raises(HeltyCloudAuthError, match="refused"):
+        await auth.authenticate("user@example.com", "secret")
+
+
 async def test_unexpected_challenge(auth: CognitoSrpAuth, cloud: FakeCloud) -> None:
     """Should they ever enable MFA, better a clear error."""
     cloud.reply(COGNITO_PATH, {"ChallengeName": "SMS_MFA", "ChallengeParameters": {}})

{pyheltycloud-0.2.0 → pyheltycloud-0.2.2}/tests/test_client.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import asyncio
 import time
+from collections.abc import Callable
 from typing import Any
 
 import pytest
@@ -16,7 +18,7 @@ from pyheltycloud import (
     HeltyCloudNoDataError,
     VmcMode,
 )
-from pyheltycloud.const import EP_COMMAND_LOGS, EP_INSTALLATIONS, EP_LAST_STATUS
+from pyheltycloud.const import EP_COMMAND_LOGS, EP_INSTALLATIONS, EP_LAST_STATUS, MODE_COMMANDS
 
 from .conftest import (
     BOARD_SERIAL,
@@ -231,52 +233,267 @@ async def test_update_without_any_telemetry(
         await client.update(device)
 
 
-async def test_set_mode_verified_retries_lost_command(
-    client: HeltyCloud,
-    cloud: FakeCloud,
-    installation: dict[str, Any],
-    telemetry: list[Any],
-    monkeypatch: pytest.MonkeyPatch,
+class FakeBoard:
+    """A panel behind the fake cloud, with a history that moves.
+
+    Every mode command leaves its ack and then its telemetries in the
+    history the way a live board does, one clock tick (a second for the
+    cloud) per command, and a refresh adds a telemetry with the current
+    mode. Tests script the misbehaviour through `on_mode`, which returns
+    the modes of the telemetries a mode command leaves (empty: the command
+    is lost), through `answers_refresh`, and through `delayed`: rows that
+    become visible only on the read after the one they were added for.
+    """
+
+    def __init__(self, cloud: FakeCloud, telemetry: list[Any], mode: VmcMode) -> None:
+        """Take over the command and history paths of the fake cloud."""
+        self.telemetry = telemetry
+        self.mode = mode
+        self.clock = 0
+        self.rows: list[dict[str, Any]] = []
+        self.delayed: list[dict[str, Any]] = []
+        self.answers_refresh = True
+        self.on_mode: Callable[[VmcMode], list[VmcMode]] = self.apply
+        self.sent: list[int] = []
+        cloud.reply_with(SEND_PATH, self._command)
+        cloud.reply_with("/log/commandlogs/search", self._search)
+
+    def apply(self, mode: VmcMode) -> list[VmcMode]:
+        """Default behaviour: switch mode and report it once."""
+        self.mode = mode
+        return [mode]
+
+    def row(self, mode: VmcMode) -> dict[str, Any]:
+        data = self.telemetry.copy()
+        data[1] = int(mode)
+        return {"commandId": 0, "timestamp": self.clock, "data": data}
+
+    def _command(self, body: Any) -> tuple[int, Any]:
+        command = body["commandId"]
+        self.sent.append(command)
+        if command == Command.GET_STATUS:
+            if self.answers_refresh:
+                self.rows.append(self.row(self.mode))
+            return (200, {})
+        self.clock += 1
+        self.rows.append({"commandId": command, "timestamp": self.clock, "data": []})
+        mode = next(m for m, c in MODE_COMMANDS.items() if c == command)
+        self.rows.extend(self.row(m) for m in self.on_mode(mode))
+        return (200, {})
+
+    def _search(self, body: Any) -> tuple[int, Any]:
+        visible = list(self.rows)
+        # Rows held back on this read join the history for the next one.
+        self.rows.extend(self.delayed)
+        self.delayed = []
+        newest_first = sorted(visible, key=lambda row: -row["timestamp"])
+        return (200, {"data": newest_first[: body["pageSize"]]})
+
+
+def _lose_first(board: FakeBoard) -> Callable[[VmcMode], list[VmcMode]]:
+    """Drop the first mode command and apply the others."""
+    lost = [True]
+
+    def on_mode(mode: VmcMode) -> list[VmcMode]:
+        if lost:
+            lost.pop()
+            return []
+        return board.apply(mode)
+
+    return on_mode
+
+
+async def test_get_last_telemetry_with_tied_rows_keeps_cloud_order(
+    client: HeltyCloud, cloud: FakeCloud, telemetry: list[Any]
 ) -> None:
-    """A command lost by the cloud is resent until the state reflects it."""
-    # Timeout 0: update() only reads the history, without waiting, so the
-    # test controls exactly which telemetry each attempt sees.
-    monkeypatch.setattr("pyheltycloud.client.REFRESH_TIMEOUT", 0)
-    ignored = telemetry.copy()
-    ignored[1] = int(VmcMode.SPEED_2)
-    cloud.reply(EP_INSTALLATIONS, [installation])
-    cloud.reply_sequence(
+    """Polling still reads the first of the telemetries sharing the newest second."""
+    other = telemetry.copy()
+    other[1] = int(VmcMode.SPEED_4)
+    cloud.reply(
         "/log/commandlogs/search",
-        [_search_reply(1, ignored), _search_reply(2, telemetry)],
+        {"data": [{"commandId": 0, "timestamp": 7, "data": data} for data in (telemetry, other)]},
     )
-    device = (await client.get_devices())[0]
+    state = await client.get_last_telemetry(SERIAL)
+    assert state.mode is VmcMode.NIGHT
+
+
+@pytest.fixture
+def fast(monkeypatch: pytest.MonkeyPatch) -> None:
+    """No real waits, and a short deadline for a board that stays silent."""
+    monkeypatch.setattr("pyheltycloud.client.REFRESH_POLL_INTERVAL", 0)
+    monkeypatch.setattr("pyheltycloud.client.CONFIRM_SETTLE_DELAY", 0)
+    monkeypatch.setattr("pyheltycloud.client.REFRESH_TIMEOUT", 0.05)
+
+
+async def _device(client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any]) -> Any:
+    cloud.reply(EP_INSTALLATIONS, [installation])
+    return (await client.get_devices())[0]
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_confirms_at_once(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_1)
+    board.rows.append(board.row(VmcMode.SPEED_1))
+    device = await _device(client, cloud, installation)
+
+    state = await client.set_mode_verified(device, VmcMode.NIGHT)
+
+    assert state.mode is VmcMode.NIGHT
+    assert board.sent.count(Command.NIGHT) == 1
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_with_empty_history(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """With nothing in the history yet, the first report confirms."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_1)
+    device = await _device(client, cloud, installation)
+
+    state = await client.set_mode_verified(device, VmcMode.NIGHT)
+
+    assert state.mode is VmcMode.NIGHT
+    assert board.sent.count(Command.NIGHT) == 1
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_retries_lost_command(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """A command lost on the way is resent until the board reports it."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_2)
+    board.rows.append(board.row(VmcMode.SPEED_2))
+    board.on_mode = _lose_first(board)
+    device = await _device(client, cloud, installation)
+
     state = await client.set_mode_verified(device, VmcMode.NIGHT)
 
     assert state.mode is VmcMode.NIGHT
-    night_commands = [
-        r for r in cloud.requests if r.path == SEND_PATH and r.json["commandId"] == Command.NIGHT
-    ]
-    assert len(night_commands) == 2
+    assert board.sent.count(Command.NIGHT) == 2
 
 
+@pytest.mark.usefixtures("fast")
 async def test_set_mode_verified_gives_up(
-    client: HeltyCloud,
-    cloud: FakeCloud,
-    installation: dict[str, Any],
-    telemetry: list[Any],
-    monkeypatch: pytest.MonkeyPatch,
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
 ) -> None:
-    monkeypatch.setattr("pyheltycloud.client.REFRESH_TIMEOUT", 0)
-    ignored = telemetry.copy()
-    ignored[1] = int(VmcMode.SPEED_2)
-    cloud.reply(EP_INSTALLATIONS, [installation])
-    cloud.reply(
-        "/log/commandlogs/search",
-        {"data": [{"commandId": 0, "timestamp": 1, "data": ignored}]},
-    )
-    device = (await client.get_devices())[0]
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_2)
+    board.rows.append(board.row(VmcMode.SPEED_2))
+    board.on_mode = lambda mode: []
+    device = await _device(client, cloud, installation)
+
     with pytest.raises(HeltyCloudError, match="NIGHT"):
         await client.set_mode_verified(device, VmcMode.NIGHT, attempts=2)
+    assert board.sent.count(Command.NIGHT) == 2
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_ignores_stale_history(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """A history that already shows the mode does not confirm a lost command."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_4)
+    board.rows.append(board.row(VmcMode.SPEED_1))
+    board.on_mode = lambda mode: []
+    board.answers_refresh = False
+    device = await _device(client, cloud, installation)
+
+    with pytest.raises(HeltyCloudError, match="SPEED_1"):
+        await client.set_mode_verified(device, VmcMode.SPEED_1, attempts=2)
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_resends_on_disagreeing_tie(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """A tie between the new mode and the old one does not confirm the command.
+
+    Seen on a live board: asked for speed 1 seconds after speed 4, it kept
+    speed 4 but left two telemetries in the same second, the first with the
+    new mode and the second with the old, and then stayed silent.
+    """
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_4)
+    board.rows.append(board.row(VmcMode.SPEED_4))
+    dropped = [True]
+
+    def drop_first(mode: VmcMode) -> list[VmcMode]:
+        if dropped:
+            dropped.pop()
+            return [mode, board.mode]
+        board.mode = mode
+        return [mode, mode]
+
+    board.on_mode = drop_first
+    board.answers_refresh = False
+    device = await _device(client, cloud, installation)
+
+    state = await client.set_mode_verified(device, VmcMode.SPEED_1)
+
+    assert state.mode is VmcMode.SPEED_1
+    assert board.sent.count(Command.SPEED_1) == 2
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_waits_for_the_late_half_of_a_tie(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """The old-mode twin of a telemetry can show up a read later: no early yes."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_4)
+    board.rows.append(board.row(VmcMode.SPEED_4))
+    dropped = [True]
+
+    def drop_first_late(mode: VmcMode) -> list[VmcMode]:
+        if dropped:
+            dropped.pop()
+            board.delayed.append(board.row(board.mode))
+            return [mode]
+        return board.apply(mode)
+
+    board.on_mode = drop_first_late
+    board.answers_refresh = False
+    device = await _device(client, cloud, installation)
+
+    state = await client.set_mode_verified(device, VmcMode.SPEED_1)
+
+    assert state.mode is VmcMode.SPEED_1
+    assert board.sent.count(Command.SPEED_1) == 2
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_accepts_agreeing_tie(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """The usual pair of telemetries in the same second confirms at once."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_1)
+    board.rows.append(board.row(VmcMode.SPEED_1))
+    board.on_mode = lambda mode: [*board.apply(mode), mode]
+    device = await _device(client, cloud, installation)
+
+    await client.set_mode_verified(device, VmcMode.NIGHT)
+
+    assert board.sent.count(Command.NIGHT) == 1
+
+
+@pytest.mark.usefixtures("fast")
+async def test_set_mode_verified_serializes_commands_per_board(
+    client: HeltyCloud, cloud: FakeCloud, installation: dict[str, Any], telemetry: list[Any]
+) -> None:
+    """The retries of an older call never land after a newer command."""
+    board = FakeBoard(cloud, telemetry, VmcMode.SPEED_1)
+    board.rows.append(board.row(VmcMode.SPEED_1))
+    board.on_mode = _lose_first(board)
+    device = await _device(client, cloud, installation)
+
+    speed_4 = asyncio.create_task(client.set_mode_verified(device, VmcMode.SPEED_4))
+    await asyncio.sleep(0)
+    speed_1 = asyncio.create_task(client.set_mode_verified(device, VmcMode.SPEED_1))
+    await asyncio.gather(speed_4, speed_1)
+
+    first_speed_1 = board.sent.index(Command.SPEED_1)
+    assert Command.SPEED_4 not in board.sent[first_speed_1:]
+    assert board.sent.count(Command.SPEED_4) == 2
+    assert board.mode is VmcMode.SPEED_1
 
 
 def test_constructor_needs_no_event_loop() -> None: