wsen-pads: Add test scenario for pressure sensor driver.

Author: nedseb

tests/runner/executor.py

@@ -5,12 +5,20 @@
 from pathlib import Path
 
 
-def load_driver_mock(driver_name, fake_i2c):
+def load_driver_mock(driver_name, fake_i2c, module_name=None):
     """Load a driver using FakeI2C on CPython.
 
     Patches machine and micropython modules, imports the driver,
     and returns an instance configured with the fake I2C bus.
+
+    Args:
+        driver_name: directory name under lib/ (e.g. 'wsen-pads')
+        fake_i2c: FakeI2C instance with pre-loaded registers
+        module_name: Python module name if different from driver_name
+                     (e.g. 'wsen_pads' when dir is 'wsen-pads')
     """
+    if module_name is None:
+        module_name = driver_name
     from tests.fake_machine import FakeI2C, FakePin
     from tests.fake_machine import micropython_stub
 
@@ -32,6 +40,17 @@ def load_driver_mock(driver_name, fake_i2c):
     if not hasattr(time, "sleep_us"):
         time.sleep_us = lambda us: time.sleep(us / 1000000)
 
+    # Create utime module as alias for time (MicroPython compatibility)
+    if "utime" not in sys.modules:
+        utime = types.ModuleType("utime")
+        utime.sleep_ms = time.sleep_ms
+        utime.sleep_us = time.sleep_us
+        utime.sleep = time.sleep
+        utime.ticks_ms = lambda: int(time.time() * 1000)
+        utime.ticks_us = lambda: int(time.time() * 1000000)
+        utime.ticks_diff = lambda a, b: a - b
+        sys.modules["utime"] = utime
+
     # Add driver lib path to sys.path
     root = Path(__file__).parent.parent.parent
     driver_lib = root / "lib" / driver_name
@@ -40,17 +59,18 @@ def load_driver_mock(driver_name, fake_i2c):
 
     # Force reimport of the driver module
     for mod_name in list(sys.modules):
-        if mod_name.startswith(driver_name):
+        if mod_name.startswith(module_name):
             del sys.modules[mod_name]
 
-    driver_module = importlib.import_module(f"{driver_name}.device")
+    driver_module = importlib.import_module(f"{module_name}.device")
     return driver_module, fake_i2c
 
 
-def cleanup_driver(driver_name):
+def cleanup_driver(driver_name, module_name=None):
     """Remove patched modules after test."""
+    mod_prefix = module_name or driver_name
     for mod_name in list(sys.modules):
-        if mod_name.startswith(driver_name):
+        if mod_name.startswith(mod_prefix):
             del sys.modules[mod_name]
     sys.modules.pop("machine", None)
     sys.modules.pop("micropython", None)

tests/runner/mpremote_bridge.py

@@ -64,8 +64,12 @@ def _driver_dir(self, driver_name):
         """Return the local lib path for a driver."""
         return PROJECT_ROOT / "lib" / driver_name
 
-    def call_method(self, driver_name, driver_class, i2c_config, method, args=None, i2c_address=None):
+    def call_method(
+        self, driver_name, driver_class, i2c_config, method,
+        args=None, i2c_address=None, module_name=None,
+    ):
         """Call a method on a driver instance and return the result."""
+        mod = module_name or driver_name
         args_str = ", ".join(repr(a) for a in (args or []))
         i2c_init = _i2c_init_code(i2c_config)
         if i2c_address is not None:
@@ -75,7 +79,7 @@ def call_method(self, driver_name, driver_class, i2c_config, method, args=None,
         code = (
             f"import json\n"
             f"{i2c_init}\n"
-            f"from {driver_name}.device import {driver_class}\n"
+            f"from {mod}.device import {driver_class}\n"
             f"{dev_init}"
             f"result = dev.{method}({args_str})\n"
             f"print(json.dumps(result))"

tests/scenarios/wsen_pads.yaml

@@ -0,0 +1,84 @@
+driver: wsen-pads
+module_name: wsen_pads
+driver_class: WSEN_PADS
+i2c_address: 0x5D
+
+# I2C config for hardware tests (STeaMi board - STM32WB55)
+i2c:
+  id: 1
+
+# Register values for mock tests
+# These simulate a real WSEN-PADS sensor
+mock_registers:
+  # DEVICE_ID (expected 0xB3)
+  0x0F: 0xB3
+  # INT_SOURCE (BOOT_ON=0, no interrupts)
+  0x24: 0x00
+  # CTRL_1 (power down, BDU enabled)
+  0x10: 0x02
+  # CTRL_2 (auto-increment enabled)
+  0x11: 0x10
+  # STATUS (pressure and temperature data available)
+  0x27: 0x03
+  # INT_CFG (default)
+  0x0B: 0x00
+  # DATA_P_XL..DATA_P_H (simulated ~1013.25 hPa: 1013.25 * 4096 = 4150272 = 0x3F5400)
+  0x28: [0x00, 0x54, 0x3F]
+  # DATA_T_L..DATA_T_H (simulated ~25.00°C: 25.00 / 0.01 = 2500 = 0x09C4)
+  0x2B: [0xC4, 0x09]
+
+tests:
+  - name: "Verify device ID register"
+    action: read_register
+    register: 0x0F
+    expect: 0xB3
+    mode: [mock, hardware]
+
+  - name: "Read device ID via method"
+    action: call
+    method: device_id
+    expect: 0xB3
+    mode: [mock, hardware]
+
+  - name: "Read status register"
+    action: call
+    method: status
+    expect_not_none: true
+    mode: [mock, hardware]
+
+  - name: "Read pressure returns float"
+    action: call
+    method: pressure
+    expect_not_none: true
+    mode: [mock]
+
+  - name: "Read temperature returns float"
+    action: call
+    method: temperature
+    expect_not_none: true
+    mode: [mock]
+
+  - name: "Pressure in plausible range"
+    action: call
+    method: pressure
+    expect_range: [900.0, 1100.0]
+    mode: [hardware]
+
+  - name: "Temperature in plausible range"
+    action: call
+    method: temperature
+    expect_range: [-10.0, 60.0]
+    mode: [hardware]
+
+  - name: "Pressure and temperature feel correct"
+    action: manual
+    display:
+      - method: pressure
+        label: "Pressure"
+        unit: "hPa"
+      - method: temperature
+        label: "Temperature"
+        unit: "°C"
+    prompt: "Ces valeurs sont-elles cohérentes (pression ~1013 hPa, température ambiante) ?"
+    expect_true: true
+    mode: [hardware]

tests/test_scenarios.py

@@ -45,6 +45,7 @@ def iter_scenario_tests():
 def make_mock_instance(scenario):
     """Create a driver instance using FakeI2C from scenario data."""
     driver_name = scenario["driver"]
+    module_name = scenario.get("module_name", driver_name)
     driver_class = scenario["driver_class"]
     address = scenario.get("i2c_address", 0x00)
     mock_registers = scenario.get("mock_registers", {})
@@ -56,7 +57,7 @@ def make_mock_instance(scenario):
         registers[key] = v
 
     fake_i2c = FakeI2C(registers=registers, address=address)
-    driver_module, _ = load_driver_mock(driver_name, fake_i2c)
+    driver_module, _ = load_driver_mock(driver_name, fake_i2c, module_name=module_name)
 
     cls = getattr(driver_module, driver_class)
     instance = cls(fake_i2c, address=address)
@@ -90,6 +91,7 @@ def test_scenario(scenario, test, mode, port):
                     scenario["i2c"],
                     display["method"],
                     display.get("args"),
+                    module_name=scenario.get("module_name"),
                 )
                 label = display.get("label", display["method"])
                 unit = display.get("unit", "")
@@ -107,6 +109,7 @@ def test_scenario(scenario, test, mode, port):
                 scenario["i2c"],
                 test["method"],
                 test.get("args"),
+                module_name=scenario.get("module_name"),
             )
         elif action == "read_register":
             result = bridge.read_register(