Add tests for stable camera ID usage

Add unit tests to ensure services use stable camera IDs (get_camera_id) rather than GUI display IDs (get_display_id). Tests added to tests/gui/test_rec_manager.py verify RecordingManager routes frames by stable ID, doesn't accept frames keyed by display ID, and doesn't infer frame size from display-only keys. Tests added/updated in tests/services/test_multicam_controller.py assert MultiCameraController emits frames and timestamps keyed by stable IDs, exposes a display_id mapping, and no internal use of display IDs; also update an existing rotation test to reference the stable camera ID. Imported get_camera_id/get_display_id and CameraSettings where needed.

Author: C-Achard

tests/gui/test_rec_manager.py

@@ -3,8 +3,9 @@
 import numpy as np
 import pytest
 
+from dlclivegui.config import CameraSettings
 from dlclivegui.gui.recording_manager import RecordingManager
-from dlclivegui.services.multi_camera_controller import get_camera_id
+from dlclivegui.services.multi_camera_controller import get_camera_id, get_display_id
 from dlclivegui.services.video_recorder import RecorderStats
 
 
@@ -277,3 +278,103 @@ def test_get_stats_summary_multi_aggregates(
     assert "30 frames" in summary  # 10 + 20
     assert "dropped 4" in summary  # 1 + 3
     assert "queue 6" in summary  # 2 + 4
+
+
+@pytest.mark.unit
+def test_recording_manager_uses_stable_camera_id_not_display_id(
+    recording_settings,
+    patch_video_recorder,
+    patch_build_run_dir,
+):
+    mgr = RecordingManager()
+
+    cam = CameraSettings(
+        name="GenTL cam",
+        backend="gentl",
+        index=0,
+        fps=30.0,
+        enabled=True,
+        properties={
+            "gentl": {
+                "device_id": "serial:SER0",
+                "serial_number": "SER0",
+            }
+        },
+    ).apply_defaults()
+
+    stable_id = get_camera_id(cam)
+    display_id = get_display_id(cam)
+
+    assert stable_id == "gentl:serial:SER0"
+    assert display_id == "gentl:0"
+    assert stable_id != display_id
+
+    frame = np.zeros((480, 640, 3), dtype=np.uint8)
+    current_frames = {stable_id: frame}
+
+    run_dir = mgr.start_all(
+        recording_settings,
+        [cam],
+        current_frames,
+        session_name="Sess",
+    )
+
+    assert run_dir is not None
+    assert stable_id in mgr.recorders
+    assert display_id not in mgr.recorders
+
+    rec = mgr.recorders[stable_id]
+    assert rec.frame_size == (480, 640)
+
+    mgr.write_frame(stable_id, frame, timestamp=123.0)
+    assert len(rec.write_calls) == 1
+    assert rec.write_calls[-1][1] == 123.0
+
+    # Display ID is GUI-only and must not route frames internally.
+    mgr.write_frame(display_id, frame, timestamp=456.0)
+    assert len(rec.write_calls) == 1
+
+
+@pytest.mark.unit
+def test_start_all_does_not_infer_frame_size_from_display_id(
+    recording_settings,
+    patch_video_recorder,
+    patch_build_run_dir,
+):
+    mgr = RecordingManager()
+
+    cam = CameraSettings(
+        name="GenTL cam",
+        backend="gentl",
+        index=0,
+        fps=30.0,
+        enabled=True,
+        properties={
+            "gentl": {
+                "device_id": "serial:SER0",
+                "serial_number": "SER0",
+            }
+        },
+    ).apply_defaults()
+
+    stable_id = get_camera_id(cam)
+    display_id = get_display_id(cam)
+
+    frame = np.zeros((480, 640, 3), dtype=np.uint8)
+
+    # Simulate the buggy situation: frames are keyed by display ID.
+    current_frames = {display_id: frame}
+
+    mgr.start_all(
+        recording_settings,
+        [cam],
+        current_frames,
+        session_name="Sess",
+    )
+
+    assert stable_id in mgr.recorders
+    assert display_id not in mgr.recorders
+
+    # Since RecordingManager uses stable IDs internally, it should not find this frame.
+    rec = mgr.recorders[stable_id]
+    assert rec.frame_size is None

tests/services/test_multicam_controller.py

@@ -5,18 +5,23 @@
 
 # from dlclivegui.config import CameraSettings
 from dlclivegui.config import CameraSettings
-from dlclivegui.services.multi_camera_controller import MultiCameraController, get_display_id
+from dlclivegui.services.multi_camera_controller import MultiCameraController, get_camera_id, get_display_id
 
 
 @pytest.mark.unit
 def test_start_and_frames(qtbot, patch_factory):
     mc = MultiCameraController()
 
-    # One dataclass + one dict (simulate mixed inputs)
     cam1 = CameraSettings(name="C1", backend="opencv", index=0, fps=25.0).apply_defaults()
     cam2 = {"name": "C2", "backend": "opencv", "index": 1, "fps": 30.0, "enabled": True}
     cam2 = CameraSettings.from_dict(cam2).apply_defaults()
 
+    cam1_id = get_camera_id(cam1)
+    cam2_id = get_camera_id(cam2)
+
+    cam1_display = get_display_id(cam1)
+    cam2_display = get_display_id(cam2)
+
     frames_seen = []
 
     def on_ready(mfd):
@@ -28,11 +33,24 @@ def on_ready(mfd):
         with qtbot.waitSignal(mc.all_started, timeout=1500):
             mc.start([cam1, cam2])
 
-        # Wait for at least one composite emission
         qtbot.waitUntil(lambda: len(frames_seen) >= 1, timeout=2000)
 
         assert mc.is_running()
-        # We should have at least one entry with 1 or 2 frames (depending on timing)
+
+        # Internal IDs should be used as frame keys.
+        seen_keys = set()
+        seen_sources = set()
+        for source_id, shape_map in frames_seen:
+            seen_sources.add(source_id)
+            seen_keys.update(shape_map.keys())
+
+        assert seen_keys <= {cam1_id, cam2_id}
+        assert seen_sources <= {cam1_id, cam2_id}
+
+        # Display IDs should not be used as internal frame keys.
+        assert cam1_display not in seen_keys
+        assert cam2_display not in seen_keys
+
         assert any(len(shape_map) >= 1 for _, shape_map in frames_seen)
 
     finally:
@@ -60,7 +78,7 @@ def test_rotation_and_crop(qtbot, patch_factory):
     last_shape = {"shape": None}
 
     def on_ready(mfd):
-        f = mfd.frames.get(get_display_id(cam))
+        f = mfd.frames.get(get_camera_id(cam))
         if f is not None:
             last_shape["shape"] = f.shape
 
@@ -95,3 +113,58 @@ def _create(_settings):
     # Expect initialization_failed with the camera id
     with qtbot.waitSignals([mc.initialization_failed, mc.all_stopped], timeout=2000) as _:
         mc.start([cam])
+
+
+@pytest.mark.unit
+def test_controller_uses_stable_camera_id_not_display_id(qtbot, patch_factory):
+    mc = MultiCameraController()
+
+    cam = CameraSettings(
+        name="C1",
+        backend="gentl",
+        index=0,
+        fps=30.0,
+        enabled=True,
+        properties={
+            "gentl": {
+                "device_id": "serial:SER0",
+                "serial_number": "SER0",
+            }
+        },
+    ).apply_defaults()
+
+    stable_id = get_camera_id(cam)
+    display_id = get_display_id(cam)
+
+    assert stable_id == "gentl:serial:SER0"
+    assert display_id == "gentl:0"
+    assert stable_id != display_id
+
+    seen = []
+
+    def on_ready(mfd):
+        seen.append(mfd)
+
+    mc.frame_ready.connect(on_ready)
+
+    try:
+        with qtbot.waitSignal(mc.all_started, timeout=1500):
+            mc.start([cam])
+
+        qtbot.waitUntil(lambda: bool(seen), timeout=2000)
+
+        mfd = seen[-1]
+
+        assert mfd.source_camera_id == stable_id
+        assert stable_id in mfd.frames
+        assert stable_id in mfd.timestamps
+
+        assert display_id not in mfd.frames
+        assert display_id not in mfd.timestamps
+
+        assert mfd.display_ids is not None
+        assert mfd.display_ids[stable_id] == display_id
+
+    finally:
+        with qtbot.waitSignal(mc.all_stopped, timeout=2000):
+            mc.stop(wait=True)