napari-plugin-manager 0.1.0a1__py3-none-any.whl → 0.1.1__py3-none-any.whl

napari_plugin_manager/_tests/conftest.py

@@ -1,6 +1,11 @@
+import sys
+from typing import TYPE_CHECKING
+
 import pytest
 from qtpy.QtWidgets import QDialog, QInputDialog, QMessageBox
 
+from napari_plugin_manager.qt_package_installer import CondaInstallerTool
+
 
 @pytest.fixture(autouse=True)
 def _block_message_box(monkeypatch, request):
@@ -16,3 +21,43 @@ def _block_message_box(monkeypatch, request):
     # 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)
+
+
+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

napari_plugin_manager/_tests/test_installer_process.py

@@ -1,5 +1,4 @@
 import re
-import sys
 import time
 from pathlib import Path
 from types import MethodType
@@ -11,6 +10,7 @@ from qtpy.QtCore import QProcessEnvironment
 from napari_plugin_manager.qt_package_installer import (
     AbstractInstallerTool,
     CondaInstallerTool,
+    InstallerActions,
     InstallerQueue,
     InstallerTools,
     PipInstallerTool,
@@ -20,40 +20,54 @@ if TYPE_CHECKING:
     from virtualenv.run import Session
 
 
-@pytest.fixture
-def tmp_virtualenv(tmp_path) -> 'Session':
-    virtualenv = pytest.importorskip('virtualenv')
+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)
+
+
+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)
 
-    cmd = [str(tmp_path), '--no-setuptools', '--no-wheel', '--activators', '']
-    return virtualenv.cli_run(cmd)
 
+class _NonExistingTool(AbstractInstallerTool):
+    def executable(self):
+        return f"this-tool-does-not-exist-{hash(time.time())}"
 
-@pytest.fixture
-def tmp_conda_env(tmp_path):
-    import subprocess
+    def arguments(self):
+        return ()
 
-    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
+    def environment(self, env=None):
+        return QProcessEnvironment.systemEnvironment()
 
-    return tmp_path
+
+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):
@@ -100,43 +114,28 @@ def test_pip_installer_tasks(qtbot, tmp_virtualenv: 'Session', monkeypatch):
         assert not (
             pth / 'pip_install_test'
         ).exists(), 'pip_install_test still installed'
-
     assert not installer.hasJobs()
 
+    # Test new signals
+    with qtbot.waitSignal(installer.processFinished, timeout=20000) as blocker:
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['pydantic'],
+        )
+    process_finished_data = blocker.args[0]
+    assert process_finished_data['action'] == InstallerActions.INSTALL
+    assert process_finished_data['pkgs'] == ["pydantic"]
 
-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)
+    # Test upgrade
+    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['requests==2.30.0'],
+        )
+        installer.upgrade(
+            tool=InstallerTools.PIP,
+            pkgs=['requests'],
+        )
 
 
 def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
@@ -181,10 +180,24 @@ def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
         )
 
 
+def test_cancel_incorrect_job_id(qtbot, tmp_virtualenv: 'Session'):
+    installer = InstallerQueue()
+    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+        job_id = installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['requests'],
+        )
+        with pytest.raises(ValueError):
+            installer.cancel(job_id + 1)
+
+
 @pytest.mark.skipif(
     not CondaInstallerTool.available(), reason="Conda is not available."
 )
 def test_conda_installer(qtbot, tmp_conda_env: Path):
+    conda_meta = tmp_conda_env / "conda-meta"
+    glob_pat = "typing-extensions-*.json"
+    glob_pat_2 = "pyzenhub-*.json"
     installer = InstallerQueue()
 
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
@@ -194,9 +207,6 @@ def test_conda_installer(qtbot, tmp_conda_env: Path):
             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))
 
@@ -210,6 +220,93 @@ def test_conda_installer(qtbot, tmp_conda_env: Path):
     assert not installer.hasJobs()
     assert not list(conda_meta.glob(glob_pat))
 
+    # Check canceling all works
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['typing-extensions'],
+            prefix=tmp_conda_env,
+        )
+        installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['pyzenhub'],
+            prefix=tmp_conda_env,
+        )
+        assert installer.currentJobs() == 2
+        installer.cancel_all()
+
+    assert not installer.hasJobs()
+    assert not list(conda_meta.glob(glob_pat))
+    assert not list(conda_meta.glob(glob_pat_2))
+
+    # Check canceling current job works (1st in queue)
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        job_id_1 = installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['typing-extensions'],
+            prefix=tmp_conda_env,
+        )
+        job_id_2 = installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['pyzenhub'],
+            prefix=tmp_conda_env,
+        )
+        assert installer.currentJobs() == 2
+        installer.cancel(job_id_1)
+        assert installer.currentJobs() == 1
+
+    assert not installer.hasJobs()
+
+    # Check canceling queued job works (somewhere besides 1st position in queue)
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        job_id_1 = installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['typing-extensions'],
+            prefix=tmp_conda_env,
+        )
+        job_id_2 = installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['pyzenhub'],
+            prefix=tmp_conda_env,
+        )
+        assert installer.currentJobs() == 2
+        installer.cancel(job_id_2)
+        assert installer.currentJobs() == 1
+
+    assert not installer.hasJobs()
+
+
+def test_installer_error(qtbot, tmp_virtualenv: 'Session', monkeypatch):
+    installer = InstallerQueue()
+    monkeypatch.setattr(
+        PipInstallerTool, "executable", lambda *a: 'not-a-real-executable'
+    )
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        installer.install(
+            tool=InstallerTools.PIP,
+            pkgs=['some-package-that-does-not-exist'],
+        )
+
+
+@pytest.mark.skipif(
+    not CondaInstallerTool.available(), reason="Conda is not available."
+)
+def test_conda_installer_wait_for_finished(qtbot, tmp_conda_env: Path):
+    installer = InstallerQueue()
+
+    with qtbot.waitSignal(installer.allFinished, timeout=600_000):
+        installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['requests'],
+            prefix=tmp_conda_env,
+        )
+        installer.install(
+            tool=InstallerTools.CONDA,
+            pkgs=['pyzenhub'],
+            prefix=tmp_conda_env,
+        )
+        installer.waitForFinished(20000)
+
 
 def test_constraints_are_in_sync():
     conda_constraints = sorted(CondaInstallerTool.constraints())
@@ -224,3 +321,18 @@ def test_constraints_are_in_sync():
         conda_name = name_re.match(conda_constraint).group(1)
         pip_name = name_re.match(pip_constraint).group(1)
         assert conda_name == pip_name
+
+
+def test_executables():
+    assert CondaInstallerTool.executable()
+    assert PipInstallerTool.executable()
+
+
+def test_available():
+    assert str(CondaInstallerTool.available())
+    assert PipInstallerTool.available()
+
+
+def test_unrecognized_tool():
+    with pytest.raises(ValueError):
+        InstallerQueue().install(tool='shrug', pkgs=[])

napari_plugin_manager/_tests/test_npe2api.py

@@ -0,0 +1,54 @@
+from flaky import flaky
+
+from napari_plugin_manager.npe2api import (
+    _user_agent,
+    cache_clear,
+    conda_map,
+    iter_napari_plugin_info,
+    plugin_summaries,
+)
+
+
+def test_user_agent():
+    assert _user_agent()
+
+
+@flaky(max_runs=3, min_passes=2)
+def test_plugin_summaries():
+    keys = [
+        "name",
+        "version",
+        "display_name",
+        "summary",
+        "author",
+        "license",
+        "home_page",
+        "pypi_versions",
+        "conda_versions",
+    ]
+    data = plugin_summaries()
+    test_data = dict(data[0])
+    for key in keys:
+        assert key in test_data
+        test_data.pop(key)
+
+    assert not test_data
+
+
+def test_conda_map():
+    pkgs = ["napari-svg"]
+    data = conda_map()
+    for pkg in pkgs:
+        assert pkg in data
+
+
+def test_iter_napari_plugin_info():
+    data = iter_napari_plugin_info()
+    for item in data:
+        assert item
+
+
+def test_clear_cache():
+    assert _user_agent.cache_info().hits >= 1
+    cache_clear()
+    assert _user_agent.cache_info().hits == 0