napari-plugin-manager 0.1.0a0__py3-none-any.whl

napari_plugin_manager/_tests/conftest.py

@@ -0,0 +1,18 @@
+import pytest
+from qtpy.QtWidgets import QDialog, QInputDialog, QMessageBox
+
+
+@pytest.fixture(autouse=True)
+def _block_message_box(monkeypatch, request):
+    def raise_on_call(*_, **__):
+        raise RuntimeError("exec_ call")  # pragma: no cover
+
+    monkeypatch.setattr(QMessageBox, "exec_", raise_on_call)
+    monkeypatch.setattr(QMessageBox, "critical", raise_on_call)
+    monkeypatch.setattr(QMessageBox, "information", raise_on_call)
+    monkeypatch.setattr(QMessageBox, "question", raise_on_call)
+    monkeypatch.setattr(QMessageBox, "warning", raise_on_call)
+    monkeypatch.setattr(QInputDialog, "getText", raise_on_call)
+    # QDialogs can be allowed via a marker; only raise if not decorated
+    if "enabledialog" not in request.keywords:
+        monkeypatch.setattr(QDialog, "exec_", raise_on_call)

napari_plugin_manager/_tests/test_installer_process.py

@@ -0,0 +1,226 @@
+import re
+import sys
+import time
+from pathlib import Path
+from types import MethodType
+from typing import TYPE_CHECKING
+
+import pytest
+from qtpy.QtCore import QProcessEnvironment
+
+from napari_plugin_manager.qt_package_installer import (
+    AbstractInstallerTool,
+    CondaInstallerTool,
+    InstallerQueue,
+    InstallerTools,
+    PipInstallerTool,
+)
+
+if TYPE_CHECKING:
+    from virtualenv.run import Session
+
+
+@pytest.fixture
+def tmp_virtualenv(tmp_path) -> 'Session':
+    virtualenv = pytest.importorskip('virtualenv')
+
+    cmd = [str(tmp_path), '--no-setuptools', '--no-wheel', '--activators', '']
+    return virtualenv.cli_run(cmd)
+
+
+@pytest.fixture
+def tmp_conda_env(tmp_path):
+    import subprocess
+
+    try:
+        subprocess.check_output(
+            [
+                CondaInstallerTool.executable(),
+                'create',
+                '-yq',
+                '-p',
+                str(tmp_path),
+                '--override-channels',
+                '-c',
+                'conda-forge',
+                f'python={sys.version_info.major}.{sys.version_info.minor}',
+            ],
+            stderr=subprocess.STDOUT,
+            text=True,
+            timeout=300,
+        )
+    except subprocess.CalledProcessError as exc:
+        print(exc.output)
+        raise
+
+    return tmp_path
+
+
+def test_pip_installer_tasks(qtbot, tmp_virtualenv: 'Session', monkeypatch):
+    installer = InstallerQueue()
+    monkeypatch.setattr(
+        PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
+    )
+    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['pip-install-test'],
+        )
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['typing-extensions'],
+        )
+        job_id = installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['requests'],
+        )
+        assert isinstance(job_id, int)
+        installer.cancel(job_id)
+
+    assert not installer.hasJobs()
+
+    pkgs = 0
+    for pth in tmp_virtualenv.creator.libs:
+        if (pth / 'pip_install_test').exists():
+            pkgs += 1
+        if (pth / 'typing_extensions.py').exists():
+            pkgs += 1
+        if (pth / 'requests').exists():
+            raise AssertionError('requests got installed')
+
+    assert pkgs >= 2, 'package was not installed'
+
+    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+        job_id = installer.uninstall(
+            tool=InstallerTools.PIP,
+            pkgs=['pip-install-test'],
+        )
+
+    for pth in tmp_virtualenv.creator.libs:
+        assert not (
+            pth / 'pip_install_test'
+        ).exists(), 'pip_install_test still installed'
+
+    assert not installer.hasJobs()
+
+
+def _assert_exit_code_not_zero(
+    self, exit_code=None, exit_status=None, error=None
+):
+    errors = []
+    if exit_code == 0:
+        errors.append("- 'exit_code' should have been non-zero!")
+    if error is not None:
+        errors.append("- 'error' should have been None!")
+    if errors:
+        raise AssertionError("\n".join(errors))
+    return self._on_process_done_original(exit_code, exit_status, error)
+
+
+class _NonExistingTool(AbstractInstallerTool):
+    def executable(self):
+        return f"this-tool-does-not-exist-{hash(time.time())}"
+
+    def arguments(self):
+        return ()
+
+    def environment(self, env=None):
+        return QProcessEnvironment.systemEnvironment()
+
+
+def _assert_error_used(self, exit_code=None, exit_status=None, error=None):
+    errors = []
+    if error is None:
+        errors.append("- 'error' should have been populated!")
+    if exit_code is not None:
+        errors.append("- 'exit_code' should not have been populated!")
+    if errors:
+        raise AssertionError("\n".join(errors))
+    return self._on_process_done_original(exit_code, exit_status, error)
+
+
+def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
+    installer = InstallerQueue()
+    monkeypatch.setattr(
+        PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
+    )
+
+    # CHECK 1) Errors should trigger finished and allFinished too
+    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
+        )
+
+    # Keep a reference before we monkey patch stuff
+    installer._on_process_done_original = installer._on_process_done
+
+    # CHECK 2) Non-existing packages should return non-zero
+    monkeypatch.setattr(
+        installer,
+        "_on_process_done",
+        MethodType(_assert_exit_code_not_zero, installer),
+    )
+    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
+        )
+
+    # CHECK 3) Non-existing tools should fail to start
+    monkeypatch.setattr(
+        installer,
+        "_on_process_done",
+        MethodType(_assert_error_used, installer),
+    )
+    monkeypatch.setattr(installer, "_get_tool", lambda *a: _NonExistingTool)
+    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+        installer.install(
+            tool=_NonExistingTool,
+            pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
+        )
+
+
+@pytest.mark.skipif(
+    not CondaInstallerTool.available(), reason="Conda is not available."
+)
+def test_conda_installer(qtbot, tmp_conda_env: Path):
+    installer = InstallerQueue()
+
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['typing-extensions'],
+            prefix=tmp_conda_env,
+        )
+
+    conda_meta = tmp_conda_env / "conda-meta"
+    glob_pat = "typing-extensions-*.json"
+
+    assert not installer.hasJobs()
+    assert list(conda_meta.glob(glob_pat))
+
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        installer.uninstall(
+            tool=InstallerTools.CONDA,
+            pkgs=['typing-extensions'],
+            prefix=tmp_conda_env,
+        )
+
+    assert not installer.hasJobs()
+    assert not list(conda_meta.glob(glob_pat))
+
+
+def test_constraints_are_in_sync():
+    conda_constraints = sorted(CondaInstallerTool.constraints())
+    pip_constraints = sorted(PipInstallerTool.constraints())
+
+    assert len(conda_constraints) == len(pip_constraints)
+
+    name_re = re.compile(r"([a-z0-9_\-]+).*")
+    for conda_constraint, pip_constraint in zip(
+        conda_constraints, pip_constraints
+    ):
+        conda_name = name_re.match(conda_constraint).group(1)
+        pip_name = name_re.match(pip_constraint).group(1)
+        assert conda_name == pip_name

napari_plugin_manager/_tests/test_qt_plugin_dialog.py

@@ -0,0 +1,374 @@
+import importlib.metadata
+import sys
+from typing import Generator, Optional, Tuple
+from unittest.mock import patch
+
+import napari.plugins
+import npe2
+import pytest
+import qtpy
+from napari.plugins._tests.test_npe2 import mock_pm  # noqa
+from napari.utils.translations import trans
+
+from napari_plugin_manager import qt_plugin_dialog
+from napari_plugin_manager.qt_package_installer import InstallerActions
+
+if qtpy.API_NAME == 'PySide2' and sys.version_info[:2] == (3, 11):
+    pytest.skip(
+        "Known PySide2 x Python 3.11 incompatibility: "
+        "TypeError: 'PySide2.QtCore.Qt.Alignment' object cannot be interpreted as an integer",
+        allow_module_level=True,
+    )
+
+N_MOCKED_PLUGINS = 2
+
+
+def _iter_napari_pypi_plugin_info(
+    conda_forge: bool = True,
+) -> Generator[
+    Tuple[Optional[npe2.PackageMetadata], bool], None, None
+]:  # pragma: no cover  (this function is used in thread and codecov has a problem with the collection of coverage in such cases)
+    """Mock the pypi method to collect available plugins.
+
+    This will mock napari.plugins.pypi.iter_napari_plugin_info` for pypi.
+
+    It will return two fake plugins that will populate the available plugins
+    list (the bottom one). The first plugin will not be available on
+    conda-forge so will be greyed out ("test-name-0"). The second plugin will
+    be available on conda-forge so will be enabled ("test-name-1").
+    """
+    # This mock `base_data`` will be the same for both fake plugins.
+    base_data = {
+        "metadata_version": "1.0",
+        "version": "0.1.0",
+        "summary": "some test package",
+        "home_page": "http://napari.org",
+        "author": "test author",
+        "license": "UNKNOWN",
+    }
+    for i in range(N_MOCKED_PLUGINS):
+        yield npe2.PackageMetadata(name=f"test-name-{i}", **base_data), bool(
+            i
+        ), {
+            "home_page": 'www.mywebsite.com',
+            "pypi_versions": ['3'],
+            "conda_versions": ['4.5'],
+        }
+
+
+class PluginsMock:
+    def __init__(self):
+        self.plugins = {
+            'test-name-0': True,
+            'test-name-1': True,
+            'my-plugin': True,
+        }
+
+
+class OldPluginsMock:
+    def __init__(self):
+        self.plugins = [('test-1', False, 'test-1')]
+        self.enabled = [True]
+
+
+@pytest.fixture
+def old_plugins(qtbot):
+    return OldPluginsMock()
+
+
+@pytest.fixture
+def plugins(qtbot):
+    return PluginsMock()
+
+
+class WarnPopupMock:
+    def __init__(self, text):
+        self._is_visible = False
+
+    def exec_(self):
+        self._is_visible = True
+
+    def move(self, pos):
+        return False
+
+    def isVisible(self):
+        return self._is_visible
+
+    def close(self):
+        self._is_visible = False
+
+
+@pytest.fixture(params=[True, False], ids=["constructor", "no-constructor"])
+def plugin_dialog(
+    request,
+    qtbot,
+    monkeypatch,
+    mock_pm,  # noqa
+    plugins,
+    old_plugins,
+):
+    """Fixture that provides a plugin dialog for a normal napari install."""
+
+    class PluginManagerMock:
+        def instance(self):
+            return PluginManagerInstanceMock(plugins)
+
+    class PluginManagerInstanceMock:
+        def __init__(self, plugins):
+            self.plugins = plugins.plugins
+
+        def __iter__(self):
+            yield from self.plugins
+
+        def iter_manifests(self):
+            yield from [mock_pm.get_manifest('my-plugin')]
+
+        def is_disabled(self, name):
+            return False
+
+        def discover(self):
+            return ['plugin']
+
+        def enable(self, plugin):
+            self.plugins[plugin] = True
+            return
+
+        def disable(self, plugin):
+            self.plugins[plugin] = False
+            return
+
+    def mock_metadata(name):
+        meta = {
+            'version': '0.1.0',
+            'summary': '',
+            'Home-page': '',
+            'author': '',
+            'license': '',
+        }
+        return meta
+
+    class OldPluginManagerMock:
+        def __init__(self):
+            self.plugins = old_plugins.plugins
+            self.enabled = old_plugins.enabled
+
+        def iter_available(self):
+            return self.plugins
+
+        def discover(self):
+            return None
+
+        def is_blocked(self, plugin):
+            return self.plugins[0][1]
+
+        def set_blocked(self, plugin, blocked):
+            self.enabled[0] = not blocked
+            return
+
+    monkeypatch.setattr(
+        qt_plugin_dialog,
+        "iter_napari_plugin_info",
+        _iter_napari_pypi_plugin_info,
+    )
+    monkeypatch.setattr(qt_plugin_dialog, 'WarnPopup', WarnPopupMock)
+
+    # This is patching `napari.utils.misc.running_as_constructor_app` function
+    # to mock a normal napari install.
+    monkeypatch.setattr(
+        qt_plugin_dialog, "running_as_constructor_app", lambda: request.param
+    )
+
+    monkeypatch.setattr(
+        napari.plugins, 'plugin_manager', OldPluginManagerMock()
+    )
+
+    monkeypatch.setattr(importlib.metadata, 'metadata', mock_metadata)
+
+    monkeypatch.setattr(npe2, 'PluginManager', PluginManagerMock())
+
+    widget = qt_plugin_dialog.QtPluginDialog()
+    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)
+    qtbot.add_widget(widget)
+    yield widget
+    widget.hide()
+    widget._add_items_timer.stop()
+    assert not widget._add_items_timer.isActive()
+
+
+def test_filter_not_available_plugins(plugin_dialog):
+    """
+    Check that the plugins listed under available plugins are
+    enabled and disabled accordingly.
+
+    The first plugin ("test-name-0") is not available on conda-forge and
+    should be disabled, and show a tooltip warning.
+
+    The second plugin ("test-name-1") is available on conda-forge and
+    should be enabled without the tooltip warning.
+    """
+    item = plugin_dialog.available_list.item(0)
+    widget = plugin_dialog.available_list.itemWidget(item)
+    if widget:
+        assert not widget.action_button.isEnabled()
+        assert widget.warning_tooltip.isVisible()
+
+    item = plugin_dialog.available_list.item(1)
+    widget = plugin_dialog.available_list.itemWidget(item)
+    assert widget.action_button.isEnabled()
+    assert not widget.warning_tooltip.isVisible()
+
+
+def test_filter_available_plugins(plugin_dialog):
+    """
+    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.filter("no-match@123")
+    assert plugin_dialog.available_list._count_visible() == 0
+
+    plugin_dialog.filter("")
+    plugin_dialog.filter("test-name-0")
+    assert plugin_dialog.available_list._count_visible() == 1
+
+
+def test_filter_installed_plugins(plugin_dialog):
+    """
+    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.filter("no-match@123")
+    assert plugin_dialog.installed_list._count_visible() == 0
+
+
+def test_visible_widgets(request, plugin_dialog):
+    """
+    Test that the direct entry button and textbox are visible
+    """
+    if "no-constructor" not in request.node.name:
+        # the plugin_dialog fixture has this id
+        # skip for 'constructor' variant
+        pytest.skip()
+    assert plugin_dialog.direct_entry_edit.isVisible()
+    assert plugin_dialog.direct_entry_btn.isVisible()
+
+
+def test_version_dropdown(qtbot, plugin_dialog):
+    """
+    Test that when the source drop down is changed, it displays the other versions properly.
+    """
+    widget = plugin_dialog.available_list.item(1).widget
+    assert widget.version_choice_dropdown.currentText() == "3"
+    # switch from PyPI source to conda one.
+    widget.source_choice_dropdown.setCurrentIndex(1)
+    assert widget.version_choice_dropdown.currentText() == "4.5"
+
+
+def test_plugin_list_count_items(plugin_dialog):
+    assert plugin_dialog.installed_list._count_visible() == 2
+
+
+def test_plugin_list_handle_action(plugin_dialog, qtbot):
+    item = plugin_dialog.installed_list.item(0)
+    with patch.object(qt_plugin_dialog.PluginListItem, "set_busy") as mock:
+        plugin_dialog.installed_list.handle_action(
+            item,
+            'test-name-1',
+            InstallerActions.UPGRADE,
+        )
+        mock.assert_called_with(
+            trans._("updating..."), InstallerActions.UPGRADE
+        )
+
+    with patch.object(qt_plugin_dialog.WarnPopup, "exec_") as mock:
+        plugin_dialog.installed_list.handle_action(
+            item,
+            'test-name-1',
+            InstallerActions.UNINSTALL,
+        )
+        assert mock.called
+
+    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,
+            'test-name-1',
+            InstallerActions.INSTALL,
+            version='3',
+        )
+        mock.assert_called_with(
+            trans._("installing..."), InstallerActions.INSTALL
+        )
+
+        plugin_dialog.available_list.handle_action(
+            item, 'test-name-1', InstallerActions.CANCEL, version='3'
+        )
+        mock.assert_called_with(
+            trans._("cancelling..."), InstallerActions.CANCEL
+        )
+
+    # Wait for refresh timer, state and worker to be done
+    qtbot.waitUntil(
+        lambda: not plugin_dialog._add_items_timer.isActive()
+        and plugin_dialog.refresh_state == qt_plugin_dialog.RefreshState.DONE
+    )
+    qtbot.waitUntil(lambda: not plugin_dialog.worker.is_running)
+
+
+def test_on_enabled_checkbox(plugin_dialog, qtbot, plugins, old_plugins):
+    # checks npe2 lines
+    item = plugin_dialog.installed_list.item(0)
+    widget = plugin_dialog.installed_list.itemWidget(item)
+
+    assert plugins.plugins['my-plugin'] is True
+    with qtbot.waitSignal(widget.enabled_checkbox.stateChanged, timeout=500):
+        widget.enabled_checkbox.setChecked(False)
+    assert plugins.plugins['my-plugin'] is False
+
+    # checks npe1 lines
+    item = plugin_dialog.installed_list.item(1)
+    widget = plugin_dialog.installed_list.itemWidget(item)
+
+    assert old_plugins.enabled[0] is True
+    with qtbot.waitSignal(widget.enabled_checkbox.stateChanged, timeout=500):
+        widget.enabled_checkbox.setChecked(False)
+    assert old_plugins.enabled[0] is False
+
+
+def test_add_items_outdated(plugin_dialog):
+    """Test that a plugin is tagged as outdated (a newer version is available), the update button becomes visible."""
+
+    # The plugin is being added to the available plugins list.  When the dialog is being built
+    # this one will be listed as available, and it will be found as already installed.
+    # Then, it will check if the installed version is a lower version than the one available.
+    # In this case, my-plugin is installed with version 0.1.0, so the one we are trying to install
+    # is newer, so the update button should pop up.
+    new_plugin = (
+        npe2.PackageMetadata(name="my-plugin", version="0.4.0"),
+        True,
+        {
+            "home_page": 'www.mywebsite.com',
+            "pypi_versions": ['0.4.0'],
+            "conda_versions": ['0.4.0'],
+        },
+    )
+
+    plugin_dialog._plugin_data = [new_plugin]
+
+    plugin_dialog._add_items()
+    item = plugin_dialog.installed_list.item(0)
+    widget = plugin_dialog.installed_list.itemWidget(item)
+
+    assert widget.update_btn.isVisible()

napari_plugin_manager/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.1.0a0'
+__version_tuple__ = version_tuple = (0, 1, 0)