devnomads-cli 0.11.1__tar.gz → 0.11.2__tar.gz

{devnomads_cli-0.11.1 → devnomads_cli-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devnomads-cli
-Version: 0.11.1
+Version: 0.11.2
 Summary: Manage your DevNomads services from the command line
 Author-email: DevNomads <support@devnomads.nl>
 License: MIT
@@ -46,16 +46,20 @@ devnomads-cli`) work as well.
 
 ### Updates
 
-Update with:
+Upgrade with:
 
 ```sh
-uv tool upgrade devnomads-cli
+dncli upgrade
 ```
 
+It uses the tool you installed dncli with (uv, pipx, or pip in a
+virtualenv); where it can't, such as a system-wide pip install or on
+Windows, it prints the command to run instead. `dncli upgrade --dry-run`
+shows what it would do.
+
 dncli checks PyPI at most once a day and tells you when a new version
-is out, with the command to update the way you installed it. It only
-does so on an interactive terminal, never in pipes, scripts or CI; set
-`DN_NO_UPDATE_CHECK=1` to turn it off.
+is out. It only does so on an interactive terminal, never in pipes,
+scripts or CI; set `DN_NO_UPDATE_CHECK=1` to turn it off.
 
 dncli also warns when the DevNomads API reports a major version it was
 not built for, and tells you when the API no longer supports your

{devnomads_cli-0.11.1 → devnomads_cli-0.11.2}/README.md

@@ -30,16 +30,20 @@ devnomads-cli`) work as well.
 
 ### Updates
 
-Update with:
+Upgrade with:
 
 ```sh
-uv tool upgrade devnomads-cli
+dncli upgrade
 ```
 
+It uses the tool you installed dncli with (uv, pipx, or pip in a
+virtualenv); where it can't, such as a system-wide pip install or on
+Windows, it prints the command to run instead. `dncli upgrade --dry-run`
+shows what it would do.
+
 dncli checks PyPI at most once a day and tells you when a new version
-is out, with the command to update the way you installed it. It only
-does so on an interactive terminal, never in pipes, scripts or CI; set
-`DN_NO_UPDATE_CHECK=1` to turn it off.
+is out. It only does so on an interactive terminal, never in pipes,
+scripts or CI; set `DN_NO_UPDATE_CHECK=1` to turn it off.
 
 dncli also warns when the DevNomads API reports a major version it was
 not built for, and tells you when the API no longer supports your

{devnomads_cli-0.11.1 → devnomads_cli-0.11.2}/devnomads_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devnomads-cli
-Version: 0.11.1
+Version: 0.11.2
 Summary: Manage your DevNomads services from the command line
 Author-email: DevNomads <support@devnomads.nl>
 License: MIT
@@ -46,16 +46,20 @@ devnomads-cli`) work as well.
 
 ### Updates
 
-Update with:
+Upgrade with:
 
 ```sh
-uv tool upgrade devnomads-cli
+dncli upgrade
 ```
 
+It uses the tool you installed dncli with (uv, pipx, or pip in a
+virtualenv); where it can't, such as a system-wide pip install or on
+Windows, it prints the command to run instead. `dncli upgrade --dry-run`
+shows what it would do.
+
 dncli checks PyPI at most once a day and tells you when a new version
-is out, with the command to update the way you installed it. It only
-does so on an interactive terminal, never in pipes, scripts or CI; set
-`DN_NO_UPDATE_CHECK=1` to turn it off.
+is out. It only does so on an interactive terminal, never in pipes,
+scripts or CI; set `DN_NO_UPDATE_CHECK=1` to turn it off.
 
 dncli also warns when the DevNomads API reports a major version it was
 not built for, and tells you when the API no longer supports your

{devnomads_cli-0.11.1 → devnomads_cli-0.11.2}/dncli.py

@@ -31,6 +31,7 @@ import re
 import secrets
 import shutil
 import stat
+import subprocess  # nosec B404 - only for `dncli upgrade`
 import sys
 import threading
 import time
@@ -63,7 +64,7 @@ from rich.markup import escape
 from rich.table import Table
 from typer.core import TyperGroup
 
-__version__ = "0.11.1"
+__version__ = "0.11.2"
 
 # Distribution names, for reporting versions via `dncli version`.
 CLI_PACKAGE = "devnomads-cli"
@@ -112,17 +113,70 @@ def _version_tuple(text: str | None) -> tuple[int, int, int] | None:
     return major, minor, patch
 
 
+def install_method() -> str:
+    """How this copy of dncli was installed, from the marker files each
+    installer leaves in the environment it creates:
+
+    uv-tool (uv tool install), pipx, uvx (uv's throwaway environments),
+    venv (pip in a virtualenv), system (pip into a system or user Python)
+    or script (the single-file dncli.py)."""
+
+    prefix = Path(sys.prefix)
+    if _package_version(CLI_PACKAGE, "") == "":
+        return "script"
+    if (prefix / "uv-receipt.toml").is_file():
+        return "uv-tool"
+    if (prefix / "pipx_metadata.json").is_file():
+        return "pipx"
+    if any(part.startswith("archive-v") for part in prefix.parts):
+        return "uvx"
+    if sys.prefix != sys.base_prefix:
+        return "venv"
+    return "system"
+
+
+def upgrade_argv(method: str) -> list[str] | None:
+    """The command that upgrades dncli in place, or None when dncli cannot
+    or should not run it itself. On Windows the running dncli.exe cannot be
+    replaced, so the upgrade is left to the user there."""
+
+    if sys.platform == "win32":
+        return None
+    if method == "uv-tool" and (uv := shutil.which("uv")):
+        return [uv, "tool", "upgrade", CLI_PACKAGE]
+    if method == "pipx" and (pipx := shutil.which("pipx")):
+        return [pipx, "upgrade", CLI_PACKAGE]
+    if method == "venv":
+        from importlib.util import find_spec
+
+        if find_spec("pip") is not None:
+            return [sys.executable, "-m", "pip", "install", "-U", CLI_PACKAGE]
+        if uv := shutil.which("uv"):  # uv-made virtualenvs have no pip
+            return [uv, "pip", "install", "--python", sys.executable, "-U", CLI_PACKAGE]
+    return None
+
+
+def manual_upgrade(method: str) -> str:
+    """How to upgrade by hand, for messages and when dncli cannot do it."""
+
+    return {
+        "uv-tool": f"uv tool upgrade {CLI_PACKAGE}",
+        "pipx": f"pipx upgrade {CLI_PACKAGE}",
+        "uvx": f"uvx --from {CLI_PACKAGE}@latest dncli (uvx caches the version "
+        "it ran last)",
+        "venv": f"pip install -U {CLI_PACKAGE}",
+        "system": f"pip install -U {CLI_PACKAGE} (with --user or sudo, as you "
+        "installed it)",
+        "script": "download the latest dncli.py",
+    }[method]
+
+
 def upgrade_command() -> str:
-    """How to upgrade dncli, judged by how this copy was installed."""
+    """How to upgrade dncli, for notices: `dncli upgrade` when it can do the
+    job itself, otherwise the command to run by hand."""
 
-    prefix = Path(sys.prefix).as_posix().lower()
-    if "/uv/tools/" in prefix:
-        return f"uv tool upgrade {CLI_PACKAGE}"
-    if "/pipx/venvs/" in prefix:
-        return f"pipx upgrade {CLI_PACKAGE}"
-    if _package_version(CLI_PACKAGE, "") == "":  # the single-file script
-        return "download the latest dncli.py"
-    return f"pip install -U {CLI_PACKAGE}"
+    method = install_method()
+    return "dncli upgrade" if upgrade_argv(method) else manual_upgrade(method)
 
 
 # ---------------------------------------------------------------------------
@@ -1382,6 +1436,80 @@ def version_cmd(
     render(state_from(ctx, output, columns), _versions())
 
 
+@app.command("upgrade")
+def upgrade_cmd(
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run", help="Show how dncli would upgrade, without doing it."
+        ),
+    ] = False,
+) -> None:
+    """Upgrade dncli to the latest release.
+
+    Uses the tool dncli was installed with (uv, pipx or pip in a
+    virtualenv). Where dncli cannot do that itself, it prints the command
+    to run."""
+
+    method = install_method()
+    argv = upgrade_argv(method)
+    latest = latest_version()
+    latest_t, current_t = _version_tuple(latest), _version_tuple(__version__)
+    newer = latest_t is not None and latest_t > (current_t or (0, 0, 0))
+    status = (
+        f"dncli {__version__}; latest release {latest}"
+        if latest
+        else f"dncli {__version__}; could not reach PyPI for the latest release"
+    )
+    err_console.print(status)
+    if dry_run:
+        err_console.print(f"installed with: {method}")
+        command = " ".join(argv) if argv else manual_upgrade(method)
+        err_console.print(
+            f"would run: {command}" if argv else f"upgrade by hand: {command}"
+        )
+        return
+    if latest is not None and not newer:
+        err_console.print("already up to date")
+        return
+    if argv is None:
+        raise CliError(
+            f"dncli cannot upgrade this installation ({method}) itself; "
+            f"run: {manual_upgrade(method)}"
+        )
+    err_console.print(f"running: {' '.join(argv)}")
+    result = subprocess.run(argv, check=False)  # nosec B603 - fixed argv, no shell
+    if result.returncode != 0:
+        raise CliError(f"upgrade failed (exit code {result.returncode})")
+    installed = _installed_version()
+    if installed and installed != __version__:
+        err_console.print(f"dncli upgraded from {__version__} to {installed}")
+    else:
+        err_console.print("dncli is up to date")
+    state = _read_update_state()
+    state.update(latest=installed or latest or __version__, checked_at=time.time())
+    _write_update_state(state)
+
+
+def _installed_version() -> str | None:
+    """The dncli version now installed in this environment, read in a fresh
+    interpreter because this process still has the old one loaded."""
+
+    result = subprocess.run(  # nosec B603 - fixed argv, no shell
+        [
+            sys.executable,
+            "-c",
+            f"from importlib.metadata import version; print(version({CLI_PACKAGE!r}))",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip() or None
+
+
 # --- configure -------------------------------------------------------------
 
 
@@ -9127,9 +9255,8 @@ def _write_update_state(state: dict[str, Any]) -> None:
         pass
 
 
-def _fetch_latest_version() -> None:
-    """Ask PyPI for the latest release and remember it. Any failure is
-    ignored: the check must never get in the way of a command."""
+def latest_version() -> str | None:
+    """The latest dncli release on PyPI, or None when PyPI cannot be reached."""
 
     try:
         response = httpx.get(
@@ -9137,8 +9264,17 @@ def _fetch_latest_version() -> None:
             timeout=UPDATE_CHECK_TIMEOUT,
             headers={"User-Agent": user_agent()},
         )
-        latest = response.json()["info"]["version"]
+        return str(response.json()["info"]["version"])
     except Exception:  # best effort: offline or a PyPI hiccup is fine
+        return None
+
+
+def _fetch_latest_version() -> None:
+    """Ask PyPI for the latest release and remember it. Any failure is
+    ignored: the check must never get in the way of a command."""
+
+    latest = latest_version()
+    if latest is None:
         return
     state = _read_update_state()
     state.update(latest=str(latest), checked_at=time.time())

{devnomads_cli-0.11.1 → devnomads_cli-0.11.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devnomads-cli"
-version = "0.11.1"
+version = "0.11.2"
 description = "Manage your DevNomads services from the command line"
 readme = "README.md"
 requires-python = ">=3.10"

devnomads_cli-0.11.2/tests/test_versions.py

@@ -0,0 +1,271 @@
+"""Update notice, API version check and the user agent."""
+
+import json
+
+import pytest
+import respx
+from httpx import Response
+
+import dncli
+
+
+@pytest.fixture
+def interactive(monkeypatch):
+    monkeypatch.delenv(dncli.ENV_NO_UPDATE_CHECK, raising=False)
+    monkeypatch.delenv("CI", raising=False)
+    monkeypatch.setattr(dncli.err_console, "_force_terminal", True)
+
+
+def write_state(**state):
+    path = dncli._update_state_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state))
+
+
+def test_version_tuple():
+    assert dncli._version_tuple("0.10.0") == (0, 10, 0)
+    assert dncli._version_tuple("2.1") == (2, 1, 0)
+    assert dncli._version_tuple("1.0.0rc1") == (1, 0, 0)
+    assert dncli._version_tuple("") is None
+    assert dncli._version_tuple(None) is None
+
+
+def test_update_check_is_off_outside_a_terminal(monkeypatch):
+    monkeypatch.setattr(dncli.err_console, "_force_terminal", False)
+    assert not dncli._update_check_enabled()
+
+
+def test_update_check_can_be_disabled(interactive, monkeypatch):
+    assert dncli._update_check_enabled()
+    monkeypatch.setenv(dncli.ENV_NO_UPDATE_CHECK, "1")
+    assert not dncli._update_check_enabled()
+    monkeypatch.delenv(dncli.ENV_NO_UPDATE_CHECK)
+    monkeypatch.setenv("CI", "true")
+    assert not dncli._update_check_enabled()
+
+
+def test_notice_when_a_newer_version_is_out(interactive, capsys):
+    write_state(latest="99.0.0", checked_at=0)
+    dncli.notify_update()
+    assert "dncli 99.0.0 is available" in capsys.readouterr().err
+    # shown at most once a day
+    dncli.notify_update()
+    assert capsys.readouterr().err == ""
+
+
+def test_no_notice_when_up_to_date(interactive, capsys):
+    write_state(latest=dncli.__version__, checked_at=0)
+    dncli.notify_update()
+    assert capsys.readouterr().err == ""
+
+
+@respx.mock
+def test_fetch_stores_the_latest_version():
+    respx.get(dncli.PYPI_URL).mock(
+        return_value=Response(200, json={"info": {"version": "1.2.3"}})
+    )
+    dncli._fetch_latest_version()
+    assert dncli._read_update_state()["latest"] == "1.2.3"
+
+
+@respx.mock
+def test_fetch_failures_are_ignored():
+    respx.get(dncli.PYPI_URL).mock(return_value=Response(500, text="down"))
+    dncli._fetch_latest_version()
+    assert dncli._read_update_state() == {}
+
+
+def test_fresh_state_skips_the_background_check(interactive, monkeypatch):
+    started = []
+    monkeypatch.setattr(
+        dncli.threading, "Thread", lambda **kw: started.append(kw) or _Dummy()
+    )
+    write_state(latest="0.0.1", checked_at=dncli.time.time())
+    dncli.start_update_check()
+    assert started == []
+    write_state(latest="0.0.1", checked_at=0)
+    dncli.start_update_check()
+    assert len(started) == 1
+
+
+class _Dummy:
+    def start(self):
+        pass
+
+
+@pytest.fixture
+def api_warning(monkeypatch):
+    monkeypatch.setattr(dncli, "_api_version_warned", False)
+    monkeypatch.setattr(dncli, "API_VERSION", "1.4.0")
+
+
+def test_same_api_major_is_silent(api_warning, capsys):
+    dncli.check_api_version("1.9.2")
+    dncli.check_api_version(None)
+    assert capsys.readouterr().err == ""
+
+
+def test_newer_api_major_warns_once(api_warning, capsys):
+    dncli.check_api_version("2.0.0")
+    dncli.check_api_version("2.0.0")
+    err = capsys.readouterr().err
+    assert err.count("warning:") == 1
+    assert "built for API 1.4.0" in err and "update dncli" in err
+
+
+def test_older_api_major_warns(api_warning, capsys):
+    dncli.check_api_version("0.9.0")
+    assert "newer than the API" in capsys.readouterr().err
+
+
+def test_upgrade_required_message():
+    message = dncli._error_message(426, "Upgrade Required")
+    assert "no longer supported" in message
+    assert dncli.upgrade_command() in message
+
+
+@pytest.fixture
+def env(tmp_path, monkeypatch):
+    """A fake installation prefix; returns a function that sets it up."""
+
+    def make(marker=None, base=None, parts=("tools", "devnomads-cli")):
+        prefix = tmp_path.joinpath(*parts)
+        prefix.mkdir(parents=True, exist_ok=True)
+        if marker:
+            (prefix / marker).write_text("")
+        monkeypatch.setattr(dncli.sys, "prefix", str(prefix))
+        monkeypatch.setattr(dncli.sys, "base_prefix", base or "/usr")
+        monkeypatch.setattr(dncli.sys, "platform", "linux")
+        return prefix
+
+    return make
+
+
+def test_install_method_from_marker_files(env):
+    env("uv-receipt.toml")
+    assert dncli.install_method() == "uv-tool"
+    env("pipx_metadata.json", parts=("pipx", "venvs", "devnomads-cli"))
+    assert dncli.install_method() == "pipx"
+    env(parts=("cache", "uv", "archive-v0", "abc"))
+    assert dncli.install_method() == "uvx"
+    env(parts=("project", ".venv"))
+    assert dncli.install_method() == "venv"
+
+
+def test_install_method_system_and_script(env, monkeypatch):
+    prefix = env()
+    monkeypatch.setattr(dncli.sys, "base_prefix", str(prefix))
+    assert dncli.install_method() == "system"
+    monkeypatch.setattr(dncli, "_package_version", lambda name, fallback="": "")
+    assert dncli.install_method() == "script"
+
+
+def test_upgrade_argv_needs_the_installer(env, monkeypatch):
+    env("uv-receipt.toml")
+    monkeypatch.setattr(dncli.shutil, "which", lambda name: f"/bin/{name}")
+    assert dncli.upgrade_argv("uv-tool") == [
+        "/bin/uv",
+        "tool",
+        "upgrade",
+        "devnomads-cli",
+    ]
+    assert dncli.upgrade_command() == "dncli upgrade"
+    monkeypatch.setattr(dncli.shutil, "which", lambda name: None)
+    assert dncli.upgrade_argv("uv-tool") is None
+    assert dncli.upgrade_command() == "uv tool upgrade devnomads-cli"
+
+
+def test_upgrade_is_left_to_the_user_on_windows_and_system_pip(env, monkeypatch):
+    env("uv-receipt.toml")
+    monkeypatch.setattr(dncli.shutil, "which", lambda name: f"/bin/{name}")
+    monkeypatch.setattr(dncli.sys, "platform", "win32")
+    assert dncli.upgrade_argv("uv-tool") is None
+    monkeypatch.setattr(dncli.sys, "platform", "linux")
+    assert dncli.upgrade_argv("system") is None
+    assert dncli.upgrade_argv("uvx") is None
+
+
+@pytest.fixture
+def upgrade(monkeypatch):
+    """Stub PyPI, the installer and subprocess for `dncli upgrade`."""
+
+    calls = []
+
+    class Done:
+        def __init__(self, returncode=0, stdout=""):
+            self.returncode, self.stdout = returncode, stdout
+
+    def run(argv, **kwargs):
+        calls.append(argv)
+        if argv[0] == dncli.sys.executable:  # the version probe
+            return Done(stdout="99.0.0\n")
+        return Done()
+
+    monkeypatch.setattr(dncli, "latest_version", lambda: "99.0.0")
+    monkeypatch.setattr(dncli, "install_method", lambda: "uv-tool")
+    monkeypatch.setattr(
+        dncli, "upgrade_argv", lambda method: ["uv", "tool", "upgrade", "devnomads-cli"]
+    )
+    monkeypatch.setattr(dncli.subprocess, "run", run)
+    return calls
+
+
+def test_upgrade_runs_the_installer(upgrade):
+    from typer.testing import CliRunner
+
+    result = CliRunner().invoke(dncli.app, ["upgrade"])
+    assert result.exit_code == 0, result.output
+    assert upgrade[0] == ["uv", "tool", "upgrade", "devnomads-cli"]
+    assert f"upgraded from {dncli.__version__} to 99.0.0" in result.stderr
+
+
+def test_upgrade_dry_run_only_reports(upgrade):
+    from typer.testing import CliRunner
+
+    result = CliRunner().invoke(dncli.app, ["upgrade", "--dry-run"])
+    assert result.exit_code == 0
+    assert "installed with: uv-tool" in result.stderr
+    assert "would run: uv tool upgrade devnomads-cli" in result.stderr
+    assert upgrade == []
+
+
+def test_upgrade_when_already_current(upgrade, monkeypatch):
+    from typer.testing import CliRunner
+
+    monkeypatch.setattr(dncli, "latest_version", lambda: dncli.__version__)
+    result = CliRunner().invoke(dncli.app, ["upgrade"])
+    assert result.exit_code == 0
+    assert "already up to date" in result.stderr
+    assert upgrade == []
+
+
+def test_upgrade_explains_what_it_cannot_do(upgrade, monkeypatch):
+    from typer.testing import CliRunner
+
+    monkeypatch.setattr(dncli, "install_method", lambda: "system")
+    monkeypatch.setattr(dncli, "upgrade_argv", lambda method: None)
+    result = CliRunner().invoke(dncli.app, ["upgrade"])
+    assert result.exit_code == 1
+    assert "pip install -U devnomads-cli" in result.stderr
+    assert upgrade == []
+
+
+def test_user_agent_names_dncli_library_and_python():
+    agent = dncli.user_agent()
+    assert agent.startswith(f"dncli/{dncli.__version__} devnomads/")
+    assert " python/3." in agent
+
+
+@respx.mock
+def test_api_version_header_is_checked_on_every_call(
+    write_profile, api_warning, monkeypatch
+):
+    from typer.testing import CliRunner
+
+    write_profile(api_key="testkey-1234567890", api_url="https://api.test")
+    respx.get("https://api.test/services/servers").mock(
+        return_value=Response(200, json=[], headers={"X-Api-Version": "2.0.0"})
+    )
+    result = CliRunner().invoke(dncli.app, ["--out", "json", "servers", "list"])
+    assert result.exit_code == 0
+    assert "the API reports 2.0.0" in result.stderr

devnomads_cli-0.11.1/tests/test_versions.py

@@ -1,157 +0,0 @@
-"""Update notice, API version check and the user agent."""
-
-import json
-
-import pytest
-import respx
-from httpx import Response
-
-import dncli
-
-
-@pytest.fixture
-def interactive(monkeypatch):
-    monkeypatch.delenv(dncli.ENV_NO_UPDATE_CHECK, raising=False)
-    monkeypatch.delenv("CI", raising=False)
-    monkeypatch.setattr(dncli.err_console, "_force_terminal", True)
-
-
-def write_state(**state):
-    path = dncli._update_state_path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(state))
-
-
-def test_version_tuple():
-    assert dncli._version_tuple("0.10.0") == (0, 10, 0)
-    assert dncli._version_tuple("2.1") == (2, 1, 0)
-    assert dncli._version_tuple("1.0.0rc1") == (1, 0, 0)
-    assert dncli._version_tuple("") is None
-    assert dncli._version_tuple(None) is None
-
-
-def test_update_check_is_off_outside_a_terminal(monkeypatch):
-    monkeypatch.setattr(dncli.err_console, "_force_terminal", False)
-    assert not dncli._update_check_enabled()
-
-
-def test_update_check_can_be_disabled(interactive, monkeypatch):
-    assert dncli._update_check_enabled()
-    monkeypatch.setenv(dncli.ENV_NO_UPDATE_CHECK, "1")
-    assert not dncli._update_check_enabled()
-    monkeypatch.delenv(dncli.ENV_NO_UPDATE_CHECK)
-    monkeypatch.setenv("CI", "true")
-    assert not dncli._update_check_enabled()
-
-
-def test_notice_when_a_newer_version_is_out(interactive, capsys):
-    write_state(latest="99.0.0", checked_at=0)
-    dncli.notify_update()
-    assert "dncli 99.0.0 is available" in capsys.readouterr().err
-    # shown at most once a day
-    dncli.notify_update()
-    assert capsys.readouterr().err == ""
-
-
-def test_no_notice_when_up_to_date(interactive, capsys):
-    write_state(latest=dncli.__version__, checked_at=0)
-    dncli.notify_update()
-    assert capsys.readouterr().err == ""
-
-
-@respx.mock
-def test_fetch_stores_the_latest_version():
-    respx.get(dncli.PYPI_URL).mock(
-        return_value=Response(200, json={"info": {"version": "1.2.3"}})
-    )
-    dncli._fetch_latest_version()
-    assert dncli._read_update_state()["latest"] == "1.2.3"
-
-
-@respx.mock
-def test_fetch_failures_are_ignored():
-    respx.get(dncli.PYPI_URL).mock(return_value=Response(500, text="down"))
-    dncli._fetch_latest_version()
-    assert dncli._read_update_state() == {}
-
-
-def test_fresh_state_skips_the_background_check(interactive, monkeypatch):
-    started = []
-    monkeypatch.setattr(
-        dncli.threading, "Thread", lambda **kw: started.append(kw) or _Dummy()
-    )
-    write_state(latest="0.0.1", checked_at=dncli.time.time())
-    dncli.start_update_check()
-    assert started == []
-    write_state(latest="0.0.1", checked_at=0)
-    dncli.start_update_check()
-    assert len(started) == 1
-
-
-class _Dummy:
-    def start(self):
-        pass
-
-
-@pytest.fixture
-def api_warning(monkeypatch):
-    monkeypatch.setattr(dncli, "_api_version_warned", False)
-    monkeypatch.setattr(dncli, "API_VERSION", "1.4.0")
-
-
-def test_same_api_major_is_silent(api_warning, capsys):
-    dncli.check_api_version("1.9.2")
-    dncli.check_api_version(None)
-    assert capsys.readouterr().err == ""
-
-
-def test_newer_api_major_warns_once(api_warning, capsys):
-    dncli.check_api_version("2.0.0")
-    dncli.check_api_version("2.0.0")
-    err = capsys.readouterr().err
-    assert err.count("warning:") == 1
-    assert "built for API 1.4.0" in err and "update dncli" in err
-
-
-def test_older_api_major_warns(api_warning, capsys):
-    dncli.check_api_version("0.9.0")
-    assert "newer than the API" in capsys.readouterr().err
-
-
-def test_upgrade_required_message():
-    message = dncli._error_message(426, "Upgrade Required")
-    assert "no longer supported" in message
-    assert dncli.upgrade_command() in message
-
-
-@pytest.mark.parametrize(
-    "prefix, expected",
-    [
-        ("/home/u/.local/share/uv/tools/devnomads-cli", "uv tool upgrade"),
-        ("/home/u/.local/pipx/venvs/devnomads-cli", "pipx upgrade"),
-    ],
-)
-def test_upgrade_command_follows_the_install_method(monkeypatch, prefix, expected):
-    monkeypatch.setattr(dncli.sys, "prefix", prefix)
-    assert dncli.upgrade_command().startswith(expected)
-
-
-def test_user_agent_names_dncli_library_and_python():
-    agent = dncli.user_agent()
-    assert agent.startswith(f"dncli/{dncli.__version__} devnomads/")
-    assert " python/3." in agent
-
-
-@respx.mock
-def test_api_version_header_is_checked_on_every_call(
-    write_profile, api_warning, monkeypatch
-):
-    from typer.testing import CliRunner
-
-    write_profile(api_key="testkey-1234567890", api_url="https://api.test")
-    respx.get("https://api.test/services/servers").mock(
-        return_value=Response(200, json=[], headers={"X-Api-Version": "2.0.0"})
-    )
-    result = CliRunner().invoke(dncli.app, ["--out", "json", "servers", "list"])
-    assert result.exit_code == 0
-    assert "the API reports 2.0.0" in result.stderr