test(cameras): add opencv camera dependency injection tests suite

lerobot/common/cameras/interface_camera_sdk.py

@@ -0,0 +1,305 @@
+# ruff: noqa: N802,N803
+import abc
+from typing import Optional, Tuple
+
+import numpy as np
+
+
+# --- Interface Definition ---
+class IVideoCapture(abc.ABC):
+    """Interface for the cv2.VideoCapture class."""
+
+    @abc.abstractmethod
+    def __init__(self, index: int | str, backend: Optional[int] = None):
+        pass
+
+    @abc.abstractmethod
+    def isOpened(self) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def release(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def set(self, propId: int, value: float) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def get(self, propId: int) -> float:
+        pass
+
+    @abc.abstractmethod
+    def read(self) -> Tuple[bool, Optional[np.ndarray]]:
+        pass
+
+
+class IOpenCVSDK(abc.ABC):
+    """Interface defining the contract for OpenCV SDK interactions."""
+
+    # --- Constants ---
+    CAP_PROP_FPS: int
+    CAP_PROP_FRAME_WIDTH: int
+    CAP_PROP_FRAME_HEIGHT: int
+    COLOR_BGR2RGB: int
+    ROTATE_90_COUNTERCLOCKWISE: int
+    ROTATE_90_CLOCKWISE: int
+    ROTATE_180: int
+    CAP_V4L2: int
+    CAP_DSHOW: int
+    CAP_AVFOUNDATION: int
+    CAP_ANY: int
+
+    # --- Inner Class Type Hint ---
+    VideoCapture: type[IVideoCapture]
+
+    # --- Methods ---
+    @abc.abstractmethod
+    def setNumThreads(self, nthreads: int) -> None:
+        pass
+
+    @abc.abstractmethod
+    def cvtColor(self, src: np.ndarray, code: int) -> np.ndarray:
+        pass
+
+    @abc.abstractmethod
+    def rotate(self, src: np.ndarray, rotateCode: int) -> np.ndarray:
+        pass
+
+
+# --- Real SDK Adapter ---
+class OpenCVSDKAdapter(IOpenCVSDK):
+    """Adapts the real cv2 library to the IOpenCVSDK interface."""
+
+    _cv2 = None
+
+    def __init__(self):
+        try:
+            import cv2
+
+            OpenCVSDKAdapter._cv2 = cv2
+        except ImportError as e:
+            raise ImportError(
+                "OpenCV (cv2) is not installed. Please install it to use the real camera."
+            ) from e
+
+        # --- Constants ---
+        self.CAP_PROP_FPS = self._cv2.CAP_PROP_FPS
+        self.CAP_PROP_FRAME_WIDTH = self._cv2.CAP_PROP_FRAME_WIDTH
+        self.CAP_PROP_FRAME_HEIGHT = self._cv2.CAP_PROP_FRAME_HEIGHT
+        self.COLOR_BGR2RGB = self._cv2.COLOR_BGR2RGB
+        self.ROTATE_90_COUNTERCLOCKWISE = self._cv2.ROTATE_90_COUNTERCLOCKWISE
+        self.ROTATE_90_CLOCKWISE = self._cv2.ROTATE_90_CLOCKWISE
+        self.ROTATE_180 = self._cv2.ROTATE_180
+        self.CAP_V4L2 = self._cv2.CAP_V4L2
+        self.CAP_DSHOW = self._cv2.CAP_DSHOW
+        self.CAP_AVFOUNDATION = self._cv2.CAP_AVFOUNDATION
+        self.CAP_ANY = self._cv2.CAP_ANY
+
+        # --- Inner Class Implementation ---
+        class RealVideoCapture(IVideoCapture):
+            def __init__(self, index: int | str, backend: Optional[int] = None):
+                self._cap = OpenCVSDKAdapter._cv2.VideoCapture(index, backend)
+
+            def isOpened(self) -> bool:
+                return self._cap.isOpened()
+
+            def release(self) -> None:
+                self._cap.release()
+
+            def set(self, propId: int, value: float) -> bool:
+                return self._cap.set(propId, value)
+
+            def get(self, propId: int) -> float:
+                return self._cap.get(propId)
+
+            def read(self) -> Tuple[bool, Optional[np.ndarray]]:
+                return self._cap.read()
+
+            def __del__(self):
+                if hasattr(self, "_cap") and self._cap and self._cap.isOpened():
+                    self._cap.release()
+
+        self.VideoCapture = RealVideoCapture
+
+    # --- Methods ---
+    def setNumThreads(self, nthreads: int) -> None:
+        self._cv2.setNumThreads(nthreads)
+
+    def cvtColor(self, src: np.ndarray, code: int) -> np.ndarray:
+        return self._cv2.cvtColor(src, code)
+
+    def rotate(self, src: np.ndarray, rotateCode: int) -> np.ndarray:
+        return self._cv2.rotate(src, rotateCode)
+
+
+# Emulates the cheap USB camera
+VALID_INDICES = {0, 1, 2, "/dev/video0", "/dev/video1", "/dev/video2"}
+DEFAULT_FPS = 30.0
+DEFAULT_WIDTH = 1280
+DEFAULT_HEIGHT = 720
+
+
+# --- Fake SDK Adapter ---
+class FakeOpenCVSDKAdapter(IOpenCVSDK):
+    """Implements the IOpenCVSDK interface with fake behavior for testing."""
+
+    # --- Constants ---
+    CAP_PROP_FPS = DEFAULT_FPS
+    CAP_PROP_FRAME_WIDTH = DEFAULT_WIDTH
+    CAP_PROP_FRAME_HEIGHT = DEFAULT_HEIGHT
+    COLOR_BGR2RGB = 99
+    ROTATE_90_COUNTERCLOCKWISE = -90
+    ROTATE_90_CLOCKWISE = 90
+    ROTATE_180 = 180
+    CAP_V4L2 = 91
+    CAP_DSHOW = 92
+    CAP_AVFOUNDATION = 93
+    CAP_ANY = 90
+
+    _cameras_opened: dict[int | str, bool] = {}
+    _camera_properties: dict[tuple[int | str, int], float] = {}
+    _simulated_image: np.ndarray = np.random.randint(
+        0, 256, (DEFAULT_HEIGHT, DEFAULT_WIDTH, 3), dtype=np.uint8
+    )
+    _simulated_fps: float = DEFAULT_FPS
+    _image_read_count: int = 0
+    _fail_read_after: Optional[int] = None  # Simulate read failure
+
+    @classmethod
+    def init_configure_fake(
+        cls,
+        simulated_image: Optional[np.ndarray] = None,
+        simulated_fps: Optional[float] = None,
+        fail_read_after: Optional[int] = None,
+    ):
+        if simulated_image is not None:
+            cls._simulated_image = simulated_image
+        if simulated_fps is not None:
+            cls._simulated_fps = simulated_fps
+        cls._fail_read_after = fail_read_after
+        cls._image_read_count = 0
+        cls._cameras_opened = {}
+        cls._camera_properties = {}
+
+    @classmethod
+    def configure_fake_simulated_image(cls, simulated_image: Optional[np.ndarray] = None):
+        if simulated_image is not None:
+            cls._simulated_image = simulated_image
+
+    @classmethod
+    def configure_fail_read_after(cls, fail_read_after: Optional[int] = None):
+        cls._fail_read_after = fail_read_after
+
+    @classmethod
+    def configure_fake_simulated_fps(cls, simulated_fps: Optional[float] = None):
+        if simulated_fps is not None:
+            cls._simulated_fps = simulated_fps
+
+    # --- Inner Class Implementation ---
+    class FakeVideoCapture(IVideoCapture):
+        def __init__(self, index: int | str, backend: Optional[int] = None):
+            self.index = index
+            self.backend = backend
+            valid_indices = VALID_INDICES
+            if self.index in valid_indices:
+                FakeOpenCVSDKAdapter._cameras_opened[self.index] = True
+                print(f"[FAKE SDK] Opened camera {self.index}")
+                # Set some default fake properties
+                FakeOpenCVSDKAdapter._camera_properties[(self.index, FakeOpenCVSDKAdapter.CAP_PROP_FPS)] = (
+                    DEFAULT_FPS
+                )
+                FakeOpenCVSDKAdapter._camera_properties[
+                    (self.index, FakeOpenCVSDKAdapter.CAP_PROP_FRAME_WIDTH)
+                ] = float(FakeOpenCVSDKAdapter._simulated_image.shape[1])
+                FakeOpenCVSDKAdapter._camera_properties[
+                    (self.index, FakeOpenCVSDKAdapter.CAP_PROP_FRAME_HEIGHT)
+                ] = float(FakeOpenCVSDKAdapter._simulated_image.shape[0])
+            else:
+                FakeOpenCVSDKAdapter._cameras_opened[self.index] = False
+                print(f"[FAKE SDK] Failed to open camera {self.index}")
+
+        def isOpened(self) -> bool:
+            return FakeOpenCVSDKAdapter._cameras_opened.get(self.index, False)
+
+        def release(self) -> None:
+            if self.index in FakeOpenCVSDKAdapter._cameras_opened:
+                FakeOpenCVSDKAdapter._cameras_opened[self.index] = False
+                print(f"[FAKE SDK] Released camera {self.index}")
+                # Clear properties on release
+                props_to_remove = [k for k in FakeOpenCVSDKAdapter._camera_properties if k[0] == self.index]
+                for k in props_to_remove:
+                    del FakeOpenCVSDKAdapter._camera_properties[k]
+
+        def set(self, propId: int, value: float) -> bool:
+            if not self.isOpened():
+                return False
+            print(
+                f"[FAKE SDK] Ignoring set property {propId} = {value} for camera {self.index} to preserve state."
+            )
+            # FakeOpenCVSDKAdapter._camera_properties[(self.index, propId)] = value
+            # Simulate failure for specific unrealistic settings if needed
+            return True
+
+        def get(self, propId: int) -> float:
+            if not self.isOpened():
+                return 0.0  # Or raise error? Mimic cv2 behavior
+            val = FakeOpenCVSDKAdapter._camera_properties.get((self.index, propId))
+            print(f"[FAKE SDK] Get property {propId} for camera {self.index} -> {val}")
+            return val
+
+        def read(self) -> Tuple[bool, Optional[np.ndarray]]:
+            if not self.isOpened():
+                print(f"[FAKE SDK] Read failed: Camera {self.index} not open.")
+                return False, None
+
+            FakeOpenCVSDKAdapter._image_read_count += 1
+            if (
+                FakeOpenCVSDKAdapter._fail_read_after is not None
+                and FakeOpenCVSDKAdapter._image_read_count > FakeOpenCVSDKAdapter._fail_read_after
+            ):
+                print(
+                    f"[FAKE SDK] Simulated read failure for camera {self.index} after {FakeOpenCVSDKAdapter._fail_read_after} reads."
+                )
+                return False, None
+
+            print(
+                f"[FAKE SDK] Read image from camera {self.index} (read #{FakeOpenCVSDKAdapter._image_read_count})"
+            )
+            # Return a copy to prevent modification issues if the caller changes it
+            return True, FakeOpenCVSDKAdapter._simulated_image.copy()
+
+        def __del__(self):
+            # Ensure cleanup if garbage collected
+            self.release()
+
+    VideoCapture = FakeVideoCapture  # Assign inner class
+
+    # --- Methods ---
+    def setNumThreads(self, nthreads: int) -> None:
+        print(f"[FAKE SDK] setNumThreads({nthreads}) called.")
+        # No actual behavior needed in fake
+
+    def cvtColor(self, src: np.ndarray, code: int) -> np.ndarray:
+        print(f"[FAKE SDK] cvtColor called with code {code}.")
+        # Just return the source image, or simulate channel swap if needed
+        if code == self.COLOR_BGR2RGB and src.shape[2] == 3:
+            print("[FAKE SDK] Simulating BGR -> RGB conversion.")
+            return src[..., ::-1]
+        return src.copy()
+
+    def rotate(self, src: np.ndarray, rotateCode: int) -> np.ndarray:
+        print(f"[FAKE SDK] rotate called with code {rotateCode}.")
+        if rotateCode == self.ROTATE_90_COUNTERCLOCKWISE:
+            print("[FAKE SDK] Simulating 90 degree counter-clockwise rotation.")
+            rotated_img = np.rot90(np.rot90(np.rot90(src.copy())))
+            return rotated_img
+        elif rotateCode == self.ROTATE_90_CLOCKWISE:
+            print("[FAKE SDK] Simulating 90 degree clockwise rotation.")
+            rotated_img = np.rot90(src.copy())
+            return rotated_img
+        elif rotateCode == self.ROTATE_180:
+            print("[FAKE SDK] Simulating 180 degree rotation.")
+            rotated_img = np.rot90(np.rot90(src.copy()))
+            return rotated_img
+        return src.copy()

lerobot/common/cameras/opencv/camera_opencv.py

@@ -25,7 +25,6 @@ import threading
 import time
 from pathlib import Path
 
-import cv2
 import numpy as np
 from PIL import Image
 
@@ -36,6 +35,7 @@ from lerobot.common.utils.robot_utils import (
 from lerobot.common.utils.utils import capture_timestamp_utc
 
 from ..camera import Camera
+from ..interface_camera_sdk import IOpenCVSDK, OpenCVSDKAdapter
 from .configuration_opencv import OpenCVCameraConfig
 
 # The maximum opencv device index depends on your operating system. For instance,
@@ -46,12 +46,17 @@ from .configuration_opencv import OpenCVCameraConfig
 MAX_OPENCV_INDEX = 60
 
 
-def find_cameras(raise_when_empty=False, max_index_search_range=MAX_OPENCV_INDEX) -> list[dict]:
+def find_cameras(
+    raise_when_empty=False, max_index_search_range=MAX_OPENCV_INDEX, cv2_sdk: IOpenCVSDK = None
+) -> list[dict]:
+    if cv2_sdk is None:
+        cv2_sdk = OpenCVSDKAdapter()
+
     cameras = []
     if platform.system() == "Linux":
         print("Linux detected. Finding available camera indices through scanning '/dev/video*' ports")
         possible_ports = [str(port) for port in Path("/dev").glob("video*")]
-        ports = _find_cameras(possible_ports)
+        ports = _find_cameras(possible_ports, cv2_sdk=cv2_sdk)
         for port in ports:
             cameras.append(
                 {
@@ -65,7 +70,7 @@ def find_cameras(raise_when_empty=False, max_index_search_range=MAX_OPENCV_INDEX
             f"scanning all indices from 0 to {MAX_OPENCV_INDEX}"
         )
         possible_indices = range(max_index_search_range)
-        indices = _find_cameras(possible_indices)
+        indices = _find_cameras(possible_indices, cv2_sdk=cv2_sdk)
         for index in indices:
             cameras.append(
                 {
@@ -77,10 +82,15 @@ def find_cameras(raise_when_empty=False, max_index_search_range=MAX_OPENCV_INDEX
     return cameras
 
 
-def _find_cameras(possible_camera_ids: list[int | str], raise_when_empty=False) -> list[int | str]:
+def _find_cameras(
+    possible_camera_ids: list[int | str], raise_when_empty=False, cv2_sdk: IOpenCVSDK = None
+) -> list[int | str]:
+    if cv2_sdk is None:
+        cv2_sdk = OpenCVSDKAdapter()
+
     camera_ids = []
     for camera_idx in possible_camera_ids:
-        camera = cv2.VideoCapture(camera_idx)
+        camera = cv2_sdk.VideoCapture(camera_idx)
         is_open = camera.isOpened()
         camera.release()
 
@@ -121,20 +131,24 @@ def save_images_from_cameras(
     width=None,
     height=None,
     record_time_s=2,
+    cv2_sdk: IOpenCVSDK = None,
 ):
     """
     Initializes all the cameras and saves images to the directory. Useful to visually identify the camera
     associated to a given camera index.
     """
+    if cv2_sdk is None:
+        cv2_sdk = OpenCVSDKAdapter()
+
     if camera_ids is None or len(camera_ids) == 0:
-        camera_infos = find_cameras()
+        camera_infos = find_cameras(cv2_sdk=cv2_sdk)
         camera_ids = [cam["index"] for cam in camera_infos]
 
     print("Connecting cameras")
     cameras = []
     for cam_idx in camera_ids:
         config = OpenCVCameraConfig(camera_index=cam_idx, fps=fps, width=width, height=height)
-        camera = OpenCVCamera(config)
+        camera = OpenCVCamera(config, cv2_sdk=cv2_sdk)
         camera.connect()
         print(
             f"OpenCVCamera({camera.camera_index}, fps={camera.fps}, width={camera.capture_width}, "
@@ -221,11 +235,16 @@ class OpenCVCamera(Camera):
     ```
     """
 
-    def __init__(self, config: OpenCVCameraConfig):
+    def __init__(self, config: OpenCVCameraConfig, cv2_sdk: IOpenCVSDK = None):
         self.config = config
         self.camera_index = config.camera_index
         self.port = None
 
+        if cv2_sdk is None:
+            cv2_sdk = OpenCVSDKAdapter()
+
+        self.cv2_sdk = cv2_sdk
+
         # Linux uses ports for connecting to cameras
         if platform.system() == "Linux":
             if isinstance(self.camera_index, int):
@@ -262,34 +281,36 @@ class OpenCVCamera(Camera):
 
         self.rotation = None
         if config.rotation == -90:
-            self.rotation = cv2.ROTATE_90_COUNTERCLOCKWISE
+            self.rotation = cv2_sdk.ROTATE_90_COUNTERCLOCKWISE
         elif config.rotation == 90:
-            self.rotation = cv2.ROTATE_90_CLOCKWISE
+            self.rotation = cv2_sdk.ROTATE_90_CLOCKWISE
         elif config.rotation == 180:
-            self.rotation = cv2.ROTATE_180
+            self.rotation = cv2_sdk.ROTATE_180
 
     def connect(self):
         if self.is_connected:
             raise DeviceAlreadyConnectedError(f"OpenCVCamera({self.camera_index}) is already connected.")
 
+        cv2_sdk = self.cv2_sdk
+
         # Use 1 thread to avoid blocking the main thread. Especially useful during data collection
         # when other threads are used to save the images.
-        cv2.setNumThreads(1)
+        cv2_sdk.setNumThreads(1)
 
         backend = (
-            cv2.CAP_V4L2
+            cv2_sdk.CAP_V4L2
             if platform.system() == "Linux"
-            else cv2.CAP_DSHOW
+            else cv2_sdk.CAP_DSHOW
             if platform.system() == "Windows"
-            else cv2.CAP_AVFOUNDATION
+            else cv2_sdk.CAP_AVFOUNDATION
             if platform.system() == "Darwin"
-            else cv2.CAP_ANY
+            else cv2_sdk.CAP_ANY
         )
 
         camera_idx = f"/dev/video{self.camera_index}" if platform.system() == "Linux" else self.camera_index
         # First create a temporary camera trying to access `camera_index`,
         # and verify it is a valid camera by calling `isOpened`.
-        tmp_camera = cv2.VideoCapture(camera_idx, backend)
+        tmp_camera = cv2_sdk.VideoCapture(camera_idx, backend)
         is_camera_open = tmp_camera.isOpened()
         # Release camera to make it accessible for `find_camera_indices`
         tmp_camera.release()
@@ -299,7 +320,7 @@ class OpenCVCamera(Camera):
         # valid cameras.
         if not is_camera_open:
             # Verify that the provided `camera_index` is valid before printing the traceback
-            cameras_info = find_cameras()
+            cameras_info = find_cameras(cv2_sdk=cv2_sdk)
             available_cam_ids = [cam["index"] for cam in cameras_info]
             if self.camera_index not in available_cam_ids:
                 raise ValueError(
@@ -312,18 +333,18 @@ class OpenCVCamera(Camera):
         # Secondly, create the camera that will be used downstream.
         # Note: For some unknown reason, calling `isOpened` blocks the camera which then
         # needs to be re-created.
-        self.camera = cv2.VideoCapture(camera_idx, backend)
+        self.camera = cv2_sdk.VideoCapture(camera_idx, backend)
 
         if self.fps is not None:
-            self.camera.set(cv2.CAP_PROP_FPS, self.fps)
+            self.camera.set(cv2_sdk.CAP_PROP_FPS, self.fps)
         if self.capture_width is not None:
-            self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, self.capture_width)
+            self.camera.set(cv2_sdk.CAP_PROP_FRAME_WIDTH, self.capture_width)
         if self.capture_height is not None:
-            self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, self.capture_height)
+            self.camera.set(cv2_sdk.CAP_PROP_FRAME_HEIGHT, self.capture_height)
 
-        actual_fps = self.camera.get(cv2.CAP_PROP_FPS)
-        actual_width = self.camera.get(cv2.CAP_PROP_FRAME_WIDTH)
-        actual_height = self.camera.get(cv2.CAP_PROP_FRAME_HEIGHT)
+        actual_fps = self.camera.get(cv2_sdk.CAP_PROP_FPS)
+        actual_width = self.camera.get(cv2_sdk.CAP_PROP_FRAME_WIDTH)
+        actual_height = self.camera.get(cv2_sdk.CAP_PROP_FRAME_HEIGHT)
 
         # Using `math.isclose` since actual fps can be a float (e.g. 29.9 instead of 30)
         if self.fps is not None and not math.isclose(self.fps, actual_fps, rel_tol=1e-3):
@@ -361,6 +382,8 @@ class OpenCVCamera(Camera):
                 f"OpenCVCamera({self.camera_index}) is not connected. Try running `camera.connect()` first."
             )
 
+        cv2_sdk = self.cv2_sdk
+
         start_time = time.perf_counter()
 
         ret, color_image = self.camera.read()
@@ -379,7 +402,7 @@ class OpenCVCamera(Camera):
         # However, Deep Learning framework such as LeRobot uses RGB format as default to train neural networks,
         # so we convert the image color from BGR to RGB.
         if requested_color_mode == "rgb":
-            color_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2RGB)
+            color_image = cv2_sdk.cvtColor(color_image, cv2_sdk.COLOR_BGR2RGB)
 
         h, w, _ = color_image.shape
         if h != self.capture_height or w != self.capture_width:
@@ -388,7 +411,7 @@ class OpenCVCamera(Camera):
             )
 
         if self.rotation is not None:
-            color_image = cv2.rotate(color_image, self.rotation)
+            color_image = cv2_sdk.rotate(color_image, self.rotation)
 
         # log the number of seconds it took to read the image
         self.logs["delta_timestamp_s"] = time.perf_counter() - start_time

tests/cameras/test_cv2_camera.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,38 +11,31 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# Note: The current test approach uses mock/patch per management decision.
-# Future maintainers may consider Dependency Injection for improved testability.
-# As it currently stands, it is brittle, requires complex mocks and discourages refactoring.
-# Everytime that we change the implementation code, we might need to change the tests.
+import os
+import platform
 import unittest
 from pathlib import Path
-from unittest.mock import MagicMock, call, patch
+from unittest.mock import MagicMock, patch
 
 import numpy as np
+import pytest
 
+from lerobot.common.cameras.interface_camera_sdk import FakeOpenCVSDKAdapter, IVideoCapture, OpenCVSDKAdapter
 from lerobot.common.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
-
-# We might need to mock these
-from lerobot.common.errors import (
-    DeviceAlreadyConnectedError,
-    DeviceNotConnectedError,
-)
+from lerobot.common.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 MODULE_PATH = "lerobot.common.cameras.opencv.camera_opencv"
 
 # Define constants that might be used by mocks
-MOCK_CV2_CAP_PROP_FPS = 30
-MOCK_CV2_CAP_PROP_FRAME_WIDTH = 1280
-MOCK_CV2_CAP_PROP_FRAME_HEIGHT = 720
-MOCK_CV2_ROTATE_90_CLOCKWISE = 90
-MOCK_CV2_ROTATE_180 = 180
-MOCK_CV2_ROTATE_90_COUNTERCLOCKWISE = -90
-MOCK_CV2_COLOR_BGR2RGB = 99
-MOCK_CV2_CAP_V4L2 = 91
-MOCK_CV2_CAP_DSHOW = 92
-MOCK_CV2_CAP_AVFOUNDATION = 93
-MOCK_CV2_CAP_ANY = 90
+MOCK_CV2_CAP_PROP_FPS = FakeOpenCVSDKAdapter.CAP_PROP_FPS
+MOCK_CV2_CAP_PROP_FRAME_WIDTH = FakeOpenCVSDKAdapter.CAP_PROP_FRAME_WIDTH
+MOCK_CV2_CAP_PROP_FRAME_HEIGHT = FakeOpenCVSDKAdapter.CAP_PROP_FRAME_HEIGHT
+
+# TODO(Steven): Consider a CLI argument to set this
+# Emulates the cheap USB camera in index 0
+LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS = (
+    os.getenv("LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS", "False").lower() == "true"
+)
 
 
 # Helper function to create a realistic-looking dummy image
@@ -57,7 +48,7 @@ def create_dummy_image(height, width, channels=3):
 
 class TestOpenCVCamera(unittest.TestCase):
     def setUp(self):
-        # Default config used in many tests
+        # Emulates the cheap USB camera in index 0
         self.default_config = OpenCVCameraConfig(
             camera_index=0,
             width=MOCK_CV2_CAP_PROP_FRAME_WIDTH,
@@ -66,44 +57,27 @@ class TestOpenCVCamera(unittest.TestCase):
             color_mode="rgb",
             rotation=None,
         )
-        # Create a default dummy image based on config
-        self.dummy_bgr_image = create_dummy_image(self.default_config.height, self.default_config.width)
-        self.dummy_rgb_image = self.dummy_bgr_image[..., ::-1]  # Simple BGR -> RGB simulation
-
-        self.patch_dependencies()
-
-    # --- Mock Setup ---
-    def patch_dependencies(self):
-        # Mock the cv2 module itself
-        patcher_cv2 = patch(f"{MODULE_PATH}.cv2", autospec=True)
-        self.mock_cv2 = patcher_cv2.start()
-        self.addCleanup(patcher_cv2.stop)
-
-        # Mock the VideoCapture class returned by cv2.VideoCapture
-        self.mock_capture_instance = MagicMock()
-        self.mock_cv2.VideoCapture.return_value = self.mock_capture_instance
-
-        # Assign mock constants (important for comparisons and calls)
-        self.mock_cv2.CAP_PROP_FPS = MOCK_CV2_CAP_PROP_FPS
-        self.mock_cv2.CAP_PROP_FRAME_WIDTH = MOCK_CV2_CAP_PROP_FRAME_WIDTH
-        self.mock_cv2.CAP_PROP_FRAME_HEIGHT = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-        self.mock_cv2.ROTATE_90_CLOCKWISE = MOCK_CV2_ROTATE_90_CLOCKWISE
-        self.mock_cv2.ROTATE_180 = MOCK_CV2_ROTATE_180
-        self.mock_cv2.ROTATE_90_COUNTERCLOCKWISE = MOCK_CV2_ROTATE_90_COUNTERCLOCKWISE
-        self.mock_cv2.COLOR_BGR2RGB = MOCK_CV2_COLOR_BGR2RGB
-        self.mock_cv2.CAP_V4L2 = MOCK_CV2_CAP_V4L2
-        self.mock_cv2.CAP_DSHOW = MOCK_CV2_CAP_DSHOW
-        self.mock_cv2.CAP_AVFOUNDATION = MOCK_CV2_CAP_AVFOUNDATION
-        self.mock_cv2.CAP_ANY = MOCK_CV2_CAP_ANY
+        # TODO(Steven): Consider calling this only once, instead of in every test
+        if LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS:
+            # Use the real OpenCV SDK
+            self.test_sdk = OpenCVSDKAdapter()
+            # self.addCleanup()
+        else:
+            # Create a default dummy image based on config
+            self.dummy_bgr_image = create_dummy_image(self.default_config.height, self.default_config.width)
+            self.dummy_rgb_image = self.dummy_bgr_image[..., ::-1]  # Simple BGR -> RGB simulation
+            FakeOpenCVSDKAdapter.init_configure_fake(simulated_image=self.dummy_bgr_image)
+            self.test_sdk = FakeOpenCVSDKAdapter()
+            # self.addCleanup()
 
         patcher_platform = patch(f"{MODULE_PATH}.platform.system")
         self.mock_platform_system = patcher_platform.start()
         self.addCleanup(patcher_platform.stop)
         self.mock_platform_system.return_value = "Darwin"  # Default to macOS
 
-        mock_is_valid_unix_path = patch(f"{MODULE_PATH}.is_valid_unix_path")
-        self.mock_is_valid_unix_path = mock_is_valid_unix_path.start()
-        self.addCleanup(mock_is_valid_unix_path.stop)
+        patcher_is_valid_unix_path = patch(f"{MODULE_PATH}.is_valid_unix_path")
+        self.mock_is_valid_unix_path = patcher_is_valid_unix_path.start()
+        self.addCleanup(patcher_is_valid_unix_path.stop)
         self.mock_is_valid_unix_path.return_value = True
 
         patcher_time_sleep = patch(f"{MODULE_PATH}.time.sleep", return_value=None)
@@ -124,18 +98,9 @@ class TestOpenCVCamera(unittest.TestCase):
         self.mock_event_class.return_value = self.mock_event_instance
         self.mock_event_instance.is_set.return_value = False  # Default to not set
 
-        # Mock internal utility functions if they interact with system/cv2
-        patcher_find_cameras = patch(f"{MODULE_PATH}.find_cameras")
-        self.mock_find_cameras = patcher_find_cameras.start()
-        self.addCleanup(patcher_find_cameras.stop)
-
-        patcher_get_index = patch(f"{MODULE_PATH}.get_camera_index_from_unix_port")
-        self.mock_get_camera_index_from_unix_port = patcher_get_index.start()
-        self.addCleanup(patcher_get_index.stop)
-
-    # --- Test __init__ ---
+    # --- Tests __init__ ---
     def test_init_defaults(self):
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
 
         self.assertEqual(cam.camera_index, 0)
         self.assertEqual(cam.capture_width, MOCK_CV2_CAP_PROP_FRAME_WIDTH)
@@ -151,129 +116,94 @@ class TestOpenCVCamera(unittest.TestCase):
     def test_init_with_rotation_90(self):
         config = self.default_config
         config.rotation = 90
-        cam = OpenCVCamera(config)
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
         self.assertEqual(cam.width, MOCK_CV2_CAP_PROP_FRAME_HEIGHT)  # Swapped
         self.assertEqual(cam.height, MOCK_CV2_CAP_PROP_FRAME_WIDTH)  # Swapped
-        self.assertEqual(cam.rotation, MOCK_CV2_ROTATE_90_CLOCKWISE)
+        self.assertEqual(cam.rotation, self.test_sdk.ROTATE_90_CLOCKWISE)
 
     def test_init_with_rotation_minus_90(self):
         config = self.default_config
         config.rotation = -90
-        cam = OpenCVCamera(config)
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
         self.assertEqual(cam.width, MOCK_CV2_CAP_PROP_FRAME_HEIGHT)  # Swapped
         self.assertEqual(cam.height, MOCK_CV2_CAP_PROP_FRAME_WIDTH)  # Swapped
-        self.assertEqual(cam.rotation, MOCK_CV2_ROTATE_90_COUNTERCLOCKWISE)
+        self.assertEqual(cam.rotation, self.test_sdk.ROTATE_90_COUNTERCLOCKWISE)
 
     def test_init_with_rotation_180(self):
         config = self.default_config
         config.rotation = 180
-        cam = OpenCVCamera(config)
-        self.assertEqual(cam.width, MOCK_CV2_CAP_PROP_FRAME_WIDTH)  # Not swapped
-        self.assertEqual(cam.height, MOCK_CV2_CAP_PROP_FRAME_HEIGHT)  # Not swapped
-        self.assertEqual(cam.rotation, MOCK_CV2_ROTATE_180)
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
+        self.assertEqual(cam.width, MOCK_CV2_CAP_PROP_FRAME_WIDTH)  # Swapped
+        self.assertEqual(cam.height, MOCK_CV2_CAP_PROP_FRAME_HEIGHT)  # Swapped
+        self.assertEqual(cam.rotation, self.test_sdk.ROTATE_180)
 
+    @pytest.mark.skipif(
+        LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS and platform.system() != "Linux",
+        reason="Not valid for real camera for other platform than Linux",
+    )
     def test_init_linux_with_index(self):
         self.mock_platform_system.return_value = "Linux"
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         self.assertEqual(cam.camera_index, 0)
         self.assertIsInstance(cam.port, Path)
         self.assertEqual(str(cam.port), "/dev/video0")
 
+    @pytest.mark.skipif(
+        LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS and platform.system() != "Linux",
+        reason="Not valid for real camera for other platform than Linux",
+    )
     def test_init_linux_with_valid_path(self):
         self.mock_platform_system.return_value = "Linux"
-        self.mock_is_valid_unix_path.return_value = True
-        self.mock_get_camera_index_from_unix_port.return_value = 2
         config = self.default_config
         config.camera_index = "/dev/video2"
-        cam = OpenCVCamera(config)
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
         self.assertIsInstance(cam.port, Path)
         self.assertEqual(str(cam.port), "/dev/video2")
         self.assertEqual(cam.camera_index, 2)
-        self.mock_is_valid_unix_path.assert_called_once_with("/dev/video2")
 
+    @pytest.mark.skipif(
+        LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS and platform.system() != "Linux",
+        reason="Not valid for real camera for other platform than Linux",
+    )
     def test_init_linux_with_invalid_path(self):
         self.mock_platform_system.return_value = "Linux"
         self.mock_is_valid_unix_path.return_value = False
         config = self.default_config
         config.camera_index = "[*?:[/invalid/path"
         with self.assertRaisesRegex(ValueError, "Please check the provided camera_index"):
-            OpenCVCamera(config)
+            OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
     # --- Test connect ---
     def test_connect_success(self):
-        cam = OpenCVCamera(self.default_config)
-
-        # Mock the temporary camera check
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = True
-        # First call to VideoCapture is the temporary one
-        # Second call is the real one
-        self.mock_cv2.VideoCapture.side_effect = [mock_tmp_capture, self.mock_capture_instance]
-
-        # Mock the actual camera setup
-        self.mock_capture_instance.get.side_effect = [
-            self.default_config.fps,
-            self.default_config.width,
-            self.default_config.height,
-        ]
-
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         cam.connect()
 
-        # Check temporary camera interactions
-        self.assertEqual(self.mock_cv2.VideoCapture.call_count, 2)
-        self.mock_cv2.VideoCapture.assert_any_call(
-            self.default_config.camera_index, MOCK_CV2_CAP_AVFOUNDATION
-        )
-        mock_tmp_capture.isOpened.assert_called_once()
-        mock_tmp_capture.release.assert_called_once()
-
-        # Check actual camera interactions
-        self.mock_capture_instance.set.assert_has_calls(
-            [
-                call(MOCK_CV2_CAP_PROP_FPS, self.default_config.fps),
-                call(MOCK_CV2_CAP_PROP_FRAME_WIDTH, self.default_config.width),
-                call(MOCK_CV2_CAP_PROP_FRAME_HEIGHT, self.default_config.height),
-            ]
-        )
-        self.mock_capture_instance.get.assert_has_calls(
-            [
-                call(MOCK_CV2_CAP_PROP_FPS),
-                call(MOCK_CV2_CAP_PROP_FRAME_WIDTH),
-                call(MOCK_CV2_CAP_PROP_FRAME_HEIGHT),
-            ]
-        )
         self.assertTrue(cam.is_connected)
         self.assertIsNotNone(cam.camera)
-        self.mock_cv2.setNumThreads.assert_called_once_with(1)
-        # Check stored actual values (after rounding)
+        self.assertIsInstance(cam.camera, IVideoCapture)
         self.assertEqual(cam.fps, self.default_config.fps)
         self.assertEqual(cam.capture_width, self.default_config.width)
         self.assertEqual(cam.capture_height, self.default_config.height)
 
+    @pytest.mark.skipif(
+        LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS and platform.system() != "Linux",
+        reason="Not valid for real camera for other platform than Linux",
+    )
     def test_connect_success_linux(self):
         self.mock_platform_system.return_value = "Linux"
-        cam = OpenCVCamera(self.default_config)
-
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = True
-        self.mock_cv2.VideoCapture.side_effect = [mock_tmp_capture, self.mock_capture_instance]
-        self.mock_capture_instance.get.side_effect = [
-            MOCK_CV2_CAP_PROP_FPS,
-            MOCK_CV2_CAP_PROP_FRAME_WIDTH,
-            MOCK_CV2_CAP_PROP_FRAME_HEIGHT,
-        ]  # Floats are ok
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
 
         cam.connect()
 
         self.assertTrue(cam.is_connected)
         self.assertIsNotNone(cam.camera)
-        self.assertEqual(self.mock_cv2.VideoCapture.call_count, 2)
-        # Check it uses the port path and correct backend
-        self.mock_cv2.VideoCapture.assert_any_call("/dev/video0", MOCK_CV2_CAP_V4L2)
+        self.assertIsInstance(cam.camera, IVideoCapture)
+        # self.assertIn('/dev/video0', self.test_sdk._cameras_opened)
+        # self.assertEqual(self.test_sdk.FakeVideoCapture.backend, self.test_sdk.CAP_V4L2)
 
     def test_connect_already_connected(self):
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         # Simulate already connected state
         cam.is_connected = True
         with self.assertRaisesRegex(DeviceAlreadyConnectedError, "already connected"):
@@ -282,45 +212,19 @@ class TestOpenCVCamera(unittest.TestCase):
 
     def test_connect_camera_not_opened_invalid_index(self):
         config = self.default_config
-        config.camera_index = 99
-        cam = OpenCVCamera(config)
-
-        # Mock temporary check failing
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = False
-        self.mock_cv2.VideoCapture.return_value = mock_tmp_capture  # Only tmp is created
-
-        # Mock find_cameras returning *other* indices
-        self.mock_find_cameras.return_value = [
-            {"index": 0, "port": None},
-            {"index": 1, "port": None},
-            {"index": 2, "port": None},
-        ]
+        config.camera_index = 99  # Invalid index in fakeSDK != (0,1,2)
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
         with self.assertRaisesRegex(
             ValueError, "expected to be one of these available cameras \\[0, 1, 2\\], but 99 is provided"
         ):
             cam.connect()
-
         self.assertFalse(cam.is_connected)
-        self.mock_find_cameras.assert_called_once()
-        mock_tmp_capture.release.assert_called_once()  # Should still release tmp capture
 
     def test_connect_fps_mismatch(self):
         config = self.default_config
-        config.fps = 999
-        cam = OpenCVCamera(config)
-
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = True
-        self.mock_cv2.VideoCapture.side_effect = [mock_tmp_capture, self.mock_capture_instance]
-
-        # Mock get to return a different FPS
-        self.mock_capture_instance.get.side_effect = [
-            MOCK_CV2_CAP_PROP_FPS,  # Different FPS
-            self.default_config.width,
-            self.default_config.height,
-        ]
+        config.fps = 999  # Different FPS
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
         with self.assertRaisesRegex(
             OSError, f"Can't set self.fps=999 .* Actual value is {MOCK_CV2_CAP_PROP_FPS}"
@@ -331,20 +235,10 @@ class TestOpenCVCamera(unittest.TestCase):
     def test_connect_width_mismatch(self):
         config = self.default_config
         config.width = 9999
-        cam = OpenCVCamera(config)
-
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = True
-        self.mock_cv2.VideoCapture.side_effect = [mock_tmp_capture, self.mock_capture_instance]
-
-        self.mock_capture_instance.get.side_effect = [
-            self.default_config.fps,
-            MOCK_CV2_CAP_PROP_FRAME_WIDTH,  # Different width
-            self.default_config.height,
-        ]
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
         with self.assertRaisesRegex(
-            OSError, f"Can't set self.capture_width=9999 .* Actual value is {MOCK_CV2_CAP_PROP_FRAME_WIDTH}"
+            OSError, f"Can't set self.capture_width=9999.* Actual value is {MOCK_CV2_CAP_PROP_FRAME_WIDTH}"
         ):
             cam.connect()
         self.assertFalse(cam.is_connected)
@@ -352,123 +246,87 @@ class TestOpenCVCamera(unittest.TestCase):
     def test_connect_height_mismatch(self):
         config = self.default_config
         config.height = 9999
-        cam = OpenCVCamera(config)
-
-        mock_tmp_capture = MagicMock()
-        mock_tmp_capture.isOpened.return_value = True
-        self.mock_cv2.VideoCapture.side_effect = [mock_tmp_capture, self.mock_capture_instance]
-
-        self.mock_capture_instance.get.side_effect = [
-            self.default_config.fps,
-            self.default_config.width,
-            MOCK_CV2_CAP_PROP_FRAME_HEIGHT,  # Different height
-        ]
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
 
         with self.assertRaisesRegex(
-            OSError, f"Can't set self.capture_height=9999 .* Actual value is {MOCK_CV2_CAP_PROP_FRAME_HEIGHT}"
+            OSError, f"Can't set self.capture_height=9999.* Actual value is {MOCK_CV2_CAP_PROP_FRAME_HEIGHT}"
         ):
             cam.connect()
         self.assertFalse(cam.is_connected)
 
     # --- Test read ---
     def test_read_not_connected(self):
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         with self.assertRaisesRegex(DeviceNotConnectedError, "not connected"):
             cam.read()
 
     def test_read_success_rgb(self):
-        cam = OpenCVCamera(self.default_config)
-        cam.camera = self.mock_capture_instance  # Simulate connection
-        cam.is_connected = True
-        cam.capture_width = MOCK_CV2_CAP_PROP_FRAME_WIDTH  # Set dimensions as if connect succeeded
-        cam.capture_height = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-
-        self.mock_capture_instance.read.return_value = (True, self.dummy_bgr_image)
-        self.mock_cv2.cvtColor.return_value = self.dummy_rgb_image  # Mock conversion
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         img = cam.read()
-
-        self.mock_capture_instance.read.assert_called_once()
-        self.mock_cv2.cvtColor.assert_called_once_with(self.dummy_bgr_image, MOCK_CV2_COLOR_BGR2RGB)
-        self.mock_cv2.rotate.assert_not_called()
-
-        np.testing.assert_array_equal(img, self.dummy_rgb_image)
+        if isinstance(self.test_sdk, FakeOpenCVSDKAdapter):
+            # When using fake SDK, verify exact match with dummy image
+            np.testing.assert_array_equal(img, self.dummy_rgb_image)
+        else:
+            # When using real camera, verify basic properties of the captured image
+            self.assertIsInstance(img, np.ndarray)
 
     def test_read_success_bgr(self):
         config = self.default_config
-        config.color_mode = "bgr"  # Request BGR
-        cam = OpenCVCamera(config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-        cam.capture_width = MOCK_CV2_CAP_PROP_FRAME_WIDTH
-        cam.capture_height = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-
-        self.mock_capture_instance.read.return_value = (True, self.dummy_bgr_image)
+        config.color_mode = "bgr"
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         img = cam.read()
-
-        self.mock_capture_instance.read.assert_called_once()
-        self.mock_cv2.cvtColor.assert_not_called()  # Should not convert
-        np.testing.assert_array_equal(img, self.dummy_bgr_image)  # Expect BGR
+        if isinstance(self.test_sdk, FakeOpenCVSDKAdapter):
+            # When using fake SDK, verify exact match with dummy image
+            np.testing.assert_array_equal(img, self.dummy_bgr_image)
+        else:
+            # When using real camera, verify basic properties of the captured image
+            self.assertIsInstance(img, np.ndarray)
 
     def test_read_success_with_rotation(self):
         config = self.default_config
         config.rotation = 90
-        cam = OpenCVCamera(config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-        cam.capture_width = MOCK_CV2_CAP_PROP_FRAME_WIDTH  # Original capture dimensions
-        cam.capture_height = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-
-        self.mock_capture_instance.read.return_value = (True, self.dummy_bgr_image)
-        self.mock_cv2.cvtColor.return_value = self.dummy_rgb_image
-        rotated_image = np.rot90(self.dummy_rgb_image)  # Simulate rotation
-        self.mock_cv2.rotate.return_value = rotated_image  # Mock rotation result
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)  # Sets cam.rotation internally
+        cam.connect()
 
         img = cam.read()
+        if isinstance(self.test_sdk, FakeOpenCVSDKAdapter):
+            # When using fake SDK, verify exact match with dummy image
+            rotated_image = np.rot90(self.dummy_rgb_image)  # Simulate rotation
+            np.testing.assert_array_equal(img, rotated_image)
+        else:
+            # When using real camera, verify basic properties of the captured image
+            self.assertEqual(img.shape, (self.default_config.width, self.default_config.height, 3))
 
-        self.mock_capture_instance.read.assert_called_once()
-        self.mock_cv2.cvtColor.assert_called_once_with(self.dummy_bgr_image, MOCK_CV2_COLOR_BGR2RGB)
-        self.mock_cv2.rotate.assert_called_once_with(self.dummy_rgb_image, MOCK_CV2_ROTATE_90_CLOCKWISE)
-        np.testing.assert_array_equal(img, rotated_image)
-
+    @pytest.mark.skipif(LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS, reason="Not valid for real camera")
     def test_read_capture_fails(self):
-        cam = OpenCVCamera(self.default_config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-
-        self.mock_capture_instance.read.return_value = (False, None)  # Simulate read failure
+        FakeOpenCVSDKAdapter.configure_fail_read_after(fail_read_after=0)  # Simulate read failure
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         with self.assertRaisesRegex(OSError, f"Can't capture color image from camera {cam.camera_index}"):
             cam.read()
 
     def test_read_invalid_temporary_color_mode(self):
-        cam = OpenCVCamera(self.default_config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-        cam.capture_width = MOCK_CV2_CAP_PROP_FRAME_WIDTH
-        cam.capture_height = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-        self.mock_capture_instance.read.return_value = (
-            True,
-            self.dummy_bgr_image,
-        )  # Need read to succeed initially
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         with self.assertRaisesRegex(
             ValueError, "Expected color values are 'rgb' or 'bgr', but xyz is provided"
         ):
             cam.read(temporary_color_mode="xyz")
 
+    @pytest.mark.skipif(LEROBOT_USE_REAL_OPENCV_CAMERA_TESTS, reason="Not valid for real camera")
     def test_read_dimension_mismatch(self):
-        wrong_dim_image = create_dummy_image(240, 320)  # Different dimensions
-        cam = OpenCVCamera(self.default_config)
-
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-        cam.capture_width = MOCK_CV2_CAP_PROP_FRAME_WIDTH  # Expected dims
-        cam.capture_height = MOCK_CV2_CAP_PROP_FRAME_HEIGHT
-
-        self.mock_capture_instance.read.return_value = (True, wrong_dim_image)
-        self.mock_cv2.cvtColor.return_value = wrong_dim_image
+        wrong_dim_image = create_dummy_image(240, 320)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
+        FakeOpenCVSDKAdapter.configure_fake_simulated_image(
+            simulated_image=wrong_dim_image
+        )  # Different dimensions
 
         with self.assertRaisesRegex(
             OSError,
@@ -476,24 +334,18 @@ class TestOpenCVCamera(unittest.TestCase):
         ):
             cam.read()
 
-    # --- Test async_read ---
+    # --- Async Read Tests ---
     def test_async_read_not_connected(self):
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         with self.assertRaisesRegex(DeviceNotConnectedError, "not connected"):
             cam.async_read()
 
-    # TODO(Steven): Not sure about this one
-    @patch.object(OpenCVCamera, "read", autospec=True)  # Mock the instance's read method
-    def test_async_read_starts_thread_and_returns_image(self, mock_instance_read):
-        cam = OpenCVCamera(self.default_config)
-        cam.is_connected = True  # Simulate connection
-
-        # TODO(Steven): This is dirty
-        def mock_read_effect(self_cam_instance):
-            self_cam_instance.color_image = self.dummy_rgb_image
-            return self.dummy_rgb_image
-
-        mock_instance_read.side_effect = mock_read_effect
+    # TODO(Steven): This is dirty, but at least we don't have to manually mock the read
+    def test_async_read_starts_thread_and_returns_image(
+        self,
+    ):
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         def mock_start():
             cam.read_loop()
@@ -512,25 +364,18 @@ class TestOpenCVCamera(unittest.TestCase):
         self.assertTrue(self.mock_thread_instance.daemon)
         self.assertIsNotNone(cam.thread)
         self.assertIsNotNone(cam.stop_event)
-        mock_instance_read.assert_called_once_with(cam)
 
-        cam.is_connected = False  # To avoid warning when running the destructor
+        if isinstance(self.test_sdk, FakeOpenCVSDKAdapter):
+            # When using fake SDK, verify exact match with dummy image
+            np.testing.assert_array_equal(img, self.dummy_rgb_image)
+        else:
+            # When using real camera, verify basic properties of the captured image
+            self.assertIsInstance(img, np.ndarray)
 
-        # Assert the image returned by async_read is the one set by the mocked read
-        np.testing.assert_array_equal(img, self.dummy_rgb_image)
-
-    @patch.object(OpenCVCamera, "read", autospec=True)
-    def test_async_read_timeout(self, mock_instance_read):
+    def test_async_read_timeout(self):
         config = self.default_config
-        cam = OpenCVCamera(config)
-        cam.is_connected = True
-
-        # Mock 'read' so it *never* sets color_image
-        def mock_read_effect(self_cam_instance):
-            self_cam_instance.color_image = None
-            return None
-
-        mock_instance_read.side_effect = mock_read_effect
+        cam = OpenCVCamera(config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         with self.assertRaisesRegex(TimeoutError, "Timed out waiting for async_read"):
             cam.async_read()
@@ -543,18 +388,15 @@ class TestOpenCVCamera(unittest.TestCase):
         self.assertIsNotNone(cam.thread)
         self.assertIsNotNone(cam.stop_event)
 
-        cam.is_connected = False  # To avoid warning when running the destructor
-
-    # --- Test disconnect ---
+    # --- Disconnection Tests ---
     def test_disconnect_not_connected(self):
-        cam = OpenCVCamera(self.default_config)
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
         with self.assertRaisesRegex(DeviceNotConnectedError, "not connected"):
             cam.disconnect()
 
     def test_disconnect_no_thread(self):
-        cam = OpenCVCamera(self.default_config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         cam.disconnect()
 
@@ -563,22 +405,9 @@ class TestOpenCVCamera(unittest.TestCase):
         self.assertIsNone(cam.thread)
         self.assertIsNone(cam.stop_event)
 
-        self.mock_capture_instance.release.assert_called_once()
-        self.mock_event_instance.set.assert_not_called()
-        self.mock_thread_instance.join.assert_not_called()
-
-    @patch.object(OpenCVCamera, "read", autospec=True)
-    def test_disconnect_with_thread(self, mock_instance_read):
-        cam = OpenCVCamera(self.default_config)
-        cam.camera = self.mock_capture_instance
-        cam.is_connected = True
-
-        # TODO(Steven): This is dirty
-        def mock_read_effect(self_cam_instance):
-            self_cam_instance.color_image = self.dummy_rgb_image
-            return self.dummy_rgb_image
-
-        mock_instance_read.side_effect = mock_read_effect
+    def test_disconnect_with_thread(self):
+        cam = OpenCVCamera(self.default_config, cv2_sdk=self.test_sdk)
+        cam.connect()
 
         def mock_start():
             cam.read_loop()
@@ -588,7 +417,6 @@ class TestOpenCVCamera(unittest.TestCase):
         # Make Event.is_set return False initially, then True after disconnect/stop
         self.mock_event_instance.is_set.side_effect = [False, True]
 
-        # Start the thread
         _img = cam.async_read()
 
         self.assertIsNotNone(cam.thread)
@@ -600,9 +428,6 @@ class TestOpenCVCamera(unittest.TestCase):
         self.mock_event_instance.set.assert_called_once()
         self.mock_thread_instance.join.assert_called_once()
 
-        # Check camera release
-        self.mock_capture_instance.release.assert_called_once()
-
         # Check state reset
         self.assertIsNone(cam.camera)
         self.assertFalse(cam.is_connected)