ragger 1.41.1__tar.gz → 1.42.0__tar.gz

{ragger-1.41.1 → ragger-1.42.0}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.42.0] - 2026-01-29
+
+### Changed
+
+- Detect error APDUs during navigation to have proper error APDUs exceptions instead of timeouts
+
+## [1.41.2] - 2026-01-08
+
+### Fixed
+
+- Only fail the test where elf file is missing
+
 ## [1.41.1] - 2025-12-12
 
 ### Fixed

{ragger-1.41.1/src/ragger.egg-info → ragger-1.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragger
-Version: 1.41.1
+Version: 1.42.0
 Summary: Testing framework using Speculos and LedgerComm as backends
 Author-email: Ledger <hello@ledger.fr>
 Project-URL: Homepage, https://github.com/LedgerHQ/ragger

{ragger-1.41.1 → ragger-1.42.0}/src/ragger/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.41.1'
-__version_tuple__ = version_tuple = (1, 41, 1)
+__version__ = version = '1.42.0'
+__version_tuple__ = version_tuple = (1, 42, 0)
 
-__commit_id__ = commit_id = 'g1f5eb0699'
+__commit_id__ = commit_id = 'g16d6f9e71'

{ragger-1.41.1 → ragger-1.42.0}/src/ragger/backend/speculos.py

@@ -120,6 +120,7 @@ class SpeculosBackend(BackendInterface):
                                                       api_url=self.url,
                                                       **kwargs)
         self._pending: Optional[ApduResponse] = None
+        self._pending_async_response: Optional[ApduResponse] = None
         self._last_screenshot: Optional[BytesIO] = None
         self._home_screenshot: Optional[BytesIO] = None
         self._ticker_paused_count = 0
@@ -137,6 +138,15 @@ class SpeculosBackend(BackendInterface):
     def apdu_timeout(self, value: float) -> None:
         self._apdu_timeout = value
 
+    def _check_async_error(self) -> None:
+        """Check for async APDU errors and raise if present."""
+        if self._pending_async_response is not None and self._last_async_response is None:
+            if has_data_available(self._pending_async_response, timeout=0):
+                self.logger.info("[Ragger] Early async data available, retrieving it now.")
+                # This will raise ExceptionRAPDU immediately if status != 9000
+                self._last_async_response = self._get_last_async_response(
+                    self._pending_async_response)
+
     def _retrieve_client_screen_content(self) -> dict:
         raw_content = self._client.get_current_screen_content()
         # Keep only text events
@@ -214,13 +224,22 @@ class SpeculosBackend(BackendInterface):
     @contextmanager
     def exchange_async_raw(self, data: bytes = b"") -> Generator[bool, None, None]:
         self.apdu_logger.info("=> %s", data.hex())
+        # Reset state for this new async exchange
+        self._last_async_response = None
         with self._client.apdu_exchange_nowait(cla=data[0],
                                                ins=data[1],
                                                p1=data[2],
                                                p2=data[3],
                                                data=data[5:]) as response:
-            yield has_data_available(response, timeout=self.apdu_timeout)
-            self._last_async_response = self._get_last_async_response(response)
+            self._pending_async_response = response
+            try:
+                yield has_data_available(response, timeout=self.apdu_timeout)
+                # Only retrieve if not already retrieved by _check_async_error during navigation
+                if self._last_async_response is None:
+                    self._last_async_response = self._get_last_async_response(response)
+            finally:
+                # Clear pending async response flag in all cases
+                self._pending_async_response = None
 
     def right_click(self) -> None:
         self._client.press_and_release("right")
@@ -315,6 +334,12 @@ class SpeculosBackend(BackendInterface):
             if not screenshot_equal(screenshot, self._last_screenshot):
                 break
 
+            # Check for async APDU errors before sending a tick. This ensures that if the
+            # application has already refused the APDU (e.g., due to an error), we detect and raise
+            # the error immediately instead of waiting for a screen change that will never occur.
+            # This makes navigation robust and prevents hanging.
+            self._check_async_error()
+
             # Send a ticker event and let the app process it
             self.send_tick()
             screenshot = BytesIO(self._client.get_screenshot())

{ragger-1.41.1 → ragger-1.42.0}/src/ragger/conftest/base_conftest.py

@@ -1,6 +1,7 @@
 import os
 import pytest
 import logging
+import warnings
 from dataclasses import fields
 from ledgered.devices import Device, Devices
 from ledgered.manifest import Manifest
@@ -14,6 +15,7 @@ from ragger.logger import init_loggers, standalone_conf_logger
 from ragger.navigator import Navigator, NanoNavigator, TouchNavigator, NavigateWithScenario
 from ragger.utils import find_project_root_dir, find_library_application, find_application
 from ragger.utils.misc import get_current_app_name_and_version, exit_current_app, open_app_from_dashboard
+from ragger.error import MissingElfError
 
 from . import configuration as conf
 
@@ -47,6 +49,10 @@ def pytest_addoption(parser):
                      const="apdu.log",
                      help="Log the APDU in a file. If no pattern provided, uses 'apdu_xxx.log'.")
     parser.addoption("--seed", action="store", default=None, help="Set a custom seed")
+    parser.addoption("--ignore-missing-binaries",
+                     action="store_true",
+                     default=False,
+                     help="Skip tests instead of failing when application binaries are missing")
     # Always allow "default" even if application conftest does not define it
     allowed_setups = conf.OPTIONAL.ALLOWED_SETUPS
     if "default" not in allowed_setups:
@@ -102,6 +108,11 @@ def cli_user_seed(pytestconfig):
     return pytestconfig.getoption("seed")
 
 
+@pytest.fixture(scope="session")
+def ignore_missing_binaries(pytestconfig):
+    return pytestconfig.getoption("ignore_missing_binaries")
+
+
 @pytest.fixture(scope="session")
 def pki_prod(pytestconfig):
     return pytestconfig.getoption("pki_prod")
@@ -238,7 +249,8 @@ def prepare_speculos_args(root_pytest_dir: Path,
                           pki_prod: bool,
                           cli_user_seed: str,
                           additional_args: List[str],
-                          verbose_speculos: bool = False):
+                          verbose_speculos: bool = False,
+                          ignore_missing_binaries: bool = False):
     speculos_args = additional_args.copy()
 
     if display:
@@ -270,16 +282,14 @@ def prepare_speculos_args(root_pytest_dir: Path,
                 f"Expected a single folder in {manifest.app.build_directory}, found {len(app_dir_subdirectories)}"
             )
         main_app_path = find_application(app_dir_subdirectories[0], device_name, "c")
-    # If the app is standalone, the main app should be located in project_root_dir / manifest.app.build_directory
-    else:
-        main_app_path = find_application(project_root_dir / manifest.app.build_directory,
-                                         device_name, manifest.app.sdk)
 
-    # If this repository does not hold the main app, then we need to load this repository's application as a library
-    if conf.OPTIONAL.MAIN_APP_DIR is not None:
         # This repo holds the library, not the standalone app: search in root_dir/build
         lib_path = find_application(project_root_dir, device_name, manifest.app.sdk)
         speculos_args.append(f"-l{lib_path}")
+    # If the app is standalone, the main app should be located in project_root_dir / manifest.app.build_directory
+    else:
+        main_app_path = find_application(project_root_dir / manifest.app.build_directory,
+                                         device_name, manifest.app.sdk)
 
     # Legacy lib method, remove once exchange is ported
     if len(conf.OPTIONAL.SIDELOADED_APPS) != 0:
@@ -290,8 +300,15 @@ def prepare_speculos_args(root_pytest_dir: Path,
         libs_dir = Path(project_root_dir / conf.OPTIONAL.SIDELOADED_APPS_DIR)
         # Add "-l Appname:filepath" to Speculos command line for every required lib app
         for coin_name, lib_name in conf.OPTIONAL.SIDELOADED_APPS.items():
-            lib_path = find_library_application(libs_dir, coin_name, device_name)
-            speculos_args.append(f"-l{lib_name}:{lib_path}")
+            try:
+                lib_path = find_library_application(libs_dir, coin_name, device_name)
+                speculos_args.append(f"-l{lib_name}:{lib_path}")
+            except MissingElfError as e:
+                if ignore_missing_binaries:
+                    warnings.warn(f"Could not find sideloaded app library for '{lib_name}': {e}",
+                                  UserWarning)
+                else:
+                    raise
     else:
         # Keep this method instead
         # Find all external libraries that have to be sideloaded
@@ -300,10 +317,17 @@ def prepare_speculos_args(root_pytest_dir: Path,
             subdirs = sorted(
                 filter(lambda d: (sideloaded_dir / d).is_dir(), os.listdir(sideloaded_dir)))
             for subdir in subdirs:
-                # Currently only C apps are used as additional binaries by ragger (Ethereum and Exchange)
-                # TODO: add support for Rust SDK libraries if needed
-                lib_path = find_application(sideloaded_dir / subdir, device_name, "c")
-                speculos_args.append(f"-l{lib_path}")
+                try:
+                    # Currently only C apps are used as additional binaries by ragger (Ethereum and Exchange)
+                    # TODO: add support for Rust SDK libraries if needed
+                    lib_path = find_application(sideloaded_dir / subdir, device_name, "c")
+                    speculos_args.append(f"-l{lib_path}")
+                except MissingElfError as e:
+                    if ignore_missing_binaries:
+                        warnings.warn(f"Could not find sideloaded app binary for '{subdir}': {e}",
+                                      UserWarning)
+                    else:
+                        raise
 
     # Check if custom user seed has been provided through CLI or optional configuration.
     # CLI user seed has priority over the optional configuration seed.
@@ -326,7 +350,8 @@ def create_backend(root_pytest_dir: Path,
                    log_apdu_file: Optional[Path],
                    cli_user_seed: str,
                    additional_speculos_arguments: List[str],
-                   verbose_speculos: bool = False) -> BackendInterface:
+                   verbose_speculos: bool = False,
+                   ignore_missing_binaries: bool = False) -> BackendInterface:
     if backend_name.lower() == "ledgercomm":
         return LedgerCommBackend(device=device,
                                  interface="hid",
@@ -338,7 +363,8 @@ def create_backend(root_pytest_dir: Path,
         main_app_path, speculos_args = prepare_speculos_args(root_pytest_dir, device, display,
                                                              pki_prod, cli_user_seed,
                                                              additional_speculos_arguments,
-                                                             verbose_speculos)
+                                                             verbose_speculos,
+                                                             ignore_missing_binaries)
         return SpeculosBackend(main_app_path,
                                device=device,
                                log_apdu_file=log_apdu_file,
@@ -353,12 +379,21 @@ def create_backend(root_pytest_dir: Path,
 @pytest.fixture(scope=conf.OPTIONAL.BACKEND_SCOPE)
 def backend(skip_tests_for_unsupported_devices, root_pytest_dir: Path, backend_name: str,
             device: Device, display: bool, pki_prod: bool, log_apdu_file: Optional[Path],
-            cli_user_seed: str, additional_speculos_arguments: List[str],
-            verbose_speculos: bool) -> Generator[BackendInterface, None, None]:
+            cli_user_seed: str, additional_speculos_arguments: List[str], verbose_speculos: bool,
+            ignore_missing_binaries: bool) -> Generator[BackendInterface, None, None]:
     # to separate the test name and its following logs
     print("")
-    with create_backend(root_pytest_dir, backend_name, device, display, pki_prod, log_apdu_file,
-                        cli_user_seed, additional_speculos_arguments, verbose_speculos) as b:
+    backend_instance = None
+    try:
+        backend_instance = create_backend(root_pytest_dir, backend_name, device, display, pki_prod,
+                                          log_apdu_file, cli_user_seed,
+                                          additional_speculos_arguments, verbose_speculos,
+                                          ignore_missing_binaries)
+    except MissingElfError as e:
+        pytest.fail(f"Missing ELF: {e}")
+
+    assert backend_instance is not None, "Backend instance should be initialized"
+    with backend_instance as b:
         if backend_name.lower() != "speculos" and conf.OPTIONAL.APP_NAME:
             # Make sure the app is restarted as this is what is requested by the fixture scope
             app_name, version = get_current_app_name_and_version(b)

{ragger-1.41.1 → ragger-1.42.0}/src/ragger/error.py

@@ -173,3 +173,11 @@ class ExceptionRAPDU(Exception):
 
     def __str__(self):
         return f"Error [0x{self.status:x}] {str(self.data)}"
+
+
+class MissingElfError(Exception):
+    """Exception raised when an expected ELF binary is missing."""
+
+    def __init__(self, path: str):
+        super().__init__(f"File '{path}' missing. Did you compile for this target?")
+        self.path = path

{ragger-1.41.1 → ragger-1.42.0}/src/ragger/utils/misc.py

@@ -16,7 +16,7 @@
 import toml
 from typing import Optional, Tuple, List
 from pathlib import Path
-from ragger.error import ExceptionRAPDU
+from ragger.error import ExceptionRAPDU, MissingElfError
 import subprocess
 import json
 
@@ -48,7 +48,7 @@ def find_library_application(base_dir: Path, name: str, device: str) -> Path:
         raise AssertionError(f"{base_dir} is not a directory")
     lib = Path(base_dir / (name + "_" + device + ".elf")).resolve()
     if not lib.is_file():
-        raise AssertionError(f"File '{lib}' missing. Did you compile for this target?")
+        raise MissingElfError(str(lib))
     return lib
 
 
@@ -91,7 +91,7 @@ def find_application(base_dir: Path, device: str, sdk: str) -> Path:
     else:
         app = app / "build" / device / "bin" / "app.elf"
     if not app.is_file():
-        raise AssertionError(f"File '{app}' missing. Did you compile for this target?")
+        raise MissingElfError(str(app))
     return app
 
 

{ragger-1.41.1 → ragger-1.42.0/src/ragger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragger
-Version: 1.41.1
+Version: 1.42.0
 Summary: Testing framework using Speculos and LedgerComm as backends
 Author-email: Ledger <hello@ledger.fr>
 Project-URL: Homepage, https://github.com/LedgerHQ/ragger

{ragger-1.41.1 → ragger-1.42.0}/tests/functional/backend/test_speculos.py

@@ -147,3 +147,30 @@ class TestbackendSpeculos(TestCase):
                     self.backend.right_click()
                     self.backend.left_click()
                     self.backend.both_click()
+
+    def test_async_error_raised_during_navigation(self):
+        """
+        Ensure that an async APDU error is raised immediately during navigation (e.g., while waiting for a screen change),
+        not just at context exit. This simulates an error response being available before navigation completes.
+        Also verifies that sequential async exchanges properly reset state and retrieve fresh responses.
+        """
+        with patch("speculos.client.subprocess"):
+            with SpeculosServerStub():
+                with self.backend:
+                    # Start an async exchange with an error APDU (not 0x9000)
+                    with self.assertRaises(ExceptionRAPDU) as error:
+                        with self.backend.exchange_async_raw(bytes.fromhex("01000000")):
+                            # Simulate navigation that would trigger the async error check
+                            # (wait_for_screen_change calls _check_async_error)
+                            self.backend.wait_for_screen_change(timeout=0.5)
+                            # This line should be unreachable - if reached, the error wasn't raised during navigation
+                            assert False, "Expected ExceptionRAPDU was not raised during navigation"  # pragma: no cover
+                    self.assertEqual(error.exception.status, APDUStatus.ERROR)
+
+                    # Perform a second async exchange with a SUCCESS APDU to ensure state is properly reset
+                    # If state wasn't reset, this could incorrectly raise due to the previous error response
+                    with self.assertRaises(TimeoutError):
+                        with self.backend.exchange_async_raw(bytes.fromhex("00000000")):
+                            self.backend.wait_for_screen_change(timeout=1)
+                    # Verify that the response was successfully retrieved despite the timeout
+                    self.assertEqual(self.backend.last_async_response.status, APDUStatus.SUCCESS)

{ragger-1.41.1 → ragger-1.42.0}/tests/unit/utils/test_misc.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from unittest import TestCase
 from unittest.mock import MagicMock
 
-from ragger.error import ExceptionRAPDU
+from ragger.error import ExceptionRAPDU, MissingElfError
 from ragger.utils import misc
 
 from ..helpers import temporary_directory
@@ -47,7 +47,7 @@ class TestMisc(TestCase):
             tmp_dir = (dir_path / "build" / device / "bin")
             tmp_dir.mkdir(parents=True, exist_ok=True)
             expected = tmp_dir / "app.elf"
-            with self.assertRaises(AssertionError) as error:
+            with self.assertRaises(MissingElfError) as error:
                 misc.find_application(dir_path, device, sdk)
             self.assertIn(str(expected), str(error.exception))