lr-shuttle 0.2.8__tar.gz → 0.2.10__tar.gz

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.8
+Version: 0.2.10
 Summary: CLI and Python client for host-side of json based serial communication with embedded device bridge.
 Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
 License: MIT

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-shuttle"
-version = "0.2.8"
+version = "0.2.10"
 description = "CLI and Python client for host-side of json based serial communication with embedded device bridge."
 readme = "README.md"
 requires-python = ">=3.11"

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/src/lr_shuttle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.8
+Version: 0.2.10
 Summary: CLI and Python client for host-side of json based serial communication with embedded device bridge.
 Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
 License: MIT

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/src/lr_shuttle.egg-info/SOURCES.txt

@@ -28,5 +28,6 @@ tests/test_flash.py
 tests/test_prodtest_edge.py
 tests/test_prodtest_helpers.py
 tests/test_serial_client.py
+tests/test_serial_client_flush.py
 tests/test_timo.py
 tests/test_timo_write.py

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/src/shuttle/cli.py

@@ -151,6 +151,19 @@ def _handle_sys_error_event(event: Dict[str, Any]) -> None:
     console.print(f"[red]{' '.join(parts)}[/]")
 
 
+def _flush_client_input(client) -> None:
+    """Best-effort drain any unread serial noise before issuing commands."""
+
+    flush = getattr(client, "flush_input_and_log", None)
+    if flush is None:
+        return
+    try:
+        flush()
+    except Exception:
+        # Flushing is opportunistic; failures should not leak into CLI flows.
+        pass
+
+
 @contextmanager
 def _open_serial_client(
     resolved_port: str,
@@ -767,6 +780,9 @@ def _execute_timo_sequence(
                 logger=logger,
                 seq_tracker=seq_tracker,
             ) as client:
+                # Drain any pending serial noise before issuing commands, to avoid
+                # mixing stale data into NDJSON responses.
+                _flush_client_input(client)
                 for transfer in sequence:
                     response = client.spi_xfer(**transfer)
                     responses.append(response)
@@ -2634,6 +2650,7 @@ def spi_enable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 response = client.spi_enable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -2668,6 +2685,7 @@ def spi_disable_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 response = client.spi_disable()
         except ShuttleSerialError as exc:
             console.print(f"[red]{exc}[/]")
@@ -3138,6 +3156,7 @@ def power_command(
                 logger=resources.get("logger"),
                 seq_tracker=resources.get("seq_tracker"),
             ) as client:
+                _flush_client_input(client)
                 method = getattr(client, method_name)
                 response = method()
         except ShuttleSerialError as exc:
@@ -3171,6 +3190,11 @@ def flash_command(
         "--erase-first/--no-erase-first",
         help="Erase the entire flash before writing",
     ),
+    sleep_after_flash: float = typer.Option(
+        1.25,
+        "--sleep-after-flash",
+        help="Seconds to wait after flashing to allow device reboot",
+    ),
 ):
     """Flash the bundled firmware image to the devboard."""
 
@@ -3194,6 +3218,24 @@ def flash_command(
             console.print(f"[red]{exc}[/]")
             raise typer.Exit(1) from exc
 
+    if sleep_after_flash:
+        time.sleep(
+            sleep_after_flash
+        )  # Give the device a moment to reboot. 0.75s is sometimes too short.
+
+    # After flashing, drain/log any startup output from the device before further commands
+    logger = ctx.obj["logger"] if ctx.obj and "logger" in ctx.obj else None
+    try:
+        from .serial_client import NDJSONSerialClient
+
+        # Use a short timeout just for draining
+        with NDJSONSerialClient(
+            resolved_port, baudrate=baudrate, timeout=0.5, logger=logger
+        ) as client:
+            _flush_client_input(client)
+    except Exception:
+        pass
+
     label = str(manifest.get("label", board))
     console.print(
         f"[green]Successfully flashed {label} ({board}) over {resolved_port}[/]"

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/src/shuttle/serial_client.py

@@ -253,7 +253,7 @@ class NDJSONSerialClient:
         except AttributeError:
             # Test stubs without an open() method are already "connected"
             pass
-        self._serial.reset_input_buffer()
+        self._reset_input_buffer()
         self._lock = threading.Lock()
         self._pending: Dict[int, CommandFuture] = {}
         self._response_backlog: Dict[int, Dict[str, Any]] = {}
@@ -281,9 +281,41 @@ class NDJSONSerialClient:
         if getattr(self, "_serial", None) and self._serial.is_open:
             self._serial.close()
 
+    def _reset_input_buffer(self) -> None:
+        serial_obj = getattr(self, "_serial", None)
+        if serial_obj is None:
+            return
+        reset = getattr(serial_obj, "reset_input_buffer", None)
+        if reset is None:
+            return
+        try:
+            reset()
+        except SerialException:
+            pass
+
+    def flush_input_and_log(self):
+        """Read and log all available data from the serial buffer before sending a command."""
+        if not hasattr(self, "_serial"):
+            return
+        try:
+            while True:
+                waiting = getattr(self._serial, "in_waiting", 0)
+                if not waiting:
+                    break
+                data = self._serial.read(waiting)
+                if data:
+                    self._log_serial("RX", data)
+        except Exception:
+            pass
+        finally:
+            self._reset_input_buffer()
+
     def send_command(self, op: str, params: Dict[str, Any]) -> CommandFuture:
         """Send a command without blocking, returning a future for the response."""
 
+        # Flush and log any unread data before sending a command
+        self.flush_input_and_log()
+
         cmd_id = self._next_cmd_id()
         message: Dict[str, Any] = {"type": "cmd", "id": cmd_id, "op": op}
         message.update(params)
@@ -457,28 +489,37 @@ class NDJSONSerialClient:
         self._log_serial("TX", payload)
 
     def _read(self) -> Optional[Dict[str, Any]]:
-        try:
-            line = self._serial.readline()
-        except SerialException as exc:  # pragma: no cover - hardware specific
-            raise ShuttleSerialError(f"Serial read failed: {exc}") from exc
-        if not line:
-            return None
-        self._log_serial("RX", line)
-        stripped = line.strip()
-        if not stripped:
-            return None
-        try:
-            decoded = stripped.decode("utf-8")
-        except UnicodeDecodeError as exc:
-            raise ShuttleSerialError(f"Invalid UTF-8 from device: {exc}") from exc
-        try:
-            message = json.loads(decoded)
-        except json.JSONDecodeError as exc:
-            raise ShuttleSerialError(
-                f"Invalid JSON from device: {decoded} ({exc})"
-            ) from exc
-        self._record_sequence(message)
-        return message
+        while True:
+            try:
+                line = self._serial.readline()
+            except SerialException as exc:  # pragma: no cover - hardware specific
+                raise ShuttleSerialError(f"Serial read failed: {exc}") from exc
+            if not line:
+                return None
+            self._log_serial("RX", line)
+            stripped = line.strip()
+            if not stripped:
+                return None
+            try:
+                decoded = stripped.decode("utf-8")
+            except UnicodeDecodeError as exc:
+                self._reset_input_buffer()
+                raise ShuttleSerialError(f"Invalid UTF-8 from device: {exc}") from exc
+            trimmed = decoded.lstrip()
+            if not trimmed:
+                continue
+            if trimmed[0] not in ("{", "["):
+                self._reset_input_buffer()
+                continue
+            try:
+                message = json.loads(decoded)
+            except json.JSONDecodeError as exc:
+                self._reset_input_buffer()
+                raise ShuttleSerialError(
+                    f"Invalid JSON from device: {decoded} ({exc})"
+                ) from exc
+            self._record_sequence(message)
+            return message
 
     def _dispatch(self, message: Dict[str, Any]) -> None:
         mtype = message.get("type")

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/tests/test_cli.py

@@ -3018,6 +3018,8 @@ def test_flash_command_invokes_helper(monkeypatch, recorded_console):
             "--board",
             "esp32c5",
             "--erase-first",
+            "--sleep-after-flash",
+            "0",
         ],
     )
 
@@ -3695,7 +3697,7 @@ def test_ndjson_serial_client_decoder_errors(monkeypatch, recorded_console):
     with cli_module.NDJSONSerialClient("/dev/null", baudrate=1, timeout=0.1) as client:
         with pytest.raises(cli_module.ShuttleSerialError):
             client._read()
-        stub._lines = [b"not-json\n"]
+        stub._lines = [b'{"type":"resp","id":1,"ok":true\n']
         with pytest.raises(cli_module.ShuttleSerialError):
             client._read()
         stub._lines = [b'{"type":"resp","id":1,"ok":true,"seq":1}\n']

lr_shuttle-0.2.10/tests/test_flash.py

@@ -0,0 +1,269 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+from contextlib import contextmanager
+
+import pytest
+
+from shuttle import flash
+from shuttle.firmware import DEFAULT_BOARD
+
+
+def test_list_available_boards_includes_default():
+    assert DEFAULT_BOARD in flash.list_available_boards()
+
+
+def test_load_firmware_manifest_returns_segments():
+    manifest, package = flash.load_firmware_manifest("esp32c5")
+    assert manifest["segments"]
+    assert package.endswith("esp32c5")
+
+
+def test_flash_firmware_invokes_esptool(monkeypatch):
+    calls = []
+
+    def fake_run(args):
+        calls.append(args)
+
+    monkeypatch.setattr(flash, "_run_esptool", fake_run)
+
+    manifest = flash.flash_firmware(
+        port="/dev/ttyUSB0",
+        baudrate=921600,
+        board="esp32c5",
+        erase_first=True,
+    )
+
+    assert manifest["label"]
+    assert len(calls) == 2  # erase + write
+    erase_args, write_args = calls
+    assert erase_args[:4] == ["--chip", manifest["chip"], "--port", "/dev/ttyUSB0"]
+    assert "write-flash" in write_args
+    assert any("devboard.ino.bin" in arg for arg in write_args)
+
+
+def test_flash_firmware_unknown_board():
+    with pytest.raises(flash.FirmwareFlashError):
+        flash.flash_firmware(port="/dev/null", baudrate=921600, board="does-not-exist")
+
+
+def test_load_firmware_manifest_missing_file(monkeypatch, tmp_path):
+    board = "missing"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="manifest missing"):
+        flash.load_firmware_manifest(board)
+
+
+def test_load_firmware_manifest_corrupt(monkeypatch, tmp_path):
+    board = "corrupt"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+    (pkg_dir / "manifest.json").write_text("not-json", encoding="utf-8")
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="Invalid manifest"):
+        flash.load_firmware_manifest(board)
+
+
+def test_load_firmware_manifest_missing_segments(monkeypatch, tmp_path):
+    board = "no-segments"
+    pkg_dir = tmp_path / "shuttle.firmware" / board
+    pkg_dir.mkdir(parents=True)
+    (pkg_dir / "manifest.json").write_text("{}", encoding="utf-8")
+
+    original_files = flash.resources.files
+
+    def fake_files(package):
+        if package == f"shuttle.firmware.{board}":
+            return pkg_dir
+        return original_files(package)
+
+    monkeypatch.setattr(flash.resources, "files", fake_files)
+
+    with pytest.raises(flash.FirmwareFlashError, match="defines no segments"):
+        flash.load_firmware_manifest(board)
+
+
+@pytest.mark.parametrize("bad_segment", [{"file": "foo.bin"}, {"offset": "0x0"}])
+def test_flash_firmware_segment_missing_fields(monkeypatch, bad_segment):
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [bad_segment],
+    }
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+
+    with pytest.raises(
+        flash.FirmwareFlashError,
+        match="Manifest segment entries require 'offset' and 'file'",
+    ):
+        flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+
+def test_flash_firmware_missing_artifact(monkeypatch):
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x0", "file": "missing.bin"}],
+    }
+    calls = []
+    tmp_pkg = Path("/nonexistent/pkg")
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_pkg)
+    monkeypatch.setattr(
+        flash.resources,
+        "as_file",
+        lambda _traversable: (_ for _ in ()).throw(FileNotFoundError()),
+    )
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    with pytest.raises(
+        flash.FirmwareFlashError, match="Missing firmware artifact: missing.bin"
+    ):
+        flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert calls == []
+
+
+def test_flash_firmware_adds_flash_options(monkeypatch, tmp_path):
+    artifact = tmp_path / "fw.bin"
+    artifact.write_bytes(b"fw")
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x1000", "file": artifact.name}],
+        "flash-mode": "dout",
+        "flash-freq": "80m",
+        "flash-size": "2MB",
+    }
+    calls = []
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_path)
+
+    @contextmanager
+    def fake_as_file(traversable):
+        yield traversable
+
+    monkeypatch.setattr(flash.resources, "as_file", fake_as_file)
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert len(calls) == 1
+    write_args = calls[0]
+    assert ["--flash-mode", "dout"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert ["--flash-freq", "80m"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert ["--flash-size", "2MB"] in [
+        write_args[i : i + 2] for i in range(len(write_args) - 1)
+    ]
+    assert str(artifact) in write_args
+
+
+def test_flash_firmware_skips_missing_flash_options(monkeypatch, tmp_path):
+    artifact = tmp_path / "fw.bin"
+    artifact.write_bytes(b"fw")
+    manifest = {
+        "chip": "esp32c5",
+        "segments": [{"offset": "0x1000", "file": artifact.name}],
+        # no flash-mode/freq/size keys -> exercise falsy branch
+    }
+    calls = []
+
+    monkeypatch.setattr(
+        flash, "load_firmware_manifest", lambda _board: (manifest, "pkg")
+    )
+    monkeypatch.setattr(flash.resources, "files", lambda _pkg: tmp_path)
+
+    @contextmanager
+    def fake_as_file(traversable):
+        yield traversable
+
+    monkeypatch.setattr(flash.resources, "as_file", fake_as_file)
+    monkeypatch.setattr(flash, "_run_esptool", lambda args: calls.append(args))
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600, board="esp32c5")
+
+    assert len(calls) == 1
+    write_args = calls[0]
+    assert all(
+        flag not in write_args
+        for flag in ("--flash-mode", "--flash-freq", "--flash-size")
+    )
+    assert str(artifact) in write_args
+
+
+def test_flash_firmware_handles_no_compress(monkeypatch):
+    calls = []
+
+    def fake_run(args):
+        calls.append(args)
+
+    manifest, package = flash.load_firmware_manifest("esp32c5")
+    custom_manifest = dict(manifest)
+    custom_manifest["compress"] = False
+
+    monkeypatch.setattr(flash, "_run_esptool", fake_run)
+    monkeypatch.setattr(
+        flash,
+        "load_firmware_manifest",
+        lambda _board: (custom_manifest, package),
+    )
+
+    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600)
+
+    assert len(calls) == 1
+    assert "--no-compress" in calls[0]
+
+
+def test_run_esptool_success_with_exit_zero(monkeypatch):
+    recorded = []
+
+    def fake_main(args):
+        recorded.append(list(args))
+        raise SystemExit(0)
+
+    monkeypatch.setattr(flash.esptool, "main", fake_main)
+
+    flash._run_esptool(["ping"])
+
+    assert recorded[0] == ["ping"]
+
+
+def test_run_esptool_failure(monkeypatch):
+    def fake_main(_args):
+        raise SystemExit(2)
+
+    monkeypatch.setattr(flash.esptool, "main", fake_main)
+
+    with pytest.raises(flash.FirmwareFlashError):
+        flash._run_esptool(["bad"])

{lr_shuttle-0.2.8 → lr_shuttle-0.2.10}/tests/test_serial_client.py

@@ -398,4 +398,37 @@ def test_response_backlog_delivered(monkeypatch):
     client._dispatch(json.loads(serial_obj.lines.get().decode()))
     future = client.send_command("ping", {})
     assert future.result(timeout=1)["ok"] is True
+
+
+def test_read_skips_noise_before_json():
+    class DummySerial:
+        def __init__(self):
+            self.lines = queue.Queue()
+            self.is_open = True
+            self.reset_calls = 0
+
+        def reset_input_buffer(self):
+            self.reset_calls += 1
+
+        def readline(self):
+            try:
+                return self.lines.get_nowait()
+            except queue.Empty:
+                return b""
+
+        def close(self):
+            self.is_open = False
+
+    serial_obj = DummySerial()
+    serial_obj.lines.put(b'":62606,"ok":true}\n')
+    serial_obj.lines.put(b'{"type":"resp","id":1,"ok":true}\n')
+
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    client._serial = serial_obj
+    client._logger = None
+    client._seq_tracker = None
+
+    message = client._read()
+    assert message["ok"] is True
+    assert serial_obj.reset_calls >= 1
     client.close()

lr_shuttle-0.2.10/tests/test_serial_client_flush.py

@@ -0,0 +1,70 @@
+import queue
+import pytest
+import shuttle.serial_client as serial_client
+
+
+class DummySerial:
+    def __init__(self, data=b"", fail=False):
+        self._data = data
+        self._fail = fail
+        self.read_calls = 0
+        self.in_waiting = len(data)
+        self.is_open = True
+        self.reset_calls = 0
+
+    def read(self, n):
+        self.read_calls += 1
+        if self._fail:
+            raise Exception("fail")
+        d, self._data = self._data[:n], self._data[n:]
+        self.in_waiting = len(self._data)
+        return d
+
+    def reset_input_buffer(self):
+        self.reset_calls += 1
+        self._data = b""
+        self.in_waiting = 0
+
+    def close(self):
+        self.is_open = False
+
+
+class DummyLogger:
+    def __init__(self):
+        self.logged = []
+
+    def log(self, direction, data):
+        self.logged.append((direction, data))
+
+
+def test_flush_input_and_log_reads_and_logs(monkeypatch):
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    logger = DummyLogger()
+    # Data in buffer
+    client._serial = DummySerial(b"abc123")
+    client._logger = logger
+    client.flush_input_and_log()
+    assert logger.logged == [("RX", b"abc123")]
+    # No data in buffer
+    client._serial = DummySerial(b"")
+    logger.logged.clear()
+    client.flush_input_and_log()
+    assert logger.logged == []
+    # Exception in read is handled
+    client._serial = DummySerial(b"abc", fail=True)
+    client.flush_input_and_log()  # Should not raise
+
+
+def test_flush_input_and_log_no_serial():
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    client._logger = DummyLogger()
+    client.flush_input_and_log()  # Should not raise
+
+
+def test_flush_input_and_log_resets_buffer():
+    client = serial_client.NDJSONSerialClient.__new__(serial_client.NDJSONSerialClient)
+    serial = DummySerial(b"residual")
+    client._serial = serial
+    client._logger = DummyLogger()
+    client.flush_input_and_log()
+    assert serial.reset_calls == 1

lr_shuttle-0.2.8/tests/test_flash.py

@@ -1,92 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import pytest
-
-from shuttle import flash
-from shuttle.firmware import DEFAULT_BOARD
-
-
-def test_list_available_boards_includes_default():
-    assert DEFAULT_BOARD in flash.list_available_boards()
-
-
-def test_load_firmware_manifest_returns_segments():
-    manifest, package = flash.load_firmware_manifest("esp32c5")
-    assert manifest["segments"]
-    assert package.endswith("esp32c5")
-
-
-def test_flash_firmware_invokes_esptool(monkeypatch):
-    calls = []
-
-    def fake_run(args):
-        calls.append(args)
-
-    monkeypatch.setattr(flash, "_run_esptool", fake_run)
-
-    manifest = flash.flash_firmware(
-        port="/dev/ttyUSB0",
-        baudrate=921600,
-        board="esp32c5",
-        erase_first=True,
-    )
-
-    assert manifest["label"]
-    assert len(calls) == 2  # erase + write
-    erase_args, write_args = calls
-    assert erase_args[:4] == ["--chip", manifest["chip"], "--port", "/dev/ttyUSB0"]
-    assert "write-flash" in write_args
-    assert any("devboard.ino.bin" in arg for arg in write_args)
-
-
-def test_flash_firmware_unknown_board():
-    with pytest.raises(flash.FirmwareFlashError):
-        flash.flash_firmware(port="/dev/null", baudrate=921600, board="does-not-exist")
-
-
-def test_flash_firmware_handles_no_compress(monkeypatch):
-    calls = []
-
-    def fake_run(args):
-        calls.append(args)
-
-    manifest, package = flash.load_firmware_manifest("esp32c5")
-    custom_manifest = dict(manifest)
-    custom_manifest["compress"] = False
-
-    monkeypatch.setattr(flash, "_run_esptool", fake_run)
-    monkeypatch.setattr(
-        flash,
-        "load_firmware_manifest",
-        lambda _board: (custom_manifest, package),
-    )
-
-    flash.flash_firmware(port="/dev/ttyUSB0", baudrate=921600)
-
-    assert len(calls) == 1
-    assert "--no-compress" in calls[0]
-
-
-def test_run_esptool_success_with_exit_zero(monkeypatch):
-    recorded = []
-
-    def fake_main(args):
-        recorded.append(list(args))
-        raise SystemExit(0)
-
-    monkeypatch.setattr(flash.esptool, "main", fake_main)
-
-    flash._run_esptool(["ping"])
-
-    assert recorded[0] == ["ping"]
-
-
-def test_run_esptool_failure(monkeypatch):
-    def fake_main(_args):
-        raise SystemExit(2)
-
-    monkeypatch.setattr(flash.esptool, "main", fake_main)
-
-    with pytest.raises(flash.FirmwareFlashError):
-        flash._run_esptool(["bad"])