refractor capture to a module

tests/test_capture.py

@@ -0,0 +1,463 @@
+"""Unit tests for orisys.capture with fake VideoCapture objects (no hardware)."""
+
+from __future__ import annotations
+
+import threading
+import time
+
+import numpy as np
+import pytest
+
+from orisys.capture import (
+    MAX_SIMULTANEOUS_CAPTURES,
+    CameraFilter,
+    CameraInfo,
+    CaptureConfig,
+    CaptureHealth,
+    CaptureManager,
+    CaptureMode,
+    CaptureSource,
+    FrameBuffer,
+    OverflowPolicy,
+    ReconnectPolicy,
+    list_cameras,
+    normalize_source,
+    open_capture,
+    pick_default_camera,
+)
+from orisys.capture.discovery import DEFAULT_LAPTOP_WEBCAM_PATTERNS
+
+
+class FakeCap:
+    """Deterministic stand-in for cv2.VideoCapture."""
+
+    def __init__(self, frames=None, *, fail_after=None, fail_reads=0, open_ok=True):
+        self._frames = list(frames or [])
+        self._idx = 0
+        self._open = bool(open_ok)
+        self._fail_after = fail_after
+        self._fail_reads_remaining = int(fail_reads)
+        self.read_count = 0
+        self.release_count = 0
+        self.width = 4
+        self.height = 3
+        self.fps = 30.0
+        self.fourcc = 0
+
+    def isOpened(self):
+        return self._open
+
+    def read(self):
+        self.read_count += 1
+        if not self._open:
+            return False, None
+        if self._fail_reads_remaining > 0:
+            self._fail_reads_remaining -= 1
+            return False, None
+        if self._fail_after is not None and self.read_count > self._fail_after:
+            self._open = False
+            return False, None
+        if self._idx >= len(self._frames):
+            # Repeat last frame like a live camera holding the stream.
+            if not self._frames:
+                return False, None
+            frame = self._frames[-1]
+        else:
+            frame = self._frames[self._idx]
+            self._idx += 1
+        return True, frame.copy()
+
+    def release(self):
+        self.release_count += 1
+        self._open = False
+
+    def get(self, prop_id):
+        # Values mirror common OpenCV property IDs without importing cv2 constants.
+        if prop_id in (3,):  # CAP_PROP_FRAME_WIDTH
+            return float(self.width)
+        if prop_id in (4,):  # CAP_PROP_FRAME_HEIGHT
+            return float(self.height)
+        if prop_id in (5,):  # CAP_PROP_FPS
+            return float(self.fps)
+        if prop_id in (6,):  # CAP_PROP_FOURCC
+            return float(self.fourcc)
+        return 0.0
+
+    def set(self, prop_id, value):
+        return True
+
+
+def _frame(val: int) -> np.ndarray:
+    return np.full((3, 4, 3), val, dtype=np.uint8)
+
+
+def _factory_from_caps(caps):
+    """Return a factory that hands out FakeCap instances in order."""
+    lock = threading.Lock()
+    state = {"i": 0}
+
+    def factory(_config):
+        with lock:
+            if state["i"] >= len(caps):
+                raise RuntimeError("No more fake captures")
+            cap = caps[state["i"]]
+            state["i"] += 1
+            return cap, "FAKE"
+
+    return factory
+
+
+# ---------------------------------------------------------------------------
+# Source normalization / config
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "video,expected",
+    [
+        (None, 0),
+        ("0", 0),
+        (" 1 ", 1),
+        (2, 2),
+        ("/dev/video0", "/dev/video0"),
+        (r".\clip.mp4" + "\\", r".\clip.mp4"),
+    ],
+)
+def test_normalize_source(video, expected):
+    assert normalize_source(video) == expected
+
+
+def test_capture_config_queue_bounds():
+    with pytest.raises(ValueError):
+        CaptureConfig(source=0, queue_size=0)
+    with pytest.raises(ValueError):
+        CaptureConfig(source=0, queue_size=11)
+    cfg = CaptureConfig(source=0, mode="queue", queue_size=10)
+    assert cfg.queue_size == 10
+    latest = CaptureConfig(source=0, mode="latest", queue_size=5)
+    assert latest.queue_size == 1
+
+
+# ---------------------------------------------------------------------------
+# FrameBuffer
+# ---------------------------------------------------------------------------
+
+
+def test_frame_buffer_latest_overwrites():
+    buf = FrameBuffer(mode=CaptureMode.LATEST)
+    buf.publish(_frame(1))
+    buf.publish(_frame(2))
+    ok, frame, seq = buf.read_latest(copy=True)
+    assert ok and seq == 2
+    assert int(frame[0, 0, 0]) == 2
+
+
+def test_frame_buffer_queue_drop_oldest():
+    buf = FrameBuffer(mode=CaptureMode.QUEUE, maxsize=2, overflow=OverflowPolicy.DROP_OLDEST)
+    buf.publish(_frame(1))
+    buf.publish(_frame(2))
+    buf.publish(_frame(3))
+    assert buf.dropped_frames == 1
+    ok, f1, _ = buf.read_next(copy=True)
+    ok2, f2, _ = buf.read_next(copy=True)
+    assert ok and ok2
+    assert int(f1[0, 0, 0]) == 2
+    assert int(f2[0, 0, 0]) == 3
+
+
+def test_frame_buffer_queue_drop_newest():
+    buf = FrameBuffer(mode=CaptureMode.QUEUE, maxsize=1, overflow=OverflowPolicy.DROP_NEWEST)
+    buf.publish(_frame(1))
+    buf.publish(_frame(2))
+    assert buf.dropped_frames == 1
+    ok, frame, _ = buf.read_next(copy=True)
+    assert ok and int(frame[0, 0, 0]) == 1
+
+
+# ---------------------------------------------------------------------------
+# CaptureSource reconnect
+# ---------------------------------------------------------------------------
+
+
+def test_capture_source_read_and_status():
+    frames = [_frame(7)]
+    cap = FakeCap(frames)
+    src = CaptureSource(
+        CaptureConfig(source=0, reconnect=ReconnectPolicy(enabled=False), start_worker=False),
+        factory=lambda cfg: (cap, "FAKE"),
+    )
+    src.open()
+    assert src.is_open()
+    assert src.status.health == CaptureHealth.CONNECTED
+    ok, frame = src.read_raw()
+    assert ok and int(frame[0, 0, 0]) == 7
+    src.release()
+    assert src.status.health == CaptureHealth.CLOSED
+    assert cap.release_count == 1
+
+
+def test_auto_reconnect_after_failed_reads():
+    first = FakeCap([_frame(1)], fail_after=1)
+    second = FakeCap([_frame(9)])
+    factory = _factory_from_caps([first, second])
+    policy = ReconnectPolicy(
+        enabled=True,
+        fail_threshold=1,
+        initial_backoff_s=0.01,
+        max_backoff_s=0.01,
+        stale_timeout_s=None,
+        max_attempts=3,
+    )
+    src = CaptureSource(
+        CaptureConfig(source=0, reconnect=policy, start_worker=False, verbose=False),
+        factory=factory,
+    )
+    src.open()
+    ok, _ = src.read_raw()
+    assert ok
+    # Next read fails and closes first cap.
+    ok, _ = src.read_raw()
+    assert not ok
+    assert src.should_reconnect()
+    assert src.reconnect()
+    ok, frame = src.read_raw()
+    assert ok and int(frame[0, 0, 0]) == 9
+    assert src.status.health == CaptureHealth.CONNECTED
+    assert src.status.reconnect_attempts >= 1
+
+
+def test_reconnect_disabled_does_not_reopen():
+    cap = FakeCap([_frame(1)], fail_after=1)
+    src = CaptureSource(
+        CaptureConfig(
+            source=0,
+            reconnect=ReconnectPolicy(enabled=False, fail_threshold=1),
+            start_worker=False,
+        ),
+        factory=lambda cfg: (cap, "FAKE"),
+    )
+    src.open()
+    src.read_raw()
+    src.read_raw()
+    assert not src.should_reconnect()
+
+
+def test_reconnect_attempts_exhausted():
+    good = FakeCap([_frame(1)], fail_after=1)
+
+    state = {"n": 0}
+
+    def factory(_cfg):
+        state["n"] += 1
+        if state["n"] == 1:
+            return good, "FAKE"
+        raise RuntimeError("camera missing")
+
+    policy = ReconnectPolicy(
+        enabled=True,
+        fail_threshold=1,
+        initial_backoff_s=0.01,
+        max_backoff_s=0.01,
+        stale_timeout_s=None,
+        max_attempts=2,
+    )
+    src = CaptureSource(
+        CaptureConfig(source=0, reconnect=policy, start_worker=False),
+        factory=factory,
+    )
+    src.open()
+    src.read_raw()
+    src.read_raw()
+    assert src.should_reconnect()
+    assert not src.reconnect()
+    assert not src.reconnect()
+    assert src.status.health == CaptureHealth.FAILED
+
+
+# ---------------------------------------------------------------------------
+# CaptureWorker
+# ---------------------------------------------------------------------------
+
+
+def test_worker_latest_mode_publishes_frames():
+    caps = [FakeCap([_frame(i) for i in range(5)])]
+    worker = open_capture(
+        CaptureConfig(
+            source=0,
+            mode=CaptureMode.LATEST,
+            start_worker=True,
+            reconnect=ReconnectPolicy(enabled=False),
+        ),
+        factory=_factory_from_caps(caps),
+        start_worker=True,
+    )
+    try:
+        deadline = time.perf_counter() + 2.0
+        ok = False
+        frame = None
+        while time.perf_counter() < deadline:
+            ok, frame = worker.read(wait_s=0.05)
+            if ok:
+                break
+        assert ok and frame is not None
+    finally:
+        worker.close()
+
+
+def test_worker_reconnect_in_background():
+    first = FakeCap([_frame(1)], fail_after=2)
+    second = FakeCap([_frame(42) for _ in range(20)])
+    policy = ReconnectPolicy(
+        enabled=True,
+        fail_threshold=1,
+        initial_backoff_s=0.01,
+        max_backoff_s=0.02,
+        stale_timeout_s=None,
+    )
+    worker = open_capture(
+        CaptureConfig(source=0, mode="latest", reconnect=policy, start_worker=True),
+        factory=_factory_from_caps([first, second]),
+        start_worker=True,
+    )
+    try:
+        saw_reconnect = False
+        saw_new = False
+        deadline = time.perf_counter() + 3.0
+        while time.perf_counter() < deadline:
+            if worker.source.status.reconnect_attempts > 0:
+                saw_reconnect = True
+            ok, frame = worker.read(wait_s=0.05)
+            if ok and frame is not None and int(frame[0, 0, 0]) == 42:
+                saw_new = True
+                break
+            time.sleep(0.01)
+        assert saw_reconnect
+        assert saw_new
+    finally:
+        worker.close()
+
+
+# ---------------------------------------------------------------------------
+# CaptureManager
+# ---------------------------------------------------------------------------
+
+
+def test_capture_manager_capacity_and_status():
+    mgr = CaptureManager(max_sources=2)
+    caps = [FakeCap([_frame(1)]), FakeCap([_frame(2)]), FakeCap([_frame(3)])]
+    factory = _factory_from_caps(caps)
+    try:
+        mgr.open(CaptureConfig(source=0, start_worker=False), factory=factory)
+        mgr.open(CaptureConfig(source=1, start_worker=False), factory=factory)
+        assert len(mgr) == 2
+        with pytest.raises(RuntimeError):
+            mgr.open(CaptureConfig(source=2, start_worker=False), factory=factory)
+        statuses = mgr.status_all()
+        assert set(statuses) == {"0", "1"}
+        assert all(s.health == CaptureHealth.CONNECTED for s in statuses.values())
+    finally:
+        mgr.close_all()
+    assert len(mgr) == 0
+
+
+def test_capture_manager_max_constant():
+    assert MAX_SIMULTANEOUS_CAPTURES == 10
+    with pytest.raises(ValueError):
+        CaptureManager(max_sources=11)
+
+
+def test_capture_manager_read_latest_all():
+    mgr = CaptureManager(max_sources=3)
+    caps = [FakeCap([_frame(10)]), FakeCap([_frame(20)])]
+    factory = _factory_from_caps(caps)
+    try:
+        w0 = mgr.open(
+            CaptureConfig(source=0, mode="latest", start_worker=True),
+            factory=factory,
+        )
+        w1 = mgr.open(
+            CaptureConfig(source=1, mode="latest", start_worker=True),
+            factory=factory,
+        )
+        deadline = time.perf_counter() + 2.0
+        while time.perf_counter() < deadline:
+            if w0.buffer.last_seq > 0 and w1.buffer.last_seq > 0:
+                break
+            time.sleep(0.01)
+        frames = mgr.read_latest_all()
+        assert "0" in frames and "1" in frames
+    finally:
+        mgr.close_all()
+
+
+# ---------------------------------------------------------------------------
+# Camera discovery filters (no hardware)
+# ---------------------------------------------------------------------------
+
+
+def test_camera_filter_excludes_laptop_webcams():
+    cams = [
+        CameraInfo(0, "DSHOW", 0, 640, 480, name="Integrated Webcam"),
+        CameraInfo(1, "DSHOW", 0, 1920, 1080, name="Orisys Tactile Cam"),
+        CameraInfo(2, "DSHOW", 0, 1280, 720, name="USB Camera"),
+    ]
+    filt = CameraFilter(exclude_laptop_webcams=True)
+    kept = [c for c in cams if filt.matches(c)]
+    assert [c.index for c in kept] == [1, 2]
+
+
+def test_camera_filter_name_include_and_vid_pid():
+    cams = [
+        CameraInfo(0, "V4L2", 0, 640, 480, name="foo", vendor_id=0x1234, product_id=0x5678),
+        CameraInfo(1, "V4L2", 0, 640, 480, name="orisys-finger", vendor_id=0xAAAA, product_id=0xBBBB),
+    ]
+    filt = CameraFilter(name_include=[r"orisys"], vid_pid_allowlist=[(0xAAAA, 0xBBBB)])
+    kept = [c for c in cams if filt.matches(c)]
+    assert len(kept) == 1 and kept[0].index == 1
+
+
+def test_camera_filter_min_resolution():
+    cams = [
+        CameraInfo(0, "DSHOW", 0, 320, 240, name="tiny"),
+        CameraInfo(1, "DSHOW", 0, 1280, 720, name="hd"),
+    ]
+    filt = CameraFilter(min_width=640, min_height=480)
+    kept = [c for c in cams if filt.matches(c)]
+    assert [c.index for c in kept] == [1]
+
+
+def test_pick_default_camera():
+    cams = [
+        CameraInfo(1, "DSHOW", 0, 640, 480),
+        CameraInfo(2, "DSHOW", 0, 640, 480),
+    ]
+    assert pick_default_camera(cams, preferred="2") == "2"
+    assert pick_default_camera(cams, preferred=None) == "1"
+    assert pick_default_camera([], preferred="0") is None
+
+
+def test_laptop_patterns_nonempty():
+    assert len(DEFAULT_LAPTOP_WEBCAM_PATTERNS) >= 5
+
+
+def test_camera_info_label_includes_name():
+    cam = CameraInfo(3, "DSHOW", 700, 1280, 720, name="Orisys")
+    assert "Orisys" in cam.label()
+    assert cam.source == "3"
+
+
+def test_list_cameras_is_callable():
+    # Smoke: function import works; may return [] without hardware.
+    assert callable(list_cameras)
+
+
+def test_sensor_external_mode_still_works():
+    from orisys import Sensor
+
+    sensor = Sensor("external", config_name="box", verbose=False, backend="cpu")
+    try:
+        assert sensor._external_only
+        assert sensor.capture_status is None
+        assert sensor._capture_worker is None
+    finally:
+        sensor.disconnect()