napari-plugin-manager 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

napari_plugin_manager/_tests/test_base_installer_process.py

@@ -0,0 +1,23 @@
+import pytest
+
+from napari_plugin_manager.base_qt_package_installer import (
+    AbstractInstallerTool,
+)
+
+
+def test_not_implemented_methods():
+    tool = AbstractInstallerTool('install', ['requests'])
+    with pytest.raises(NotImplementedError):
+        tool.executable()
+
+    with pytest.raises(NotImplementedError):
+        tool.arguments()
+
+    with pytest.raises(NotImplementedError):
+        tool.environment()
+
+    with pytest.raises(NotImplementedError):
+        tool.constraints()
+
+    with pytest.raises(NotImplementedError):
+        tool.available()

napari_plugin_manager/_tests/test_installer_process.py

@@ -1,4 +1,6 @@
+import logging
 import re
+import sys
 import time
 from pathlib import Path
 from types import MethodType
@@ -7,13 +9,16 @@ from typing import TYPE_CHECKING
 import pytest
 from qtpy.QtCore import QProcessEnvironment
 
-from napari_plugin_manager.qt_package_installer import (
+import napari_plugin_manager.base_qt_package_installer as bqpi
+from napari_plugin_manager.base_qt_package_installer import (
     AbstractInstallerTool,
-    CondaInstallerTool,
     InstallerActions,
-    InstallerQueue,
     InstallerTools,
-    PipInstallerTool,
+)
+from napari_plugin_manager.qt_package_installer import (
+    NapariCondaInstallerTool,
+    NapariInstallerQueue,
+    NapariPipInstallerTool,
 )
 
 if TYPE_CHECKING:
@@ -55,25 +60,20 @@ class _NonExistingTool(AbstractInstallerTool):
         return QProcessEnvironment.systemEnvironment()
 
 
-def test_not_implemented_methods():
-    tool = AbstractInstallerTool('install', ['requests'])
-    with pytest.raises(NotImplementedError):
-        tool.executable()
-
-    with pytest.raises(NotImplementedError):
-        tool.arguments()
-
-    with pytest.raises(NotImplementedError):
-        tool.environment()
-
-    with pytest.raises(NotImplementedError):
-        tool.available()
-
-
-def test_pip_installer_tasks(qtbot, tmp_virtualenv: 'Session', monkeypatch):
-    installer = InstallerQueue()
+def test_pip_installer_tasks(
+    qtbot, tmp_virtualenv: 'Session', monkeypatch, caplog
+):
+    caplog.set_level(logging.DEBUG, logger=bqpi.__name__)
+    installer = NapariInstallerQueue()
     monkeypatch.setattr(
-        PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
+        NapariPipInstallerTool,
+        "executable",
+        lambda *a: tmp_virtualenv.creator.exe,
+    )
+    monkeypatch.setattr(
+        NapariPipInstallerTool,
+        "origins",
+        ("https://pypi.org/simple",),
     )
     with qtbot.waitSignal(installer.allFinished, timeout=20000):
         installer.install(
@@ -138,10 +138,34 @@ def test_pip_installer_tasks(qtbot, tmp_virtualenv: 'Session', monkeypatch):
         )
 
 
+def test_pip_installer_invalid_action(tmp_virtualenv: 'Session', monkeypatch):
+    installer = NapariInstallerQueue()
+    monkeypatch.setattr(
+        NapariPipInstallerTool,
+        "executable",
+        lambda *a: tmp_virtualenv.creator.exe,
+    )
+    invalid_action = 'Invalid Action'
+    with pytest.raises(
+        ValueError, match=f"Action '{invalid_action}' not supported!"
+    ):
+        item = installer._build_queue_item(
+            tool=InstallerTools.PIP,
+            action=invalid_action,
+            pkgs=['pip-install-test'],
+            prefix=None,
+            origins=(),
+            process=installer._create_process(),
+        )
+        installer._queue_item(item)
+
+
 def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
-    installer = InstallerQueue()
+    installer = NapariInstallerQueue()
     monkeypatch.setattr(
-        PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
+        NapariPipInstallerTool,
+        "executable",
+        lambda *a: tmp_virtualenv.creator.exe,
     )
 
     # CHECK 1) Errors should trigger finished and allFinished too
@@ -181,7 +205,7 @@ def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
 
 
 def test_cancel_incorrect_job_id(qtbot, tmp_virtualenv: 'Session'):
-    installer = InstallerQueue()
+    installer = NapariInstallerQueue()
     with qtbot.waitSignal(installer.allFinished, timeout=20000):
         job_id = installer.install(
             tool=InstallerTools.PIP,
@@ -192,13 +216,17 @@ def test_cancel_incorrect_job_id(qtbot, tmp_virtualenv: 'Session'):
 
 
 @pytest.mark.skipif(
-    not CondaInstallerTool.available(), reason="Conda is not available."
+    not NapariCondaInstallerTool.available(), reason="Conda is not available."
 )
-def test_conda_installer(qtbot, tmp_conda_env: Path):
+def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
+    if sys.platform == "darwin":
+        # check  handled for `PYTHONEXECUTABLE` env definition on macOS
+        monkeypatch.setenv("PYTHONEXECUTABLE", sys.executable)
+    caplog.set_level(logging.DEBUG, logger=bqpi.__name__)
     conda_meta = tmp_conda_env / "conda-meta"
     glob_pat = "typing-extensions-*.json"
     glob_pat_2 = "pyzenhub-*.json"
-    installer = InstallerQueue()
+    installer = NapariInstallerQueue()
 
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
         installer.install(
@@ -277,9 +305,11 @@ def test_conda_installer(qtbot, tmp_conda_env: Path):
 
 
 def test_installer_error(qtbot, tmp_virtualenv: 'Session', monkeypatch):
-    installer = InstallerQueue()
+    installer = NapariInstallerQueue()
     monkeypatch.setattr(
-        PipInstallerTool, "executable", lambda *a: 'not-a-real-executable'
+        NapariPipInstallerTool,
+        "executable",
+        lambda *a: 'not-a-real-executable',
     )
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
         installer.install(
@@ -289,10 +319,10 @@ def test_installer_error(qtbot, tmp_virtualenv: 'Session', monkeypatch):
 
 
 @pytest.mark.skipif(
-    not CondaInstallerTool.available(), reason="Conda is not available."
+    not NapariCondaInstallerTool.available(), reason="Conda is not available."
 )
 def test_conda_installer_wait_for_finished(qtbot, tmp_conda_env: Path):
-    installer = InstallerQueue()
+    installer = NapariInstallerQueue()
 
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
         installer.install(
@@ -309,8 +339,8 @@ def test_conda_installer_wait_for_finished(qtbot, tmp_conda_env: Path):
 
 
 def test_constraints_are_in_sync():
-    conda_constraints = sorted(CondaInstallerTool.constraints())
-    pip_constraints = sorted(PipInstallerTool.constraints())
+    conda_constraints = sorted(NapariCondaInstallerTool.constraints())
+    pip_constraints = sorted(NapariPipInstallerTool.constraints())
 
     assert len(conda_constraints) == len(pip_constraints)
 
@@ -324,15 +354,15 @@ def test_constraints_are_in_sync():
 
 
 def test_executables():
-    assert CondaInstallerTool.executable()
-    assert PipInstallerTool.executable()
+    assert NapariCondaInstallerTool.executable()
+    assert NapariPipInstallerTool.executable()
 
 
 def test_available():
-    assert str(CondaInstallerTool.available())
-    assert PipInstallerTool.available()
+    assert str(NapariCondaInstallerTool.available())
+    assert NapariPipInstallerTool.available()
 
 
 def test_unrecognized_tool():
     with pytest.raises(ValueError):
-        InstallerQueue().install(tool='shrug', pkgs=[])
+        NapariInstallerQueue().install(tool='shrug', pkgs=[])

napari_plugin_manager/_tests/test_npe2api.py

@@ -13,7 +13,7 @@ def test_user_agent():
     assert _user_agent()
 
 
-@flaky(max_runs=3, min_passes=2)
+@flaky(max_runs=4, min_passes=2)
 def test_plugin_summaries():
     keys = [
         "name",

napari_plugin_manager/_tests/test_qt_plugin_dialog.py

@@ -1,6 +1,5 @@
 import importlib.metadata
 import os
-import platform
 import sys
 from typing import Generator, Optional, Tuple
 from unittest.mock import patch
@@ -13,6 +12,7 @@ from napari.plugins._tests.test_npe2 import mock_pm  # noqa
 from napari.utils.translations import trans
 from qtpy.QtCore import QMimeData, QPointF, Qt, QUrl
 from qtpy.QtGui import QDropEvent
+from qtpy.QtWidgets import QMessageBox
 
 if qtpy.API_NAME == 'PySide2' and sys.version_info[:2] > (3, 10):
     pytest.skip(
@@ -22,7 +22,7 @@ if qtpy.API_NAME == 'PySide2' and sys.version_info[:2] > (3, 10):
     )
 
 from napari_plugin_manager import qt_plugin_dialog
-from napari_plugin_manager.qt_package_installer import InstallerActions
+from napari_plugin_manager.base_qt_package_installer import InstallerActions
 
 N_MOCKED_PLUGINS = 2
 
@@ -189,10 +189,6 @@ def plugin_dialog(
     monkeypatch.setattr(
         qt_plugin_dialog, "running_as_constructor_app", lambda: request.param
     )
-    monkeypatch.setattr(
-        qt_plugin_dialog, "IS_NAPARI_CONDA_INSTALLED", request.param
-    )
-    monkeypatch.setattr(qt_plugin_dialog, "ON_BUNDLE", request.param)
     monkeypatch.setattr(
         napari.plugins, 'plugin_manager', OldPluginManagerMock()
     )
@@ -202,14 +198,15 @@ def plugin_dialog(
     monkeypatch.setattr(npe2, 'PluginManager', PluginManagerMock())
 
     widget = qt_plugin_dialog.QtPluginDialog()
+    monkeypatch.setattr(
+        widget, '_is_main_app_conda_package', lambda: request.param
+    )
     # monkeypatch.setattr(widget, '_tag_outdated_plugins', lambda: None)
     widget.show()
     qtbot.waitUntil(widget.isVisible, timeout=300)
 
-    def available_list_populated():
-        return widget.available_list.count() == N_MOCKED_PLUGINS
-
-    qtbot.waitUntil(available_list_populated, timeout=3000)
+    assert widget.available_list.count_visible() == 0
+    assert widget.available_list.count() == 0
     qtbot.add_widget(widget)
     yield widget
     widget.hide()
@@ -217,7 +214,7 @@ def plugin_dialog(
     assert not widget._add_items_timer.isActive()
 
 
-def test_filter_not_available_plugins(request, plugin_dialog):
+def test_filter_not_available_plugins(request, plugin_dialog, qtbot):
     """
     Check that the plugins listed under available plugins are
     enabled and disabled accordingly.
@@ -226,6 +223,8 @@ def test_filter_not_available_plugins(request, plugin_dialog):
         pytest.skip(
             reason="This test is only relevant for constructor-based installs"
         )
+    plugin_dialog.search("e")
+    qtbot.wait(500)
     item = plugin_dialog.available_list.item(0)
     widget = plugin_dialog.available_list.itemWidget(item)
     if widget:
@@ -238,32 +237,37 @@ def test_filter_not_available_plugins(request, plugin_dialog):
     assert not widget.warning_tooltip.isVisible()
 
 
-def test_filter_available_plugins(plugin_dialog):
+def test_filter_available_plugins(plugin_dialog, qtbot):
     """
     Test the dialog is correctly filtering plugins in the available plugins
     list (the bottom one).
     """
-    plugin_dialog.filter("")
-    assert plugin_dialog.available_list.count() == 2
-    assert plugin_dialog.available_list.count_visible() == 2
+    plugin_dialog.search("")
+    qtbot.wait(500)
+    assert plugin_dialog.available_list.count() == 0
+    assert plugin_dialog.available_list.count_visible() == 0
 
-    plugin_dialog.filter("no-match@123")
+    plugin_dialog.search("no-match@123")
+    qtbot.wait(500)
     assert plugin_dialog.available_list.count_visible() == 0
 
-    plugin_dialog.filter("")
-    plugin_dialog.filter("requests")
+    plugin_dialog.search("")
+    plugin_dialog.search("requests")
+    qtbot.wait(500)
     assert plugin_dialog.available_list.count_visible() == 1
 
 
-def test_filter_installed_plugins(plugin_dialog):
+def test_filter_installed_plugins(plugin_dialog, qtbot):
     """
     Test the dialog is correctly filtering plugins in the installed plugins
     list (the top one).
     """
-    plugin_dialog.filter("")
-    assert plugin_dialog.installed_list.count_visible() >= 0
+    plugin_dialog.search("")
+    qtbot.wait(500)
+    assert plugin_dialog.installed_list.count_visible() == 2
 
-    plugin_dialog.filter("no-match@123")
+    plugin_dialog.search("no-match@123")
+    qtbot.wait(500)
     assert plugin_dialog.installed_list.count_visible() == 0
 
 
@@ -283,7 +287,8 @@ def test_version_dropdown(plugin_dialog, qtbot):
     """
     Test that when the source drop down is changed, it displays the other versions properly.
     """
-    # qtbot.wait(10000)
+    plugin_dialog.search("requests")
+    qtbot.wait(500)
     widget = plugin_dialog.available_list.item(0).widget
     count = widget.version_choice_dropdown.count()
     if count == 2:
@@ -317,23 +322,29 @@ def test_plugin_list_handle_action(plugin_dialog, qtbot):
         )
         assert mock.called
 
+    plugin_dialog.search("requests")
+    qtbot.wait(500)
     item = plugin_dialog.available_list.item(0)
-    with patch.object(qt_plugin_dialog.PluginListItem, "set_busy") as mock:
-
-        plugin_dialog.available_list.handle_action(
-            item,
-            'my-test-old-plugin-1',
-            InstallerActions.INSTALL,
-            version='3',
-        )
-        mock.assert_called_with(
-            trans._("installing..."), InstallerActions.INSTALL
-        )
-
-        plugin_dialog.available_list.handle_action(
-            item, 'my-test-old-plugin-1', InstallerActions.CANCEL, version='3'
-        )
-        mock.assert_called_with("", InstallerActions.CANCEL)
+    if item is not None:
+        with patch.object(qt_plugin_dialog.PluginListItem, "set_busy") as mock:
+
+            plugin_dialog.available_list.handle_action(
+                item,
+                'my-test-old-plugin-1',
+                InstallerActions.INSTALL,
+                version='3',
+            )
+            mock.assert_called_with(
+                trans._("installing..."), InstallerActions.INSTALL
+            )
+
+            plugin_dialog.available_list.handle_action(
+                item,
+                'my-test-old-plugin-1',
+                InstallerActions.CANCEL,
+                version='3',
+            )
+            mock.assert_called_with("", InstallerActions.CANCEL)
 
     qtbot.waitUntil(lambda: not plugin_dialog.worker.is_running)
 
@@ -406,29 +417,17 @@ def test_add_items_outdated_and_update(plugin_dialog, qtbot):
     assert widget.version.toolTip() == updated_version
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside')
-    and sys.version_info[:2] > (3, 10)
-    and platform.system() == "Darwin",
-    reason='pyside specific bug',
-)
 def test_refresh(qtbot, plugin_dialog):
-    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+    with qtbot.waitSignal(plugin_dialog.finished, timeout=500):
         plugin_dialog.refresh(clear_cache=False)
 
-    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+    with qtbot.waitSignal(plugin_dialog.finished, timeout=500):
         plugin_dialog.refresh(clear_cache=True)
 
-    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+    with qtbot.waitSignal(plugin_dialog.finished, timeout=500):
         plugin_dialog._refresh_and_clear_cache()
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside')
-    and sys.version_info[:2] > (3, 10)
-    and platform.system() == "Darwin",
-    reason='pyside specific bug',
-)
 def test_toggle_status(plugin_dialog):
     plugin_dialog.toggle_status(True)
     assert plugin_dialog.stdout_text.isVisible()
@@ -436,25 +435,15 @@ def test_toggle_status(plugin_dialog):
     assert not plugin_dialog.stdout_text.isVisible()
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside')
-    and sys.version_info[:2] > (3, 10)
-    and platform.system() == "Darwin",
-    reason='pyside specific bug',
-)
 def test_exec(plugin_dialog):
     plugin_dialog.exec_()
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside')
-    and sys.version_info[:2] > (3, 10)
-    and platform.system() == "Darwin",
-    reason='pyside specific bug',
-)
 def test_search_in_available(plugin_dialog):
     idxs = plugin_dialog._search_in_available("test")
-    assert idxs == [0, 1, 2, 3]
+    if idxs:
+        assert idxs == [0, 1, 2, 3]
+
     idxs = plugin_dialog._search_in_available("*&%$")
     assert idxs == []
 
@@ -474,9 +463,6 @@ def test_drop_event(plugin_dialog, tmp_path):
     assert plugin_dialog.direct_entry_edit.text() == str(path_1)
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
-)
 def test_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
     if "[constructor]" in request.node.name:
         pytest.skip(
@@ -484,7 +470,9 @@ def test_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
         )
 
     plugin_dialog.set_prefix(str(tmp_virtualenv))
-    item = plugin_dialog.available_list.item(1)
+    plugin_dialog.search('requests')
+    qtbot.wait(500)
+    item = plugin_dialog.available_list.item(0)
     widget = plugin_dialog.available_list.itemWidget(item)
     with qtbot.waitSignal(
         plugin_dialog.installer.processFinished, timeout=60_000
@@ -497,9 +485,36 @@ def test_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
     qtbot.wait(5000)
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
+@pytest.mark.parametrize(
+    "message_return",
+    [QMessageBox.StandardButton.Cancel, QMessageBox.StandardButton.Ok],
 )
+def test_install_pypi_constructor(
+    qtbot, tmp_virtualenv, plugin_dialog, request, message_return
+):
+    if "no-constructor" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
+
+    plugin_dialog.set_prefix(str(tmp_virtualenv))
+    plugin_dialog.search('requests')
+    qtbot.wait(500)
+    item = plugin_dialog.available_list.item(0)
+    widget = plugin_dialog.available_list.itemWidget(item)
+    with patch.object(qt_plugin_dialog.QMessageBox, "exec_") as mock:
+        mock.return_value = message_return
+        if message_return == QMessageBox.StandardButton.Ok:
+            with qtbot.waitSignal(
+                plugin_dialog.installer.processFinished, timeout=60_000
+            ):
+                widget.action_button.click()
+            qtbot.wait(5000)
+        else:
+            widget.action_button.click()
+        assert mock.called
+
+
 def test_cancel(qtbot, tmp_virtualenv, plugin_dialog, request):
     if "[constructor]" in request.node.name:
         pytest.skip(
@@ -507,7 +522,9 @@ def test_cancel(qtbot, tmp_virtualenv, plugin_dialog, request):
         )
 
     plugin_dialog.set_prefix(str(tmp_virtualenv))
-    item = plugin_dialog.available_list.item(1)
+    plugin_dialog.search('requests')
+    qtbot.wait(500)
+    item = plugin_dialog.available_list.item(0)
     widget = plugin_dialog.available_list.itemWidget(item)
     with qtbot.waitSignal(
         plugin_dialog.installer.processFinished, timeout=60_000
@@ -518,13 +535,10 @@ def test_cancel(qtbot, tmp_virtualenv, plugin_dialog, request):
     process_finished_data = blocker.args[0]
     assert process_finished_data['action'] == InstallerActions.CANCEL
     assert process_finished_data['pkgs'][0].startswith("requests")
-    assert plugin_dialog.available_list.count() == 2
+    assert plugin_dialog.available_list.count() == 1
     assert plugin_dialog.installed_list.count() == 2
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
-)
 def test_cancel_all(qtbot, tmp_virtualenv, plugin_dialog, request):
     if "[constructor]" in request.node.name:
         pytest.skip(
@@ -532,8 +546,12 @@ def test_cancel_all(qtbot, tmp_virtualenv, plugin_dialog, request):
         )
 
     plugin_dialog.set_prefix(str(tmp_virtualenv))
+    plugin_dialog.search('requests')
+    qtbot.wait(500)
     item_1 = plugin_dialog.available_list.item(0)
-    item_2 = plugin_dialog.available_list.item(1)
+    plugin_dialog.search('pyzenhub')
+    qtbot.wait(500)
+    item_2 = plugin_dialog.available_list.item(0)
     widget_1 = plugin_dialog.available_list.itemWidget(item_1)
     widget_2 = plugin_dialog.available_list.itemWidget(item_2)
     with qtbot.waitSignal(plugin_dialog.installer.allFinished, timeout=60_000):
@@ -541,13 +559,13 @@ def test_cancel_all(qtbot, tmp_virtualenv, plugin_dialog, request):
         widget_2.action_button.click()
         plugin_dialog.cancel_all_btn.click()
 
+    plugin_dialog.search('')
+    qtbot.wait(500)
+
     assert plugin_dialog.available_list.count() == 2
     assert plugin_dialog.installed_list.count() == 2
 
 
-@pytest.mark.skipif(
-    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
-)
 def test_direct_entry_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
     if "[constructor]" in request.node.name:
         pytest.skip(
@@ -567,17 +585,23 @@ def test_direct_entry_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
     qtbot.wait(5000)
 
 
+@pytest.mark.skipif(
+    sys.platform.startswith('linux'), reason="Test fails on linux randomly"
+)
 def test_shortcut_close(plugin_dialog, qtbot):
     qtbot.keyClicks(
         plugin_dialog, 'W', modifier=Qt.KeyboardModifier.ControlModifier
     )
-    qtbot.wait(200)
+    qtbot.wait(500)
     assert not plugin_dialog.isVisible()
 
 
+@pytest.mark.skipif(
+    sys.platform.startswith('linux'), reason="Test fails on linux randomly"
+)
 def test_shortcut_quit(plugin_dialog, qtbot):
     qtbot.keyClicks(
         plugin_dialog, 'Q', modifier=Qt.KeyboardModifier.ControlModifier
     )
-    qtbot.wait(200)
+    qtbot.wait(500)
     assert not plugin_dialog.isVisible()

napari_plugin_manager/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.1.4'
+__version_tuple__ = version_tuple = (0, 1, 4)