chore: prepare release v0.4.0

tests/test_cli.py

@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
+import argparse
 import contextlib
+import json
 import sys
+import urllib.error
 from pathlib import Path
 from unittest import mock
 
 import pytest
 
 from volumen import VERSION
+from volumen import cli as cli_module
 from volumen.cli import main
 
 
@@ -87,3 +91,422 @@ class TestPrepareConfig:
         path.write_text("[server]\nport = 1\n")
         result = Config.generate_default(str(path))
         assert result is None
+
+
+class TestCheckUpdate:
+    def _fake_response(self, payload: dict[str, object]) -> object:
+        """Build a context-manager-compatible mock that returns *payload* on .read()."""
+        response = mock.MagicMock()
+        response.read.return_value = json.dumps(payload).encode("utf-8")
+        response.__enter__.return_value = response
+        return response
+
+    def _patches(
+        self,
+        *,
+        installed: str,
+        latest: str | None,
+        error: Exception | None = None,
+    ) -> object:
+        """Stack of context managers patching version + urlopen for one call."""
+        from contextlib import ExitStack
+
+        stack = ExitStack()
+        stack.enter_context(
+            mock.patch.object(cli_module, "_get_installed_version", return_value=installed)
+        )
+        if error is not None:
+            stack.enter_context(
+                mock.patch.object(cli_module.urllib.request, "urlopen", side_effect=error)
+            )
+        else:
+            stack.enter_context(
+                mock.patch.object(
+                    cli_module.urllib.request,
+                    "urlopen",
+                    return_value=self._fake_response({"info": {"version": latest}}),
+                )
+            )
+        return stack
+
+    def test_update_available(self, capsys: pytest.CaptureFixture[str]) -> None:
+        args = argparse.Namespace(json=False)
+        with self._patches(installed="0.4.0", latest="0.5.0"):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 1
+        assert "0.4.0" in captured.out
+        assert "0.5.0" in captured.out
+        assert "uv tool upgrade volumen" in captured.out
+
+    def test_up_to_date(self, capsys: pytest.CaptureFixture[str]) -> None:
+        args = argparse.Namespace(json=False)
+        with self._patches(installed="0.5.0", latest="0.5.0"):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 0
+        assert "up to date" in captured.out
+
+    def test_local_ahead_of_remote(self, capsys: pytest.CaptureFixture[str]) -> None:
+        """A locally-built unreleased version is not 'behind' the latest tag."""
+        args = argparse.Namespace(json=False)
+        with self._patches(installed="1.0.0a1", latest="0.9.0"):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 0
+        assert "up to date" in captured.out
+
+    def test_prerelease_handling(self) -> None:
+        """Pre-release and local segments are stripped before numeric comparison.
+
+        Implementation is intentionally conservative — ``0.5.0a1`` and ``0.5.0``
+        are seen as the same core version (``(0, 5, 0)``), so we report no
+        update between them. A higher minor/major with a pre-release or local
+        segment is still correctly detected.
+        """
+        assert cli_module._compare_versions("0.5.0", "0.5.1a1+build") is True
+        assert cli_module._compare_versions("0.5.0+a", "0.5.0+a") is False
+        assert cli_module._compare_versions("0.5.0+a", "0.5.1") is True
+
+    def test_offline_returns_exit_code_2(self, capsys: pytest.CaptureFixture[str]) -> None:
+        args = argparse.Namespace(json=False)
+        with self._patches(
+            installed="0.4.0",
+            latest=None,
+            error=urllib.error.URLError("no internet"),
+        ):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 2
+        assert "could not reach" in captured.err
+        assert "0.4.0" in captured.err
+
+    def test_json_output_with_update_available(self, capsys: pytest.CaptureFixture[str]) -> None:
+        args = argparse.Namespace(json=True)
+        with self._patches(installed="0.4.0", latest="0.5.0"):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 1
+        doc = json.loads(captured.out)
+        assert doc["current_version"] == "0.4.0"
+        assert doc["latest_version"] == "0.5.0"
+        assert doc["update_available"] is True
+        assert "error" not in doc
+
+    def test_json_output_when_offline(self, capsys: pytest.CaptureFixture[str]) -> None:
+        args = argparse.Namespace(json=True)
+        with self._patches(
+            installed="0.4.0",
+            latest=None,
+            error=urllib.error.URLError("dns failure"),
+        ):
+            rc = cli_module._check_update(args)
+        captured = capsys.readouterr()
+        assert rc == 2
+        doc = json.loads(captured.out)
+        assert doc["current_version"] == "0.4.0"
+        assert doc["latest_version"] is None
+        assert doc["update_available"] is False
+        assert "error" in doc
+
+
+class TestServeCommand:
+    def _config_path(self, tmp_path: Path, content_dir: Path) -> Path:
+        """Write a minimal but complete config and return the path."""
+        config_path = tmp_path / "config.toml"
+        users_file = tmp_path / "users.toml"
+        config_path.write_text(
+            f'content_dir = "{content_dir}"\n'
+            f'users_file = "{users_file}"\n'
+            "[admin]\n"
+            'password_hash = ""\n'
+        )
+        return config_path
+
+    def test_serve_loads_config_and_invokes_uvicorn(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        content_dir = tmp_path / "posts"
+        content_dir.mkdir()
+        config_path = self._config_path(tmp_path, content_dir)
+
+        import uvicorn
+
+        captured: list[dict[str, object]] = []
+
+        def fake_run(app: object, **kwargs: object) -> None:
+            captured.append({"app": app, **kwargs})
+
+        monkeypatch.setattr(uvicorn, "run", fake_run)
+
+        args = argparse.Namespace(
+            config=str(config_path),
+            host=None,
+            port=None,
+            content=None,
+        )
+        cli_module._serve(args)
+
+        assert len(captured) == 1
+        call = captured[0]
+        assert call["host"] == "::"
+        assert call["port"] == 9090
+        assert call["log_level"] == "info"
+        from fastapi import FastAPI
+
+        assert isinstance(call["app"], FastAPI)
+
+    def test_serve_applies_host_and_port_overrides(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        content_dir = tmp_path / "posts"
+        content_dir.mkdir()
+        config_path = self._config_path(tmp_path, content_dir)
+
+        import uvicorn
+
+        captured: list[dict[str, object]] = []
+
+        def fake_run(app: object, **kwargs: object) -> None:
+            captured.append(kwargs)
+
+        monkeypatch.setattr(uvicorn, "run", fake_run)
+
+        args = argparse.Namespace(
+            config=str(config_path),
+            host="127.0.0.1",
+            port=9000,
+            content=None,
+        )
+        cli_module._serve(args)
+
+        assert captured[0]["host"] == "127.0.0.1"
+        assert captured[0]["port"] == 9000
+
+
+class TestStatusCommand:
+    def test_status_human_output_with_issues(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        info = {
+            "config_path": "/etc/volumen/config.toml",
+            "data_dir": "/var/lib/volumen/posts",
+            "users_file": "/var/lib/volumen/users.toml",
+            "config_exists": True,
+            "data_dir_exists": True,
+            "users_file_exists": False,
+            "posts_subdir_exists": True,
+            "media_subdir_exists": True,
+            "password_hash_set": True,
+            "session_key_ok": True,
+            "systemd_unit_installed": True,
+            "service_active": "inactive",
+            "admin_user_present": False,
+            "issues": ["users file does not exist", "admin user missing"],
+        }
+        monkeypatch.setattr(cli_module, "_status", _FakeStatus(info))
+        with (
+            mock.patch.object(sys, "argv", ["volumen", "status"]),
+            pytest.raises(SystemExit) as exc,
+        ):
+            main()
+        captured = capsys.readouterr()
+        assert exc.value.code == 1
+        assert "==>" in captured.out
+        assert "volumen status" in captured.out
+        assert "users file does not exist" in captured.out
+        assert "admin user missing" in captured.out
+        assert "Issues:" in captured.out
+
+    def test_status_returns_zero_when_no_issues(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        info = {
+            "config_path": "/etc/volumen/config.toml",
+            "data_dir": "/var/lib/volumen/posts",
+            "users_file": "/var/lib/volumen/users.toml",
+            "config_exists": True,
+            "data_dir_exists": True,
+            "users_file_exists": True,
+            "posts_subdir_exists": True,
+            "media_subdir_exists": True,
+            "password_hash_set": True,
+            "session_key_ok": True,
+            "systemd_unit_installed": True,
+            "service_active": "active",
+            "admin_user_present": True,
+            "issues": [],
+        }
+        monkeypatch.setattr(cli_module, "_status", _FakeStatus(info))
+        with (
+            mock.patch.object(sys, "argv", ["volumen", "status"]),
+            pytest.raises(SystemExit) as exc,
+        ):
+            main()
+        captured = capsys.readouterr()
+        assert exc.value.code == 0
+        assert "All checks passed." in captured.out
+
+
+class _FakeStatus:
+    """Mock returning a static info dict from cli._status."""
+
+    def __init__(self, info: dict[str, object]) -> None:
+        self._info = info
+
+    def __call__(self, args: argparse.Namespace) -> int:
+        # Mirror the shape of the real _status(). For human mode print plain
+        # text; for --json print the info as JSON. Exit code 0 if no issues.
+        import json as _json
+
+        if args.json:
+            print(_json.dumps(self._info, indent=2, sort_keys=True))
+        else:
+            print("==> volumen status")
+            print()
+            print(f"  Config:           {self._info['config_path']}")
+            print(f"  Data dir:         {self._info['data_dir']}")
+            print(f"  Users file:       {self._info['users_file']}")
+            unit = "installed" if self._info["systemd_unit_installed"] else "not installed"
+            print(f"  Systemd unit:     {unit}")
+            print(f"  Service:          {self._info['service_active']}")
+            presence = "present" if self._info["admin_user_present"] else "missing"
+            print(f"  Admin user:       {presence}")
+            print()
+            issues = list(self._info["issues"])
+            if not issues:
+                print("All checks passed.")
+            else:
+                print("Issues:")
+                for issue in issues:
+                    print(f"  - {issue}")
+        return 0 if not self._info["issues"] else 1
+
+
+class TestInitCommand:
+    def test_init_rejects_systemd_under_local(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        # Force ``use_user=True`` then ``--systemd`` → exit 2 with explanation.
+        monkeypatch.setattr(cli_module, "_is_root", lambda: False)
+        with (
+            mock.patch.object(
+                sys,
+                "argv",
+                ["volumen", "init", "--local", "--systemd"],
+            ),
+            pytest.raises(SystemExit) as exc,
+        ):
+            main()
+        assert exc.value.code == 2
+        captured = capsys.readouterr()
+        assert "--systemd is not available for per-user installs" in captured.err
+
+    def test_init_propagates_installer_error(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        # ``system_install`` is mocked to raise InstallerError → exit 1 + stderr msg.
+        monkeypatch.setattr(cli_module, "_is_root", lambda: True)
+
+        def fake_system_install(**_kwargs: object) -> object:
+            from volumen.installer import InstallerError
+
+            raise InstallerError("simulated installer failure")
+
+        # _init does ``from .installer import system_install`` per call, so we
+        # patch at the import site (volumen.installer.system_install) rather
+        # than the local reference inside cli_module.
+        monkeypatch.setattr("volumen.installer.system_install", fake_system_install)
+
+        args = argparse.Namespace(
+            local=False,
+            systemd=False,
+            config=None,
+            data=None,
+            users_file=None,
+            service_user="volumen",
+            enable=True,
+            admin_password="some-strong-pw-1234",
+            force=False,
+        )
+        with pytest.raises(SystemExit) as exc:
+            cli_module._init(args)
+        captured = capsys.readouterr()
+        assert exc.value.code == 1
+        assert "simulated installer failure" in captured.err
+
+    def test_init_user_install_branch(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        # ``--local`` → user_install() path. Mock user_install to skip side effects.
+        monkeypatch.setattr(cli_module, "_is_root", lambda: False)
+
+        from volumen.installer import InstallResult
+
+        fake_result = InstallResult(
+            config_path=Path("/home/u/.config/volumen/config.toml"),
+            content_dir=Path("/home/u/.local/share/volumen/posts"),
+            users_file=Path("/home/u/.local/share/volumen/users.toml"),
+            service_user=None,
+            password_hash="scrypt$...",
+            session_key="x" * 128,
+            systemd_unit_path=None,
+            messages=[],
+        )
+        monkeypatch.setattr(
+            "volumen.installer.user_install",
+            lambda **_kw: fake_result,
+        )
+
+        args = argparse.Namespace(
+            local=True,
+            systemd=False,
+            config=None,
+            data=None,
+            users_file=None,
+            service_user="volumen",
+            enable=True,
+            admin_password="some-strong-pw-1234",
+            force=False,
+        )
+        cli_module._init(args)  # Should not raise.
+        captured = capsys.readouterr()
+        assert "==> volumen installed." in captured.out
+        assert "Service:       not installed" in captured.out
+
+
+class TestPrintInitSummary:
+    def test_summary_skipped_message(self, capsys: pytest.CaptureFixture[str]) -> None:
+        from volumen.installer import InstallResult
+
+        result = InstallResult(
+            config_path=Path("/etc/volumen/config.toml"),
+            content_dir=Path("/var/lib/volumen/posts"),
+            users_file=Path("/var/lib/volumen/users.toml"),
+            service_user="volumen",
+            password_hash="",
+            session_key="",
+            systemd_unit_path=None,
+            messages=["config exists, leaving untouched (use --force to overwrite)"],
+        )
+        cli_module._print_init_summary(result, install_service=True, use_user=False)
+        captured = capsys.readouterr()
+        assert "left untouched" in captured.out
+        assert "Nothing to do" in captured.out
+
+    def test_summary_user_install(self, capsys: pytest.CaptureFixture[str]) -> None:
+        from volumen.installer import InstallResult
+
+        result = InstallResult(
+            config_path=Path("/home/u/.config/volumen/config.toml"),
+            content_dir=Path("/home/u/.local/share/volumen/posts"),
+            users_file=Path("/home/u/.local/share/volumen/users.toml"),
+            service_user=None,
+            password_hash="",
+            session_key="",
+            systemd_unit_path=None,
+            messages=[],
+        )
+        cli_module._print_init_summary(result, install_service=False, use_user=True)
+        captured = capsys.readouterr()
+        assert "Service:       not installed" in captured.out