clan-app: rename clan-vm-manager

pkgs/clan-app/tests/command.py

@@ -0,0 +1,64 @@
+import os
+import signal
+import subprocess
+from collections.abc import Iterator
+from pathlib import Path
+from typing import IO, Any
+
+import pytest
+
+_FILE = None | int | IO[Any]
+
+
+class Command:
+    def __init__(self) -> None:
+        self.processes: list[subprocess.Popen[str]] = []
+
+    def run(
+        self,
+        command: list[str],
+        extra_env: dict[str, str] = {},
+        stdin: _FILE = None,
+        stdout: _FILE = None,
+        stderr: _FILE = None,
+        workdir: Path | None = None,
+    ) -> subprocess.Popen[str]:
+        env = os.environ.copy()
+        env.update(extra_env)
+        # We start a new session here so that we can than more reliably kill all childs as well
+        p = subprocess.Popen(
+            command,
+            env=env,
+            start_new_session=True,
+            stdout=stdout,
+            stderr=stderr,
+            stdin=stdin,
+            text=True,
+            cwd=workdir,
+        )
+        self.processes.append(p)
+        return p
+
+    def terminate(self) -> None:
+        # Stop in reverse order in case there are dependencies.
+        # We just kill all processes as quickly as possible because we don't
+        # care about corrupted state and want to make tests fasts.
+        for p in reversed(self.processes):
+            try:
+                os.killpg(os.getpgid(p.pid), signal.SIGKILL)
+            except OSError:
+                pass
+
+
+@pytest.fixture
+def command() -> Iterator[Command]:
+    """
+    Starts a background command. The process is automatically terminated in the end.
+    >>> p = command.run(["some", "daemon"])
+    >>> print(p.pid)
+    """
+    c = Command()
+    try:
+        yield c
+    finally:
+        c.terminate()

pkgs/clan-app/tests/conftest.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from clan_cli.custom_logger import setup_logging
+from clan_cli.nix import nix_shell
+
+sys.path.append(str(Path(__file__).parent / "helpers"))
+sys.path.append(str(Path(__file__).parent.parent))  # Also add clan app to PYTHONPATH
+
+pytest_plugins = [
+    "temporary_dir",
+    "root",
+    "command",
+    "wayland",
+]
+
+
+# Executed on pytest session start
+def pytest_sessionstart(session: pytest.Session) -> None:
+    # This function will be called once at the beginning of the test session
+    print("Starting pytest session")
+    # You can access the session config, items, testsfailed, etc.
+    print(f"Session config: {session.config}")
+
+    setup_logging(level="DEBUG")
+
+
+# fixture for git_repo
+@pytest.fixture
+def git_repo(tmp_path: Path) -> Path:
+    # initialize a git repository
+    cmd = nix_shell(["nixpkgs#git"], ["git", "init"])
+    subprocess.run(cmd, cwd=tmp_path, check=True)
+    # set user.name and user.email
+    cmd = nix_shell(["nixpkgs#git"], ["git", "config", "user.name", "test"])
+    subprocess.run(cmd, cwd=tmp_path, check=True)
+    cmd = nix_shell(["nixpkgs#git"], ["git", "config", "user.email", "test@test.test"])
+    subprocess.run(cmd, cwd=tmp_path, check=True)
+    # return the path to the git repository
+    return tmp_path

pkgs/clan-app/tests/helpers/cli.py

@@ -0,0 +1,15 @@
+import logging
+import shlex
+
+from clan_cli.custom_logger import get_caller
+
+from clan_app import main
+
+log = logging.getLogger(__name__)
+
+
+class Cli:
+    def run(self, args: list[str]) -> None:
+        cmd = shlex.join(["clan", *args])
+        log.debug(f"$ {cmd} \nCaller: {get_caller()}")
+        main(args)

pkgs/clan-app/tests/root.py

@@ -0,0 +1,35 @@
+import os
+from pathlib import Path
+
+import pytest
+
+TEST_ROOT = Path(__file__).parent.resolve()
+PROJECT_ROOT = TEST_ROOT.parent
+if CLAN_CORE_ := os.environ.get("CLAN_CORE"):
+    CLAN_CORE = Path(CLAN_CORE_)
+else:
+    CLAN_CORE = PROJECT_ROOT.parent.parent
+
+
+@pytest.fixture(scope="session")
+def project_root() -> Path:
+    """
+    Root directory the clan-cli
+    """
+    return PROJECT_ROOT
+
+
+@pytest.fixture(scope="session")
+def test_root() -> Path:
+    """
+    Root directory of the tests
+    """
+    return TEST_ROOT
+
+
+@pytest.fixture(scope="session")
+def clan_core() -> Path:
+    """
+    Directory of the clan-core flake
+    """
+    return CLAN_CORE

pkgs/clan-app/tests/temporary_dir.py

@@ -0,0 +1,27 @@
+import logging
+import os
+import tempfile
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+log = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def temporary_home(monkeypatch: pytest.MonkeyPatch) -> Iterator[Path]:
+    env_dir = os.getenv("TEST_TEMPORARY_DIR")
+    if env_dir is not None:
+        path = Path(env_dir).resolve()
+        log.debug("Temp HOME directory: %s", str(path))
+        monkeypatch.setenv("HOME", str(path))
+        monkeypatch.chdir(str(path))
+        yield path
+    else:
+        with tempfile.TemporaryDirectory(prefix="pytest-") as dirpath:
+            monkeypatch.setenv("HOME", str(dirpath))
+            monkeypatch.setenv("XDG_CONFIG_HOME", str(Path(dirpath) / ".config"))
+            monkeypatch.chdir(str(dirpath))
+            log.debug("Temp HOME directory: %s", str(dirpath))
+            yield Path(dirpath)

pkgs/clan-app/tests/test_cli.py

@@ -0,0 +1,8 @@
+import pytest
+from cli import Cli
+
+
+def test_help(capfd: pytest.CaptureFixture) -> None:
+    cli = Cli()
+    with pytest.raises(SystemExit):
+        cli.run(["clan-app", "--help"])

pkgs/clan-app/tests/test_join.py

@@ -0,0 +1,8 @@
+import time
+
+from wayland import GtkProc
+
+
+def test_open(app: GtkProc) -> None:
+    time.sleep(0.5)
+    assert app.poll() is None

pkgs/clan-app/tests/wayland.py

@@ -0,0 +1,27 @@
+import sys
+from collections.abc import Generator
+from subprocess import Popen
+from typing import NewType
+
+import pytest
+
+
+@pytest.fixture(scope="session")
+def wayland_compositor() -> Generator[Popen, None, None]:
+    # Start the Wayland compositor (e.g., Weston)
+    # compositor = Popen(["weston", "--backend=headless-backend.so"])
+    compositor = Popen(["weston"])
+    yield compositor
+    # Cleanup: Terminate the compositor
+    compositor.terminate()
+
+
+GtkProc = NewType("GtkProc", Popen)
+
+
+@pytest.fixture(scope="function")
+def app() -> Generator[GtkProc, None, None]:
+    rapp = Popen([sys.executable, "-m", "clan_app"], text=True)
+    yield GtkProc(rapp)
+    # Cleanup: Terminate your application
+    rapp.terminate()