napari-plugin-manager 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

napari_plugin_manager/_tests/conftest.py

@@ -10,17 +10,17 @@ from napari_plugin_manager.qt_package_installer import CondaInstallerTool
 @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)
+        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)
+    if 'enabledialog' not in request.keywords:
+        monkeypatch.setattr(QDialog, 'exec_', raise_on_call)
 
 
 if TYPE_CHECKING:

napari_plugin_manager/_tests/test_installer_process.py

@@ -19,6 +19,7 @@ from napari_plugin_manager.qt_package_installer import (
     NapariCondaInstallerTool,
     NapariInstallerQueue,
     NapariPipInstallerTool,
+    NapariUvInstallerTool,
 )
 
 if TYPE_CHECKING:
@@ -34,7 +35,7 @@ def _assert_exit_code_not_zero(
     if error is not None:
         errors.append("- 'error' should have been None!")
     if errors:
-        raise AssertionError("\n".join(errors))
+        raise AssertionError('\n'.join(errors))
     return self._on_process_done_original(exit_code, exit_status, error)
 
 
@@ -45,13 +46,13 @@ def _assert_error_used(self, exit_code=None, exit_status=None, error=None):
     if exit_code is not None:
         errors.append("- 'exit_code' should not have been populated!")
     if errors:
-        raise AssertionError("\n".join(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())}"
+        return f'this-tool-does-not-exist-{hash(time.time())}'
 
     def arguments(self):
         return ()
@@ -60,32 +61,52 @@ class _NonExistingTool(AbstractInstallerTool):
         return QProcessEnvironment.systemEnvironment()
 
 
+@pytest.fixture
+def patch_tool_executable(request):
+    mp = request.getfixturevalue('monkeypatch')
+    venv = request.getfixturevalue('tmp_virtualenv')
+    tool = request.getfixturevalue('tool')
+    mp.setattr(
+        tool,
+        'executable'
+        if tool == NapariPipInstallerTool
+        else '_python_executable',
+        lambda *a: venv.creator.exe,
+    )
+
+
+@pytest.mark.parametrize(
+    'tool', [NapariPipInstallerTool, NapariUvInstallerTool]
+)
 def test_pip_installer_tasks(
-    qtbot, tmp_virtualenv: 'Session', monkeypatch, caplog
+    qtbot,
+    tool,
+    tmp_virtualenv: 'Session',
+    monkeypatch,
+    caplog,
+    patch_tool_executable,
 ):
     caplog.set_level(logging.DEBUG, logger=bqpi.__name__)
-    installer = NapariInstallerQueue()
     monkeypatch.setattr(
-        NapariPipInstallerTool,
-        "executable",
-        lambda *a: tmp_virtualenv.creator.exe,
+        NapariInstallerQueue, 'PYPI_INSTALLER_TOOL_CLASS', tool
     )
+    installer = NapariInstallerQueue()
     monkeypatch.setattr(
-        NapariPipInstallerTool,
-        "origins",
-        ("https://pypi.org/simple",),
+        tool,
+        'origins',
+        ('https://pypi.org/simple',),
     )
-    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+    with qtbot.waitSignal(installer.allFinished, timeout=30_000):
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['pip-install-test'],
         )
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['typing-extensions'],
         )
         job_id = installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['requests'],
         )
         assert isinstance(job_id, int)
@@ -104,74 +125,82 @@ def test_pip_installer_tasks(
 
     assert pkgs >= 2, 'package was not installed'
 
-    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+    with qtbot.waitSignal(installer.allFinished, timeout=30_000):
         job_id = installer.uninstall(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             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 (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:
+    with qtbot.waitSignal(
+        installer.processFinished, timeout=30_000
+    ) as blocker:
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['pydantic'],
         )
     process_finished_data = blocker.args[0]
     assert process_finished_data['action'] == InstallerActions.INSTALL
-    assert process_finished_data['pkgs'] == ["pydantic"]
+    assert process_finished_data['pkgs'] == ('pydantic',)
 
     # Test upgrade
-    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+    with qtbot.waitSignal(installer.allFinished, timeout=30_000):
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['requests==2.30.0'],
         )
         installer.upgrade(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['requests'],
         )
 
 
-def test_pip_installer_invalid_action(tmp_virtualenv: 'Session', monkeypatch):
-    installer = NapariInstallerQueue()
+@pytest.mark.parametrize(
+    'tool', [NapariPipInstallerTool, NapariUvInstallerTool]
+)
+def test_pip_installer_invalid_action(
+    tool, tmp_virtualenv: 'Session', monkeypatch, patch_tool_executable
+):
     monkeypatch.setattr(
-        NapariPipInstallerTool,
-        "executable",
-        lambda *a: tmp_virtualenv.creator.exe,
+        NapariInstallerQueue, 'PYPI_INSTALLER_TOOL_CLASS', tool
     )
+    installer = NapariInstallerQueue()
     invalid_action = 'Invalid Action'
+    item = installer._build_queue_item(
+        tool=InstallerTools.PYPI,
+        action=invalid_action,
+        pkgs=['pip-install-test'],
+        prefix=None,
+        origins=(),
+        process=installer._create_process(),
+    )
     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 = NapariInstallerQueue()
+@pytest.mark.parametrize(
+    'tool', [NapariPipInstallerTool, NapariUvInstallerTool]
+)
+def test_installer_failures(
+    tool, qtbot, tmp_virtualenv: 'Session', monkeypatch, patch_tool_executable
+):
     monkeypatch.setattr(
-        NapariPipInstallerTool,
-        "executable",
-        lambda *a: tmp_virtualenv.creator.exe,
+        NapariInstallerQueue, 'PYPI_INSTALLER_TOOL_CLASS', tool
     )
+    installer = NapariInstallerQueue()
 
     # CHECK 1) Errors should trigger finished and allFinished too
-    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+    with qtbot.waitSignal(installer.allFinished, timeout=10_000):
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
         )
 
@@ -181,51 +210,57 @@ def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
     # CHECK 2) Non-existing packages should return non-zero
     monkeypatch.setattr(
         installer,
-        "_on_process_done",
+        '_on_process_done',
         MethodType(_assert_exit_code_not_zero, installer),
     )
-    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+    with qtbot.waitSignal(installer.allFinished, timeout=10_000):
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             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",
+        '_on_process_done',
         MethodType(_assert_error_used, installer),
     )
-    monkeypatch.setattr(installer, "_get_tool", lambda *a: _NonExistingTool)
-    with qtbot.waitSignal(installer.allFinished, timeout=10000):
+    monkeypatch.setattr(installer, '_get_tool', lambda *a: _NonExistingTool)
+    with qtbot.waitSignal(installer.allFinished, timeout=10_000):
         installer.install(
             tool=_NonExistingTool,
             pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
         )
 
 
-def test_cancel_incorrect_job_id(qtbot, tmp_virtualenv: 'Session'):
+@pytest.mark.parametrize(
+    'tool', [NapariPipInstallerTool, NapariUvInstallerTool]
+)
+def test_cancel_incorrect_job_id(tool, qtbot, monkeypatch):
+    monkeypatch.setattr(
+        NapariInstallerQueue, 'PYPI_INSTALLER_TOOL_CLASS', tool
+    )
     installer = NapariInstallerQueue()
-    with qtbot.waitSignal(installer.allFinished, timeout=20000):
+    with qtbot.waitSignal(installer.allFinished, timeout=30_000):
         job_id = installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['requests'],
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=f'No job with id {job_id + 1}.'):
             installer.cancel(job_id + 1)
 
 
 @pytest.mark.skipif(
-    not NapariCondaInstallerTool.available(), reason="Conda is not available."
+    not NapariCondaInstallerTool.available(), reason='Conda is not available.'
 )
 def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
-    if sys.platform == "darwin":
+    if sys.platform == 'darwin':
         # check  handled for `PYTHONEXECUTABLE` env definition on macOS
-        monkeypatch.setenv("PYTHONEXECUTABLE", sys.executable)
+        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"
+    conda_meta = tmp_conda_env / 'conda-meta'
+    glob_pat = 'typing-extensions-*.json'
+    glob_pat_2 = 'packaging-*.json'
     installer = NapariInstallerQueue()
 
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
@@ -257,7 +292,7 @@ def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
         )
         installer.install(
             tool=InstallerTools.CONDA,
-            pkgs=['pyzenhub'],
+            pkgs=['packaging'],
             prefix=tmp_conda_env,
         )
         assert installer.currentJobs() == 2
@@ -276,7 +311,7 @@ def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
         )
         job_id_2 = installer.install(
             tool=InstallerTools.CONDA,
-            pkgs=['pyzenhub'],
+            pkgs=['packaging'],
             prefix=tmp_conda_env,
         )
         assert installer.currentJobs() == 2
@@ -294,7 +329,7 @@ def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
         )
         job_id_2 = installer.install(
             tool=InstallerTools.CONDA,
-            pkgs=['pyzenhub'],
+            pkgs=['packaging'],
             prefix=tmp_conda_env,
         )
         assert installer.currentJobs() == 2
@@ -304,22 +339,24 @@ def test_conda_installer(qtbot, caplog, monkeypatch, tmp_conda_env: Path):
     assert not installer.hasJobs()
 
 
-def test_installer_error(qtbot, tmp_virtualenv: 'Session', monkeypatch):
-    installer = NapariInstallerQueue()
+@pytest.mark.parametrize(
+    'tool', [NapariPipInstallerTool, NapariUvInstallerTool]
+)
+def test_installer_error(qtbot, tool, monkeypatch):
     monkeypatch.setattr(
-        NapariPipInstallerTool,
-        "executable",
-        lambda *a: 'not-a-real-executable',
+        NapariInstallerQueue, 'PYPI_INSTALLER_TOOL_CLASS', tool
     )
+    installer = NapariInstallerQueue()
+    monkeypatch.setattr(tool, 'executable', lambda *a: 'not-a-real-executable')
     with qtbot.waitSignal(installer.allFinished, timeout=600_000):
         installer.install(
-            tool=InstallerTools.PIP,
+            tool=InstallerTools.PYPI,
             pkgs=['some-package-that-does-not-exist'],
         )
 
 
 @pytest.mark.skipif(
-    not NapariCondaInstallerTool.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 = NapariInstallerQueue()
@@ -332,37 +369,41 @@ def test_conda_installer_wait_for_finished(qtbot, tmp_conda_env: Path):
         )
         installer.install(
             tool=InstallerTools.CONDA,
-            pkgs=['pyzenhub'],
+            pkgs=['packaging'],
             prefix=tmp_conda_env,
         )
-        installer.waitForFinished(20000)
+        installer.waitForFinished(30_000)
 
 
 def test_constraints_are_in_sync():
     conda_constraints = sorted(NapariCondaInstallerTool.constraints())
-    pip_constraints = sorted(NapariPipInstallerTool.constraints())
+    pypi_constraints = sorted(NapariPipInstallerTool.constraints())
 
-    assert len(conda_constraints) == len(pip_constraints)
+    assert len(conda_constraints) == len(pypi_constraints)
 
-    name_re = re.compile(r"([a-z0-9_\-]+).*")
-    for conda_constraint, pip_constraint in zip(
-        conda_constraints, pip_constraints, strict=False
+    name_re = re.compile(r'([a-z0-9_\-]+).*')
+    for conda_constraint, pypi_constraint in zip(
+        conda_constraints, pypi_constraints, strict=False
     ):
         conda_name = name_re.match(conda_constraint).group(1)
-        pip_name = name_re.match(pip_constraint).group(1)
-        assert conda_name == pip_name
+        pypi_name = name_re.match(pypi_constraint).group(1)
+        assert conda_name == pypi_name
 
 
 def test_executables():
     assert NapariCondaInstallerTool.executable()
     assert NapariPipInstallerTool.executable()
+    assert NapariUvInstallerTool.executable()
 
 
 def test_available():
     assert str(NapariCondaInstallerTool.available())
     assert NapariPipInstallerTool.available()
+    assert NapariUvInstallerTool.available()
 
 
 def test_unrecognized_tool():
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ValueError, match='InstallerTool shrug not recognized!'
+    ):
         NapariInstallerQueue().install(tool='shrug', pkgs=[])

napari_plugin_manager/_tests/test_npe2api.py

@@ -18,16 +18,17 @@ def test_user_agent():
 @flaky(max_runs=4, min_passes=2)
 def test_plugin_summaries():
     keys = [
-        "name",
-        "version",
-        "display_name",
-        "summary",
-        "author",
-        "license",
-        "home_page",
-        "pypi_versions",
-        "conda_versions",
-        "project_url",
+        'name',
+        'normalized_name',
+        'version',
+        'display_name',
+        'summary',
+        'author',
+        'license',
+        'home_page',
+        'pypi_versions',
+        'conda_versions',
+        'project_url',
     ]
     try:
         data = plugin_summaries()
@@ -42,7 +43,7 @@ def test_plugin_summaries():
 
 
 def test_conda_map():
-    pkgs = ["napari-svg"]
+    pkgs = ['napari-svg']
     try:
         data = conda_map()
         for pkg in pkgs: