Improve testing

Test the cases of missing libraries when using XCB.

Add fixtures to reset the XCB library loader after each testcase.

Add fixtures to check for Xlib errors after each testcase.

Author: jholveck

pyproject.toml

@@ -134,6 +134,7 @@ strict_equality = true
 
 [tool.pytest.ini_options]
 pythonpath = "src"
+markers = ["without_libraries"]
 addopts = """
   --showlocals
   --strict-markers

src/mss/linux/xcb.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import ctypes.util
+from contextlib import suppress
 from copy import copy
 from ctypes import (
     CDLL,
@@ -22,7 +24,6 @@
     cast,
     cdll,
 )
-from ctypes.util import find_library
 from threading import Lock
 from typing import TYPE_CHECKING
 from weakref import finalize
@@ -857,6 +858,13 @@ def __init__(self) -> None:
         self._lock = Lock()
         self._initialized = False
 
+    def reset(self) -> None:
+        with self._lock:
+            self._initialized = False
+            for name in self._EXPOSED_NAMES:
+                with suppress(AttributeError):
+                    delattr(self, name)
+
     def __getattr__(self, name: str) -> CDLL:
         # In normal use, this will only be called once (for a library).  After that, all the names will be populated in
         # __dict__, and this fallback won't be used.
@@ -872,6 +880,7 @@ def __getattr__(self, name: str) -> CDLL:
     def load(self) -> None:
         with self._lock:
             if self._initialized:
+                # Something else initialized this object while we were waiting for the lock.
                 return
 
             # We don't use the cached versions that ctypes.cdll exposes as attributes, since other libraries may be
@@ -886,9 +895,14 @@ def load(self) -> None:
             # Alternatively, we might define the functions to be initialized with a decorator on the functions that use
             # them.
 
-            self.xcb = cdll.LoadLibrary(find_library("xcb"))
+            libxcb_so = ctypes.util.find_library("xcb")
+            if libxcb_so is None:
+                msg = "Library libxcb.so not found"
+                raise ScreenShotError(msg)
+            self.xcb = cdll.LoadLibrary(libxcb_so)
 
             # Ordered as <xcb/xcb.h>
+
             self.xcb.xcb_request_check.argtypes = [POINTER(XcbConnection), XcbVoidCookie]
             self.xcb.xcb_request_check.restype = POINTER(XcbGenericErrorStructure)
             self.xcb.xcb_discard_reply.argtypes = [POINTER(XcbConnection), c_uint]
@@ -908,6 +922,7 @@ def load(self) -> None:
             self.xcb.xcb_disconnect.restype = None
 
             # Ordered as <xcb/xproto.h>
+
             self.xcb.xcb_depth_visuals.argtypes = [POINTER(XcbDepth)]
             self.xcb.xcb_depth_visuals.restype = POINTER(XcbVisualtype)
             self.xcb.xcb_depth_visuals_length.argtypes = [POINTER(XcbDepth)]
@@ -957,7 +972,12 @@ def load(self) -> None:
             initialize_xcb_void_func(self.xcb, "xcb_no_operation_checked", [POINTER(XcbConnection)])
 
             # Ordered as <xcb/randr.h>
-            self.randr = cdll.LoadLibrary(find_library("xcb-randr"))
+
+            libxcb_randr_so = ctypes.util.find_library("xcb-randr")
+            if libxcb_randr_so is None:
+                msg = "Library libxcb-randr.so not found"
+                raise ScreenShotError(msg)
+            self.randr = cdll.LoadLibrary(libxcb_randr_so)
             self.randr_id = XcbExtension.in_dll(self.randr, "xcb_randr_id")
             initialize_xcb_typed_func(
                 self.randr,
@@ -997,7 +1017,12 @@ def load(self) -> None:
             self.randr.xcb_randr_get_screen_resources_current_crtcs_length.restype = c_int
 
             # Ordered as <xcb/render.h>
-            self.render = cdll.LoadLibrary(find_library("xcb-render"))
+
+            libxcb_render_so = ctypes.util.find_library("xcb-render")
+            if libxcb_render_so is None:
+                msg = "Library libxcb-render.so not found"
+                raise ScreenShotError(msg)
+            self.render = cdll.LoadLibrary(libxcb_render_so)
             self.render_id = XcbExtension.in_dll(self.render, "xcb_render_id")
 
             self.render.xcb_render_pictdepth_visuals.argtypes = [POINTER(XcbRenderPictdepth)]
@@ -1035,7 +1060,11 @@ def load(self) -> None:
 
             # Ordered as <xcb/xfixes.h>
 
-            self.xfixes = cdll.LoadLibrary(find_library("xcb-xfixes"))
+            libxcb_xfixes_so = ctypes.util.find_library("xcb-xfixes")
+            if libxcb_xfixes_so is None:
+                msg = "Library libxcb-xfixes.so not found"
+                raise ScreenShotError(msg)
+            self.xfixes = cdll.LoadLibrary(libxcb_xfixes_so)
             self.xfixes_id = XcbExtension.in_dll(self.xfixes, "xcb_xfixes_id")
 
             initialize_xcb_typed_func(

src/tests/conftest.py

@@ -4,7 +4,6 @@
 
 import os
 from collections.abc import Callable, Generator
-from functools import partial
 from hashlib import sha256
 from pathlib import Path
 from platform import system
@@ -14,6 +13,7 @@
 
 from mss import mss
 from mss.base import MSSBase
+from mss.linux import xcb, xlib
 
 
 @pytest.fixture(autouse=True)
@@ -43,6 +43,23 @@ def _before_tests() -> None:
     purge_files()
 
 
+@pytest.fixture(autouse=True)
+def no_xlib_errors(request: pytest.FixtureRequest) -> None:
+    system() == "Linux" and ("backend" not in request.fixturenames or request.getfixturevalue("backend") == "xlib")
+    assert not xlib._ERROR
+
+
+@pytest.fixture(autouse=True)
+def reset_xcb_libraries(request: pytest.FixtureRequest) -> Generator[None]:
+    # We need to test this before we yield, since the backend isn't available afterwards.
+    xcb_should_reset = system() == "Linux" and (
+        "backend" not in request.fixturenames or request.getfixturevalue("backend") == "xcb"
+    )
+    yield None
+    if xcb_should_reset:
+        xcb.LIB.reset()
+
+
 @pytest.fixture(scope="session")
 def raw() -> bytes:
     file = Path(__file__).parent / "res" / "monitor-1024x768.raw.zip"
@@ -60,4 +77,6 @@ def backend(request: pytest.FixtureRequest) -> str:
 
 @pytest.fixture
 def mss_impl(backend: str) -> Callable[..., MSSBase]:
-    return partial(mss, display=os.getenv("DISPLAY"), backend=backend)
+    # We can't just use partial here, since it will read $DISPLAY at the wrong time.  This can cause problems,
+    # depending on just how the fixtures get run.
+    return lambda *args, **kwargs: mss(*args, display=os.getenv("DISPLAY"), backend=backend, **kwargs)

src/tests/test_gnu_linux.py

@@ -2,20 +2,26 @@
 Source: https://github.com/BoboTiG/python-mss.
 """
 
+from __future__ import annotations
+
+import ctypes.util
 import platform
-from collections.abc import Generator
 from ctypes import CFUNCTYPE, POINTER, _Pointer, c_int
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from unittest.mock import Mock, NonCallableMock, patch
 
 import pytest
 
 import mss
 import mss.linux
+import mss.linux.xcb
 import mss.linux.xlib
 from mss.base import MSSBase
 from mss.exception import ScreenShotError
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
 pyvirtualdisplay = pytest.importorskip("pyvirtualdisplay")
 
 PYPY = platform.python_implementation() == "PyPy"
@@ -33,6 +39,26 @@ def spy_and_patch(monkeypatch: pytest.MonkeyPatch, obj: Any, name: str) -> Mock:
     return spy
 
 
+@pytest.fixture(autouse=True)
+def without_libraries(monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest) -> Generator[None]:
+    marker = request.node.get_closest_marker("without_libraries")
+    if marker is None:
+        yield None
+        return
+    skip_find = frozenset(marker.args)
+    old_find_library = ctypes.util.find_library
+
+    def new_find_library(name: str, *args: list, **kwargs: dict[str, Any]) -> str | None:
+        if name in skip_find:
+            return None
+        return old_find_library(name, *args, **kwargs)
+
+    # We use a context here so other fixtures or the test itself can use .undo.
+    with monkeypatch.context() as mp:
+        mp.setattr(ctypes.util, "find_library", new_find_library)
+        yield None
+
+
 @pytest.fixture
 def display() -> Generator:
     with pyvirtualdisplay.Display(size=(WIDTH, HEIGHT), color_depth=DEPTH) as vdisplay:
@@ -84,15 +110,18 @@ def test_arg_display(display: str, backend: str, monkeypatch: pytest.MonkeyPatch
         pass
 
     # No `DISPLAY` in envars
-    monkeypatch.delenv("DISPLAY")
-    with pytest.raises(ScreenShotError), mss.mss(backend=backend):
-        pass
+    # The monkeypatch implementation of delenv seems to interact badly with some other uses of setenv, so we use a
+    # monkeypatch context to isolate it a bit.
+    with monkeypatch.context() as mp:
+        mp.delenv("DISPLAY")
+        with pytest.raises(ScreenShotError), mss.mss(backend=backend):
+            pass
 
 
 def test_xerror_without_details() -> None:
     # Opening an invalid display with the Xlib backend will create an XError instance, but since there was no
     # XErrorEvent, then the details won't be filled in.  Generate one.
-    with pytest.raises(ScreenShotError) as excinfo, mss.mss(display=":INVALID", backend="xlib"):
+    with pytest.raises(ScreenShotError) as excinfo, mss.mss(display=":INVALID"):
         pass
 
     exc = excinfo.value
@@ -102,15 +131,17 @@ def test_xerror_without_details() -> None:
     str(exc)
 
 
+@pytest.mark.without_libraries("xcb")
 @patch("mss.linux.xlib._X11", new=None)
-def test_no_xlib_library() -> None:
-    with pytest.raises(ScreenShotError), mss.mss(backend="xlib"):
+def test_no_xlib_library(backend: str) -> None:
+    with pytest.raises(ScreenShotError), mss.mss(backend=backend):
         pass
 
 
+@pytest.mark.without_libraries("xcb-randr")
 @patch("mss.linux.xlib._XRANDR", new=None)
-def test_no_xrandr_extension() -> None:
-    with pytest.raises(ScreenShotError), mss.mss(backend="xlib"):
+def test_no_xrandr_extension(backend: str) -> None:
+    with pytest.raises(ScreenShotError), mss.mss(backend=backend):
         pass
 
 
@@ -132,9 +163,6 @@ def test_unsupported_depth(backend: str) -> None:
 def test_region_out_of_monitor_bounds(display: str, backend: str) -> None:
     monitor = {"left": -30, "top": 0, "width": WIDTH, "height": HEIGHT}
 
-    if backend == "xlib":
-        assert not mss.linux.xlib._ERROR
-
     with mss.mss(display=display, backend=backend, with_cursor=True) as sct:
         # At one point, I had accidentally been reporting the resource ID as a CData object instead of the contained
         # int.  This is to make sure I don't repeat that mistake.  That said, change this error regex if needed to keep
@@ -164,9 +192,6 @@ def test_region_out_of_monitor_bounds(display: str, backend: str) -> None:
         if backend == "xlib":
             assert not mss.linux.xlib._ERROR
 
-    if backend == "xlib":
-        assert not mss.linux.xlib._ERROR
-
 
 def test__is_extension_enabled_unknown_name(display: str) -> None:
     with mss.mss(display=display, backend="xlib") as sct: