Select Qt backend if already imported

Co-authored-by: Bruno Oliveira <[email protected]>

Author: eyllanesc

CHANGELOG.rst

@@ -4,6 +4,12 @@ UNRELEASED
 - Use ``pytest.hookimpl`` to configure hooks, avoiding a deprecation warning in
   the upcoming pytest 7.2.0.
 
+- Now ``pytest-qt`` will check if any of the Qt libraries is already imported by the time the plugin loads,
+  and use it if that is the case (`#412`_). Thanks `@eyllanesc`_ for the PR.
+
+.. _#412: https://github.com/pytest-dev/pytest-qt/pull/412
+.. _@eyllanesc: https://github.com/eyllanesc
+
 4.1.0 (2022-06-23)
 ------------------
 

README.rst

@@ -76,9 +76,11 @@ Requirements
 
 Since version 4.1.0, ``pytest-qt`` requires Python 3.7+.
 
-Works with either PySide6_, PySide2_, PyQt6_ or PyQt5_, picking whichever
-is available on the system, giving preference to the first one installed in
-this order:
+Works with either PySide6_, PySide2_, PyQt6_ or PyQt5_.
+
+If any of the above libraries is already imported by the time the tests execute, that library will be used.
+
+If not, pytest-qt will try to import and use the Qt APIs, in this order:
 
 - ``PySide6``
 - ``PySide2``

src/pytestqt/qt_compat.py

@@ -1,6 +1,6 @@
 """
 Provide a common way to import Qt classes used by pytest-qt in a unique manner,
-abstracting API differences between PyQt5 and PySide2/6.
+abstracting API differences between PyQt5/6 and PySide2/6.
 
 .. note:: This module is not part of pytest-qt public API, hence its interface
 may change between releases and users should not rely on it.
@@ -9,20 +9,31 @@
 """
 
 
-from collections import namedtuple
+from collections import namedtuple, OrderedDict
 import os
+import sys
 
 import pytest
 
 
 VersionTuple = namedtuple("VersionTuple", "qt_api, qt_api_version, runtime, compiled")
 
+QT_APIS = OrderedDict()
+QT_APIS["pyside6"] = "PySide6"
+QT_APIS["pyside2"] = "PySide2"
+QT_APIS["pyqt6"] = "PyQt6"
+QT_APIS["pyqt5"] = "PyQt5"
+
 
 def _import(name):
     """Think call so we can mock it during testing"""
     return __import__(name)
 
 
+def _is_library_loaded(name):
+    return name in sys.modules
+
+
 class _QtApi:
     """
     Interface to the underlying Qt API currently configured for pytest-qt.
@@ -36,12 +47,7 @@ def __init__(self):
 
     def _get_qt_api_from_env(self):
         api = os.environ.get("PYTEST_QT_API")
-        supported_apis = [
-            "pyside6",
-            "pyside2",
-            "pyqt6",
-            "pyqt5",
-        ]
+        supported_apis = QT_APIS.keys()
 
         if api is not None:
             api = api.lower()
@@ -50,6 +56,12 @@ def _get_qt_api_from_env(self):
                 raise pytest.UsageError(msg)
         return api
 
+    def _get_already_loaded_backend(self):
+        for api, backend in QT_APIS.items():
+            if _is_library_loaded(backend):
+                return api
+        return None
+
     def _guess_qt_api(self):  # pragma: no cover
         def _can_import(name):
             try:
@@ -61,18 +73,18 @@ def _can_import(name):
 
         # Note, not importing only the root namespace because when uninstalling from conda,
         # the namespace can still be there.
-        if _can_import("PySide6.QtCore"):
-            return "pyside6"
-        elif _can_import("PySide2.QtCore"):
-            return "pyside2"
-        elif _can_import("PyQt6.QtCore"):
-            return "pyqt6"
-        elif _can_import("PyQt5.QtCore"):
-            return "pyqt5"
+        for api, backend in QT_APIS.items():
+            if _can_import(f"{backend}.QtCore"):
+                return api
         return None
 
     def set_qt_api(self, api):
-        self.pytest_qt_api = self._get_qt_api_from_env() or api or self._guess_qt_api()
+        self.pytest_qt_api = (
+            self._get_qt_api_from_env()
+            or api
+            or self._get_already_loaded_backend()
+            or self._guess_qt_api()
+        )
 
         self.is_pyside = self.pytest_qt_api in ["pyside2", "pyside6"]
         self.is_pyqt = self.pytest_qt_api in ["pyqt5", "pyqt6"]
@@ -88,13 +100,7 @@ def set_qt_api(self, api):
             )
             raise pytest.UsageError(msg)
 
-        _root_modules = {
-            "pyside6": "PySide6",
-            "pyside2": "PySide2",
-            "pyqt6": "PyQt6",
-            "pyqt5": "PyQt5",
-        }
-        _root_module = _root_modules[self.pytest_qt_api]
+        _root_module = QT_APIS[self.pytest_qt_api]
 
         def _import_module(module_name):
             m = __import__(_root_module, globals(), locals(), [module_name], 0)

tests/test_basics.py

@@ -563,8 +563,12 @@ def test_importerror(monkeypatch):
     def _fake_import(name, *args):
         raise ModuleNotFoundError(f"Failed to import {name}")
 
+    def _fake_is_library_loaded(name, *args):
+        return False
+
     monkeypatch.delenv("PYTEST_QT_API", raising=False)
     monkeypatch.setattr(qt_compat, "_import", _fake_import)
+    monkeypatch.setattr(qt_compat, "_is_library_loaded", _fake_is_library_loaded)
 
     expected = (
         "pytest-qt requires either PySide2, PySide6, PyQt5 or PyQt6 installed.\n"
@@ -578,6 +582,73 @@ def _fake_import(name, *args):
         qt_api.set_qt_api(api=None)
 
 
+@pytest.mark.parametrize(
+    "option_api, backend",
+    [
+        ("pyqt5", "PyQt5"),
+        ("pyqt6", "PyQt6"),
+        ("pyside2", "PySide2"),
+        ("pyside6", "PySide6"),
+    ],
+)
+def test_already_loaded_backend(monkeypatch, option_api, backend):
+
+    import builtins
+
+    class Mock:
+        pass
+
+    qtcore = Mock()
+    for method_name in (
+        "qInstallMessageHandler",
+        "qDebug",
+        "qWarning",
+        "qCritical",
+        "qFatal",
+    ):
+        setattr(qtcore, method_name, lambda *_: None)
+
+    if backend in ("PyQt5", "PyQt6"):
+        pyqt_version = 0x050B00 if backend == "PyQt5" else 0x060000
+        qtcore.PYQT_VERSION = pyqt_version + 1
+        qtcore.pyqtSignal = object()
+        qtcore.pyqtSlot = object()
+        qtcore.pyqtProperty = object()
+    else:
+        qtcore.Signal = object()
+        qtcore.Slot = object()
+        qtcore.Property = object()
+
+    qtwidgets = Mock()
+    qapplication = Mock()
+    qapplication.instance = lambda *_: None
+    qtwidgets.QApplication = qapplication
+
+    qbackend = Mock()
+    qbackend.QtCore = qtcore
+    qbackend.QtGui = object()
+    qbackend.QtTest = object()
+    qbackend.QtWidgets = qtwidgets
+
+    import_orig = builtins.__import__
+
+    def _fake_import(name, *args, **kwargs):
+        if name == backend:
+            return qbackend
+        return import_orig(name, *args, **kwargs)
+
+    def _fake_is_library_loaded(name, *args):
+        return name == backend
+
+    monkeypatch.delenv("PYTEST_QT_API", raising=False)
+    monkeypatch.setattr(qt_compat, "_is_library_loaded", _fake_is_library_loaded)
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+
+    qt_api.set_qt_api(api=None)
+
+    assert qt_api.pytest_qt_api == option_api
+
+
 def test_before_close_func(testdir):
     """
     Test the `before_close_func` argument of qtbot.addWidget.