Enhance fake GenTL/Aravis test fixtures

Make test backend mocks more robust for SDK-less unit tests: add numpy import and a stricter Aravis availability check (require gi and Aravis typelib), expose HARVESTERS_AVAILABLE, and refine force_pypylon_unavailable to set pylon=None. Replace the simple FakeHarvester with a richer fake GenTL implementation (device info adapter, node/node_map, image acquirer, payload/components, timeout exception) that supports create()/create_image_acquirer(), start/stop/fetch and realistic buffer payloads. Patch GenTLCameraBackend to avoid CTI file searching during tests. Also remove pytest.mark.integration markers from many aravis tests so they run as unit tests.

Author: C-Achard

tests/cameras/backends/conftest.py

@@ -1,8 +1,8 @@
 # tests/cameras/backends/conftest.py
 import importlib
 import os
-from types import SimpleNamespace
 
+import numpy as np
 import pytest
 
 
@@ -17,8 +17,25 @@ def _has_module(name: str) -> bool:
         return False
 
 
-ARAVIS_AVAILABLE = _has_module("gi")  # Aravis via GObject introspection
-PYPYLON_AVAILABLE = _has_module("pypylon")  # Basler pypylon SDK
+def _has_aravis_gi() -> bool:
+    """
+    GI can exist without the Aravis typelib. Be representative:
+    check that gi.repository.Aravis is importable and versionable.
+    """
+    try:
+        import gi  # type: ignore
+
+        gi.require_version("Aravis", "0.8")
+        from gi.repository import Aravis  # noqa: F401
+
+        return True
+    except Exception:
+        return False
+
+
+ARAVIS_AVAILABLE = _has_aravis_gi()
+PYPYLON_AVAILABLE = _has_module("pypylon")
+HARVESTERS_AVAILABLE = _has_module("harvesters")
 
 
 # -----------------------------
@@ -109,23 +126,21 @@ def force_aravis_unavailable(monkeypatch):
 def force_pypylon_unavailable(monkeypatch):
     """
     Force Basler/pypylon to be unavailable for error-path testing.
+    Basler backend availability is based on 'pylon is not None'.
     """
     try:
         import dlclivegui.cameras.backends.basler_backend as bas
     except Exception:
-        # If the module doesn't exist in your tree, ignore.
         yield
         return
-    monkeypatch.setattr(bas, "PYPYLON_AVAILABLE", False, raising=False)
+
     monkeypatch.setattr(bas, "pylon", None, raising=False)
     yield
 
 
 # -----------------------------------------------------------------------------
 # Fake Aravis SDK (module-like) + fixtures
 # -----------------------------------------------------------------------------
-
-
 class FakeAravis:
     """Minimal fake Aravis module used for SDK-less unit/contract tests."""
 
@@ -495,61 +510,290 @@ def patch_basler_sdk(monkeypatch, fake_pylon_module):
 
 
 # -----------------------------------------------------------------------------
-# Fake GenTL / harvesters SDK (module-like) + fixtures
+# Fake GenTL / harvesters SDK (open/read/close capable) + fixtures
 # -----------------------------------------------------------------------------
 
 
-class FakeHarvesterTimeoutError(TimeoutError):
+class FakeGenTLTimeoutException(TimeoutError):
+    """
+    Representative timeout: Harvesters often surfaces GenTL TimeoutException semantics.
+    """
+
     pass
 
 
+class _DeviceInfoAdapter:
+    """
+    Make device_info_list entries behave whether they're dict-like or object-like.
+    """
+
+    def __init__(self, payload):
+        self._payload = payload
+
+    def get(self, key, default=None):
+        if isinstance(self._payload, dict):
+            return self._payload.get(key, default)
+        return getattr(self._payload, key, default)
+
+    @property
+    def serial_number(self):
+        return self.get("serial_number", "")
+
+    @property
+    def vendor(self):
+        return self.get("vendor", "")
+
+    @property
+    def model(self):
+        return self.get("model", "")
+
+    @property
+    def display_name(self):
+        return self.get("display_name", "")
+
+
+class _FakeNode:
+    """
+    Minimal GenICam-style node with .value and optional constraints.
+    Harvesters exposes nodes as objects; your backend uses:
+      - node.value
+      - node.min / node.max / node.inc (for Width/Height)
+      - PixelFormat.symbolics (for allowed formats)
+    """
+
+    def __init__(self, value=None, *, min=None, max=None, inc=1, symbolics=None):
+        self.value = value
+        self.min = min
+        self.max = max
+        self.inc = inc
+        self.symbolics = symbolics or []
+
+
+class _FakeNodeMap:
+    """Provides attribute access for nodes used by GenTLCameraBackend."""
+
+    def __init__(self, *, width=1920, height=1080, fps=30.0, exposure=10000.0, gain=0.0, pixel_format="Mono8"):
+        # Identification / label fields your _resolve_device_label() tries
+        self.DeviceModelName = _FakeNode("FakeGenTLModel")
+        self.DeviceSerialNumber = _FakeNode("FAKE-GENTL-0")
+        self.DeviceDisplayName = _FakeNode("FakeGenTLDisplay")
+
+        # Format + acquisition nodes
+        self.PixelFormat = _FakeNode(
+            pixel_format,
+            symbolics=["Mono8", "Mono16", "RGB8", "BGR8"],
+        )
+
+        # Width/Height with constraints for increment alignment logic
+        self.Width = _FakeNode(int(width), min=64, max=4096, inc=2)
+        self.Height = _FakeNode(int(height), min=64, max=4096, inc=2)
+
+        # FPS related nodes (backend may set AcquisitionFrameRate)
+        self.AcquisitionFrameRateEnable = _FakeNode(True)
+        self.AcquisitionFrameRate = _FakeNode(float(fps))
+        # backend tries ResultingFrameRate for actual FPS; provide it
+        self.ResultingFrameRate = _FakeNode(float(fps))
+
+        # Exposure/Gain
+        self.ExposureAuto = _FakeNode("Off")
+        self.ExposureTime = _FakeNode(float(exposure))
+        self.GainAuto = _FakeNode("Off")
+        self.Gain = _FakeNode(float(gain))
+
+
+class _FakeRemoteDevice:
+    def __init__(self, node_map: _FakeNodeMap):
+        self.node_map = node_map
+
+
+class _FakeComponent:
+    def __init__(self, width: int, height: int, channels: int, dtype=np.uint8):
+        self.width = int(width)
+        self.height = int(height)
+        self._channels = int(channels)
+        self._dtype = dtype
+
+        # Create a deterministic image payload
+        n = self.width * self.height * self._channels
+        if dtype == np.uint8:
+            arr = (np.arange(n) % 255).astype(np.uint8)
+        else:
+            # e.g., uint16
+            arr = (np.arange(n) % 65535).astype(np.uint16)
+
+        # Harvesters often exposes component.data as a buffer-like object;
+        # your backend does np.asarray(component.data) and may fall back to frombuffer(bytes(...)).
+        # A numpy array works fine for both.
+        self.data = arr
+
+
+class _FakePayload:
+    def __init__(self, component: _FakeComponent):
+        self.components = [component]
+
+
+class _FakeFetchedBufferCtx:
+    """
+    Context manager returned by FakeImageAcquirer.fetch().
+    Must provide .payload with components.
+    """
+
+    def __init__(self, payload: _FakePayload):
+        self.payload = payload
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+
+class FakeImageAcquirer:
+    """
+    Minimal Harvesters image acquirer:
+      - remote_device.node_map
+      - start()/stop()/destroy()
+      - fetch(timeout=...) -> context manager
+      - node_map shortcut (your backend uses self._acquirer.node_map in read())
+    """
+
+    def __init__(self, *, serial="FAKE-GENTL-0", width=1920, height=1080, pixel_format="Mono8"):
+        self.serial = serial
+        self._started = False
+        self._destroyed = False
+
+        # Node map used by open() and read()
+        self.remote_device = _FakeRemoteDevice(_FakeNodeMap(width=width, height=height, pixel_format=pixel_format))
+        self.node_map = self.remote_device.node_map
+
+        # Simple FIFO of frames (buffers)
+        self._queue: list[_FakePayload] = []
+        self._populate_default_frames()
+
+    def _populate_default_frames(self):
+        # Make one frame available by default
+        pf = str(self.node_map.PixelFormat.value or "Mono8")
+        if pf in ("RGB8", "BGR8"):
+            channels = 3
+            dtype = np.uint8
+        elif pf == "Mono16":
+            channels = 1
+            dtype = np.uint16
+        else:
+            channels = 1
+            dtype = np.uint8
+
+        comp = _FakeComponent(self.node_map.Width.value, self.node_map.Height.value, channels, dtype=dtype)
+        self._queue.append(_FakePayload(comp))
+
+    def start(self):
+        self._started = True
+
+    def stop(self):
+        self._started = False
+
+    def destroy(self):
+        self._destroyed = True
+
+    def fetch(self, timeout: float = 2.0):
+        if not self._started:
+            raise FakeGenTLTimeoutException("Acquirer not started")
+
+        if not self._queue:
+            raise FakeGenTLTimeoutException(f"Timeout after {timeout}s")
+
+        payload = self._queue.pop(0)
+        return _FakeFetchedBufferCtx(payload)
+
+
 class FakeHarvester:
     """
-    Minimal fake for 'from harvesters.core import Harvester' usage.
+    Minimal fake for 'from harvesters.core import Harvester' supporting:
+      - add_file/update/reset
+      - device_info_list for enumeration
+      - create()/create_image_acquirer() returning FakeImageAcquirer
 
-    Enough for:
-      - is_available()
-      - get_device_count() flow (Harvester() -> add_file -> update -> device_info_list -> reset)
+    This enables GenTLCameraBackend.open/read/close paths.
     """
 
     def __init__(self):
         self.device_info_list = []
         self._files = []
+        self._acquirers: list[FakeImageAcquirer] = []
 
     def add_file(self, file_path: str):
         self._files.append(str(file_path))
 
     def update(self):
-        # Expose at least one device info entry
-        self.device_info_list = [SimpleNamespace(serial_number="FAKE-GENTL-0")]
+        # Harvesters tutorial output shows dict-like device entries.
+        self.device_info_list = [
+            {
+                "display_name": "TLSimuMono (FAKE-GENTL-0)",
+                "model": "FakeGenTLModel",
+                "vendor": "FakeVendor",
+                "serial_number": "FAKE-GENTL-0",
+                "id_": "FakeDeviceId",
+                "tl_type": "Custom",
+                "user_defined_name": "Center",
+                "version": "1.0.0",
+            }
+        ]
 
     def reset(self):
+        # "release" resources
         self.device_info_list = []
         self._files = []
+        self._acquirers = []
+
+    def create(self, selector=None, index: int | None = None, *args, **kwargs):
+        serial = None
 
-    # Optional: creation methods referenced by GenTL backend (only needed if you test open())
-    def create(self, *args, **kwargs):
-        raise RuntimeError("FakeHarvester.create() not implemented for open-path tests")
+        # Selector dict commonly used: {"serial_number": "..."} [1](https://github.com/genicam/harvesters/issues/454)
+        if isinstance(selector, dict):
+            serial = selector.get("serial_number")
+
+        if serial is None and index is None:
+            index = 0
+
+        if not self.device_info_list:
+            self.update()
+
+        if serial is None:
+            if index is None:
+                index = 0
+            if index < 0 or index >= len(self.device_info_list):
+                raise RuntimeError("Index out of range")
+            info = _DeviceInfoAdapter(self.device_info_list[index])
+            serial = info.serial_number or "FAKE-GENTL-0"
+
+        acq = FakeImageAcquirer(serial=serial)
+        self._acquirers.append(acq)
+        return acq
 
     def create_image_acquirer(self, *args, **kwargs):
-        raise RuntimeError("FakeHarvester.create_image_acquirer() not implemented for open-path tests")
+        # Alias used by some Harvesters versions; just delegate to create()
+        return self.create(*args, **kwargs)
 
 
 @pytest.fixture()
 def fake_harvester_class():
-    """Provides FakeHarvester class (not an instance) for patching gentl backend."""
+    """Provides FakeHarvester class for patching GenTL backend."""
     return FakeHarvester
 
 
 @pytest.fixture()
 def patch_gentl_sdk(monkeypatch, fake_harvester_class):
-    """
-    Patch GenTL backend to behave as if harvesters is installed, using FakeHarvester.
-    """
     import dlclivegui.cameras.backends.gentl_backend as gb
 
     monkeypatch.setattr(gb, "Harvester", fake_harvester_class, raising=False)
-    monkeypatch.setattr(gb, "HarvesterTimeoutError", FakeHarvesterTimeoutError, raising=False)
+    monkeypatch.setattr(gb, "HarvesterTimeoutError", FakeGenTLTimeoutException, raising=False)
+
+    # Prevent CTI searching from blocking open/get_device_count
+    monkeypatch.setattr(gb.GenTLCameraBackend, "_find_cti_file", lambda self: "dummy.cti", raising=False)
+    monkeypatch.setattr(
+        gb.GenTLCameraBackend, "_search_cti_file", staticmethod(lambda patterns: "dummy.cti"), raising=False
+    )
+
     return fake_harvester_class