Skip to content

armgit / ODS

Public Imported from GitHub
0

ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.

38.0 KB
Raw Blame
"""Selection checks must survive state changes and contend on a real lock."""

import importlib.util
import json
from pathlib import Path
import subprocess
import sys

import pytest


SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "extension-selection.py"
SPEC = importlib.util.spec_from_file_location("extension_selection", SCRIPT)
selection = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(selection)


def extension(root, service_id, *, depends=(), compose_depends=(), enabled=True):
    directory = root / "extensions" / "services" / service_id
    directory.mkdir(parents=True, exist_ok=True)
    deps = ", ".join(depends)
    (directory / "manifest.yaml").write_text(
        f"service:\n  id: {service_id}\n  depends_on: [{deps}]\n", encoding="utf-8"
    )
    chosen = "compose.yaml" if enabled else "compose.yaml.disabled"
    compose_deps = ", ".join(compose_depends)
    (directory / chosen).write_text(
        f"services:\n  {service_id}:\n    image: example:latest\n"
        f"    depends_on: [{compose_deps}]\n", encoding="utf-8"
    )
    return directory


def restore(root, preset, *, compose_flags="-f docker-compose.base.yml"):
    base = root / "docker-compose.base.yml"
    if not base.exists():
        base.write_text("services: {}\n", encoding="utf-8")
    return selection.restore_preset(root, preset, compose_flags=compose_flags)


def test_preset_accepts_native_windows_compose_flags_before_library_enable(tmp_path):
    """The installed Windows stack must let the Library enable a dependency pair."""
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / ".env").write_text("ODS_MODE=local\n", encoding="utf-8")
    (tmp_path / "docker-compose.base.yml").write_text(
        "services:\n  dashboard: {}\n", encoding="utf-8",
    )
    (tmp_path / "docker-compose.nvidia.yml").write_text(
        "services:\n  llama-server: {}\n", encoding="utf-8",
    )
    extension(tmp_path, "litellm")
    search = extension(tmp_path, "searxng", enabled=False)
    research = extension(tmp_path, "perplexica", depends=("searxng",), enabled=False)
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:searxng\nenabled:perplexica\n", encoding="utf-8")
    flags = ("--env-file .env -f docker-compose.base.yml "
             "-f docker-compose.nvidia.yml -f extensions/services/litellm/compose.yaml")

    assert restore(tmp_path, preset, compose_flags=flags) == (2, 0, [])
    assert (search / "compose.yaml").is_file()
    assert (research / "compose.yaml").is_file()


@pytest.mark.parametrize("prefix", [
    "--env-file", "--env-file ../.env", "--env-file /tmp/.env",
    "--env-file .env.local", r"--env-file .\env", '--env-file ".env"',
    "--env-file .env --env-file .env",
    "--project-name other", "-f", "-f docker-compose.base.yml --env-file .env",
])
def test_preset_rejects_untrusted_native_compose_flags_without_marker_moves(tmp_path, prefix):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / ".env").write_text("ODS_MODE=local\n", encoding="utf-8")
    target = extension(tmp_path, "searxng", enabled=False)
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:searxng\n", encoding="utf-8")

    with pytest.raises(selection.SelectionError, match="Invalid current Compose flags"):
        restore(tmp_path, preset, compose_flags=f"{prefix} -f docker-compose.base.yml")
    assert (target / "compose.yaml.disabled").is_file()
    assert not (target / "compose.yaml").exists()


def test_preset_rejects_symlinked_native_env_file_without_marker_moves(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    external = tmp_path / "other.env"
    external.write_text("ODS_MODE=local\n", encoding="utf-8")
    try:
        (tmp_path / ".env").symlink_to(external)
    except OSError:
        pytest.skip("symlink creation is unavailable")
    target = extension(tmp_path, "searxng", enabled=False)
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:searxng\n", encoding="utf-8")

    with pytest.raises(selection.SelectionError, match="Invalid current Compose environment file"):
        restore(tmp_path, preset, compose_flags="--env-file .env -f docker-compose.base.yml")
    assert (target / "compose.yaml.disabled").is_file()
    assert not (target / "compose.yaml").exists()


def test_selected_compose_and_user_shadowing(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    extension(tmp_path, "search")
    extension(tmp_path, "manifest-user", depends=("search",))
    extension(tmp_path, "compose-user", compose_depends=("search",))
    assert selection._enabled_dependents(tmp_path, "search") == ["compose-user", "manifest-user"]

    # The Compose resolver still selects the enabled bundled fragment even
    # when a same-name user definition is disabled.
    user = tmp_path / "data" / "user-extensions" / "manifest-user"
    user.mkdir()
    (user / "compose.yaml.disabled").write_text("services: {}\n", encoding="utf-8")
    assert selection._enabled_dependents(tmp_path, "search") == ["compose-user", "manifest-user"]

    (user / "compose.yaml.disabled").rename(user / "compose.yaml")
    (user / "manifest.yaml").write_text(
        "service:\n  id: manifest-user\n  depends_on: [search]\n", encoding="utf-8"
    )
    assert selection._enabled_dependents(tmp_path, "search") == ["manifest-user", "compose-user"]
    (user / "manifest.yaml").write_text(
        "service:\n  id: manifest-user\n  depends_on: []\n", encoding="utf-8"
    )
    assert selection._enabled_dependents(tmp_path, "search") == ["compose-user", "manifest-user"]


def test_incomplete_user_directory_cannot_hide_enabled_bundled_dependent(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    bundled = extension(tmp_path, "consumer", depends=("search",))
    user = tmp_path / "data" / "user-extensions" / "consumer"
    user.mkdir()

    # The Compose resolver still selects the bundled fragment. An interrupted
    # user install must not make its dependency disappear from disable checks.
    assert (bundled / "compose.yaml").is_file()
    assert selection._enabled_dependents(tmp_path, "search") == ["consumer"]
    with pytest.raises(selection.SelectionError, match="enabled extensions depend on search"):
        selection.run("disable", tmp_path, "search")
    assert (target / "compose.yaml").is_file()


def test_selected_json_manifest_dependent_blocks_disable(tmp_path):
    user_root = tmp_path / "data" / "user-extensions"
    user_root.mkdir(parents=True)
    target = extension(tmp_path, "search")
    consumer = user_root / "consumer"
    consumer.mkdir()
    (consumer / "compose.yaml").write_text(
        "services:\n  consumer:\n    image: alpine:3.22\n", encoding="utf-8",
    )
    (consumer / "manifest.json").write_text(json.dumps({
        "schema_version": "ods.services.v1",
        "service": {"id": "consumer", "depends_on": ["search"]},
    }), encoding="utf-8")

    assert selection._enabled_dependents(tmp_path, "search") == ["consumer"]
    with pytest.raises(selection.SelectionError, match="enabled extensions depend on search"):
        selection.run("check-disable", tmp_path, "search")
    assert (target / "compose.yaml").is_file()


def test_malformed_selected_json_manifest_fails_closed(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    consumer = extension(tmp_path, "consumer")
    (consumer / "manifest.yaml").unlink()
    (consumer / "manifest.json").write_text('{"service":', encoding="utf-8")

    with pytest.raises(selection.SelectionError, match="Cannot inspect selected file"):
        selection.run("check-disable", tmp_path, "search")
    assert (target / "compose.yaml").is_file()


def test_bad_selected_compose_fails_closed(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    extension(tmp_path, "search")
    peer = extension(tmp_path, "consumer", compose_depends=("search",))
    (peer / "compose.yaml").write_text("services: [invalid]\n", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="Invalid selected Compose services"):
        selection._enabled_dependents(tmp_path, "search")


def test_missing_yaml_module_fails_closed_for_selected_peer(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    extension(tmp_path, "search")
    extension(tmp_path, "consumer", compose_depends=("search",))
    monkeypatch.setitem(sys.modules, "yaml", None)
    with pytest.raises(selection.SelectionError, match="PyYAML is required"):
        selection.run("disable", tmp_path, "search")
    assert (tmp_path / "extensions" / "services" / "search" / "compose.yaml").is_file()


def test_state_change_between_preflight_and_commit_retains_selection_and_data(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    retained = tmp_path / "data" / "search" / "settings.json"
    retained.parent.mkdir()
    retained.write_text("keep", encoding="utf-8")
    assert selection.run("check-disable", tmp_path, "search") == "ready"

    peer = extension(tmp_path, "consumer", compose_depends=("search",))
    with pytest.raises(selection.SelectionError, match="enabled extensions depend on search"):
        selection.run("disable", tmp_path, "search")
    assert (target / "compose.yaml").is_file()
    assert retained.read_text(encoding="utf-8") == "keep"

    (peer / "compose.yaml").rename(peer / "compose.yaml.disabled")
    assert selection.run("disable", tmp_path, "search") == "disabled"
    assert (target / "compose.yaml.disabled").is_file()
    assert not (target / "compose.yaml").exists()
    assert retained.read_text(encoding="utf-8") == "keep"


def test_cli_stop_and_commit_hold_selection_lock_against_dependent_enable(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    dependent = extension(tmp_path, "consumer", depends=("search",), enabled=False)
    original_run = subprocess.run

    def stop_with_concurrent_enable(args, **kwargs):
        assert args[-2:] == ["stop", "search"]
        assert (target / "compose.yaml").is_file()
        contender = original_run(
            [sys.executable, str(SCRIPT), "enable", "--install-dir", str(tmp_path),
             "--service-id", "consumer", "--lock-timeout", "0.1"],
            capture_output=True, text=True, timeout=5,
        )
        assert contender.returncode == 1
        assert "Timed out waiting for extensions lock" in contender.stderr
        return subprocess.CompletedProcess(args, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", stop_with_concurrent_enable)
    assert selection.run("disable", tmp_path, "search", stop_mode="compose",
                         compose_flags="-f docker-compose.base.yml") == "disabled"
    assert (target / "compose.yaml.disabled").is_file()
    assert (dependent / "compose.yaml.disabled").is_file()


def test_cli_disable_stops_the_companions_its_fragment_owns(tmp_path, monkeypatch):
    """A database left running keeps writing the data a later purge deletes."""
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    extension(tmp_path, "search-proxy")
    (target / "compose.yaml").write_text(
        "services:\n"
        "  search:\n    image: example:latest\n"
        "  search-db:\n    image: example:latest\n"
        "  search-worker:\n    image: example:latest\n"
        "  search-proxy:\n    environment: [EXTRA=1]\n"
        "  llama-server:\n    environment: [EXTRA=1]\n",
        encoding="utf-8",
    )
    calls = []

    def stop(args, **kwargs):
        calls.append(args)
        return subprocess.CompletedProcess(args, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", stop)
    assert selection.run("disable", tmp_path, "search", stop_mode="compose",
                         compose_flags="-f docker-compose.base.yml") == "disabled"
    # A service with its own extension directory and a core service keep
    # their own lifecycle.
    assert [args[-4:] for args in calls] == [["stop", "search", "search-db", "search-worker"]]


def test_cli_disable_rollback_restarts_every_stopped_companion(tmp_path, monkeypatch):
    """A failed marker rename must not leave a stopped worker behind."""
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    (target / "compose.yaml").write_text(
        "services:\n"
        "  search:\n    image: example:latest\n"
        "  search-db:\n    image: example:latest\n"
        "  search-worker:\n    image: example:latest\n",
        encoding="utf-8",
    )
    calls = []

    def record(args, **kwargs):
        calls.append(args)
        return subprocess.CompletedProcess(args, 0, "", "")

    original_replace = selection.os.replace

    def refuse_marker_rename(source, destination):
        if Path(source) == target / "compose.yaml":
            raise OSError("read-only extension directory")
        return original_replace(source, destination)

    monkeypatch.setattr(selection.subprocess, "run", record)
    monkeypatch.setattr(selection.os, "replace", refuse_marker_rename)
    with pytest.raises(selection.SelectionError, match="selected file remains recoverable"):
        selection.run("disable", tmp_path, "search", stop_mode="compose",
                      compose_flags="-f docker-compose.base.yml")
    assert [args[-4:] for args in calls] == [
        ["stop", "search", "search-db", "search-worker"],
        ["start", "search", "search-db", "search-worker"],
    ]
    assert (target / "compose.yaml").is_file()


def test_cli_stop_failure_preserves_selection_and_cache(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    cache = tmp_path / ".compose-flags"
    cache.write_text("previous selection", encoding="utf-8")
    monkeypatch.setattr(
        selection.subprocess, "run",
        lambda args, **kwargs: subprocess.CompletedProcess(args, 1, "", "Docker failure"),
    )
    with pytest.raises(selection.SelectionError, match="selection unchanged"):
        selection.run("disable", tmp_path, "search", stop_mode="compose",
                      compose_flags="-f docker-compose.base.yml")
    assert (target / "compose.yaml").is_file()
    assert cache.read_text(encoding="utf-8") == "previous selection"


def test_enable_rechecks_prerequisite_then_preserves_data(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    prerequisite = extension(tmp_path, "search", enabled=False)
    target = extension(tmp_path, "consumer", depends=("search",), enabled=False)
    retained = tmp_path / "data" / "consumer" / "settings.json"
    retained.parent.mkdir()
    retained.write_text("keep", encoding="utf-8")
    cache = tmp_path / ".compose-flags"
    cache.write_text("stale", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="disabled prerequisites: search"):
        selection.run("enable", tmp_path, "consumer")
    assert (target / "compose.yaml.disabled").is_file()
    assert cache.is_file()
    assert selection.run("enable", tmp_path, "search") == "enabled"
    assert (prerequisite / "compose.yaml").is_file()
    assert not cache.exists()
    assert selection.run("enable", tmp_path, "consumer") == "enabled"
    assert (target / "compose.yaml").is_file()
    assert retained.read_text(encoding="utf-8") == "keep"


def test_enable_accepts_same_fragment_and_base_services(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "consumer", enabled=False)
    (target / "compose.yaml.disabled").write_text(
        "services:\n  consumer:\n    image: example:latest\n"
        "    depends_on: [consumer-db, postgres]\n"
        "  consumer-db:\n    image: example:latest\n", encoding="utf-8"
    )
    assert selection.run("enable", tmp_path, "consumer") == "enabled"


def test_enable_core_bypass_does_not_trust_disabled_user_shadow(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "gateway", depends=("llama-server",), enabled=False)
    assert selection.run("enable", tmp_path, "gateway", core_services={"llama-server"}) == "enabled"
    (target / "compose.yaml").rename(target / "compose.yaml.disabled")
    user = tmp_path / "data" / "user-extensions" / "llama-server"
    user.mkdir()
    (user / "compose.yaml.disabled").write_text("services: {}\n", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="disabled prerequisites: llama-server"):
        selection.run("enable", tmp_path, "gateway", core_services={"llama-server"})
    assert (target / "compose.yaml.disabled").is_file()


def test_enable_refuses_disabled_known_compose_dependency(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    extension(tmp_path, "search", enabled=False)
    target = extension(tmp_path, "consumer", compose_depends=("search",), enabled=False)
    with pytest.raises(selection.SelectionError, match="disabled prerequisites: search"):
        selection.run("enable", tmp_path, "consumer")
    assert (target / "compose.yaml.disabled").is_file()


def test_enable_existing_selection_revalidates_and_invalidates_cache(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "consumer", enabled=True)
    cache = tmp_path / ".compose-flags"
    cache.write_text("stale", encoding="utf-8")
    assert selection.run("enable", tmp_path, "consumer") == "already-enabled"
    assert not cache.exists()
    (target / "manifest.yaml").write_text(
        "service:\n  id: consumer\n  depends_on: [search]\n", encoding="utf-8"
    )
    with pytest.raises(selection.SelectionError, match="disabled prerequisites: search"):
        selection.run("enable", tmp_path, "consumer")
    assert (target / "compose.yaml").is_file()


def test_enable_refuses_divergent_dual_markers_without_losing_data(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "consumer")
    enabled = target / "compose.yaml"
    disabled = target / "compose.yaml.disabled"
    disabled.write_text("services:\n  other:\n    image: example:latest\n", encoding="utf-8")
    cache = tmp_path / ".compose-flags"
    cache.write_text("previous selection", encoding="utf-8")

    with pytest.raises(selection.SelectionError, match="Conflicting Compose selection files"):
        selection.run("enable", tmp_path, "consumer")

    assert enabled.is_file()
    assert disabled.is_file()
    assert cache.read_text(encoding="utf-8") == "previous selection"


def test_enable_reports_committed_selection_when_cache_save_fails(tmp_path, monkeypatch, capsys):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "consumer", enabled=False)
    scripts = tmp_path / "scripts"
    scripts.mkdir()
    resolver = scripts / "resolve-compose-stack.sh"
    resolver.write_text("#!/bin/sh\n", encoding="utf-8")
    resolver.chmod(0o755)
    monkeypatch.setattr(selection.shutil, "which", lambda _: "bash")
    monkeypatch.setattr(
        selection.subprocess, "run",
        lambda *args, **kwargs: subprocess.CompletedProcess(
            args=[], returncode=0, stdout="-f docker-compose.base.yml\n", stderr="",
        ),
    )
    original_replace = selection.os.replace

    def fail_cache_replace(source, destination):
        if Path(destination).name == ".compose-flags":
            raise OSError("simulated cache write failure")
        original_replace(source, destination)

    monkeypatch.setattr(selection.os, "replace", fail_cache_replace)

    assert selection.run("enable", tmp_path, "consumer") == "enabled"
    assert (target / "compose.yaml").is_file()
    assert not (target / "compose.yaml.disabled").exists()
    assert not (tmp_path / ".compose-flags").exists()
    assert "WARNING: Cannot save Compose cache" in capsys.readouterr().err


def test_separate_process_lock_blocks_commit_then_releases(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    holder_code = (
        "import importlib.util,sys,time; from pathlib import Path; "
        "s=importlib.util.spec_from_file_location('selection',sys.argv[1]); "
        "m=importlib.util.module_from_spec(s); s.loader.exec_module(m); "
        "lock=m._selection_lock(Path(sys.argv[2]),2); lock.__enter__(); "
        "print('held',flush=True); time.sleep(1); lock.__exit__(None,None,None)"
    )
    holder = subprocess.Popen(
        [sys.executable, "-c", holder_code, str(SCRIPT), str(tmp_path)],
        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
    )
    try:
        assert holder.stdout.readline().strip() == "held"
        with pytest.raises(selection.SelectionError, match="Timed out waiting"):
            selection.run("disable", tmp_path, "search", timeout=0.1)
        assert (target / "compose.yaml").is_file()
    finally:
        stdout, stderr = holder.communicate(timeout=5)
        assert holder.returncode == 0, stderr or stdout
    assert selection.run("disable", tmp_path, "search") == "disabled"


def test_preset_restore_orders_dependents_and_prerequisites(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    search = extension(tmp_path, "search")
    consumer = extension(tmp_path, "consumer", depends=("search",))
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\ndisabled:consumer\n", encoding="utf-8")
    original_replace = selection.os.replace
    moves = []
    monkeypatch.setattr(selection, "_stop_for_disable", lambda *args, **kwargs: None)

    def ordered_replace(source, target):
        moves.append(Path(source).parent.name)
        if Path(source).parent.name == "search" and Path(target).name.endswith("disabled"):
            assert not (consumer / "compose.yaml").exists()
        if Path(source).parent.name == "consumer" and Path(target).name == "compose.yaml":
            assert (search / "compose.yaml").exists()
        original_replace(source, target)

    monkeypatch.setattr(selection.os, "replace", ordered_replace)
    assert restore(tmp_path, preset) == (0, 2, [])
    assert moves == ["consumer", "search"]

    moves.clear()
    preset.write_text("enabled:consumer\nenabled:search\n", encoding="utf-8")
    assert restore(tmp_path, preset) == (2, 0, [])
    assert moves == ["search", "consumer"]


def test_preset_rejects_invalid_final_graph_before_any_rename(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    search = extension(tmp_path, "search")
    consumer = extension(tmp_path, "consumer", compose_depends=("search",))
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\n", encoding="utf-8")
    retained = tmp_path / "data" / "search" / "settings.json"
    retained.parent.mkdir()
    retained.write_text("keep", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="without prerequisites: search"):
        restore(tmp_path, preset)
    assert (search / "compose.yaml").is_file()
    assert (consumer / "compose.yaml").is_file()
    assert retained.read_text(encoding="utf-8") == "keep"


def test_preset_rejects_conflicting_entries_and_user_shadow(tmp_path):
    user_root = tmp_path / "data" / "user-extensions"
    user_root.mkdir(parents=True)
    extension(tmp_path, "search")
    user_search = user_root / "search"
    user_search.mkdir()
    (user_search / "compose.yaml.disabled").write_text("services: {}\n", encoding="utf-8")
    consumer = extension(tmp_path, "consumer", depends=("search",), enabled=False)
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:consumer\ndisabled:consumer\n", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="Conflicting preset states"):
        restore(tmp_path, preset)
    preset.write_text("enabled:consumer\n", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="without prerequisites: search"):
        restore(tmp_path, preset)
    assert (consumer / "compose.yaml.disabled").is_file()
    assert (user_search / "compose.yaml.disabled").is_file()


def test_preset_partial_rename_failure_reports_committed_prefix(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    search = extension(tmp_path, "search")
    consumer = extension(tmp_path, "consumer", depends=("search",))
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\ndisabled:consumer\n", encoding="utf-8")
    cache = tmp_path / ".compose-flags"
    cache.write_text("stale", encoding="utf-8")
    original_replace = selection.os.replace
    monkeypatch.setattr(selection, "_stop_for_disable", lambda *args, **kwargs: None)

    def fail_second(source, target):
        if Path(source).parent.name == "search":
            raise OSError("simulated rename failure")
        original_replace(source, target)

    monkeypatch.setattr(selection.os, "replace", fail_second)
    with pytest.raises(selection.SelectionError, match="after 0 enabled and 1 disabled"):
        restore(tmp_path, preset)
    assert (consumer / "compose.yaml.disabled").is_file()
    assert (search / "compose.yaml").is_file()
    assert not cache.exists()


def test_preset_repairs_invalid_starting_graph_before_enable_start(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    search = extension(tmp_path, "search", enabled=False)
    consumer = extension(tmp_path, "consumer", depends=("search",))
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:consumer\n", encoding="utf-8")
    with pytest.raises(selection.SelectionError, match="without prerequisites: search"):
        restore(tmp_path, preset)
    assert (search / "compose.yaml.disabled").is_file()
    assert (consumer / "compose.yaml").is_file()

    preset.write_text("enabled:search\n", encoding="utf-8")
    assert restore(tmp_path, preset) == (1, 0, [])
    assert (search / "compose.yaml").is_file()
    assert (consumer / "compose.yaml").is_file()


def test_preset_noop_enable_invalidates_stale_compose_cache(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    extension(tmp_path, "search")
    cache = tmp_path / ".compose-flags"
    cache.write_text("stale flags", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:search\n", encoding="utf-8")
    assert restore(tmp_path, preset) == (0, 0, [])
    assert not cache.exists()


def test_cli_preset_skips_host_service_without_compose_marker(tmp_path):
    # OpenCode runs on the host: its directory has a manifest and no Compose
    # file. Presets saved by older CLIs list it as disabled:opencode, and
    # `ods preset load` must still restore the Compose selection. The
    # Dashboard's strict selection keeps refusing an explicit host service.
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    host = tmp_path / "extensions" / "services" / "opencode"
    host.mkdir(parents=True)
    (host / "manifest.yaml").write_text(
        "service:\n  id: opencode\n  type: host-systemd\n", encoding="utf-8"
    )
    search = extension(tmp_path, "search", enabled=False)
    preset = tmp_path / "extensions.list"
    preset.write_text("enabled:search\ndisabled:opencode\n", encoding="utf-8")

    with pytest.raises(selection.SelectionError, match="No Compose selection file for opencode"):
        selection.restore_preset(tmp_path, preset, compose_flags="-f docker-compose.base.yml",
                                 strict=True)
    assert (search / "compose.yaml.disabled").is_file()

    assert restore(tmp_path, preset) == (1, 0, [])
    assert (search / "compose.yaml").is_file()
    assert [path.name for path in host.iterdir()] == ["manifest.yaml"]


def test_preset_rejects_symlink_and_directory_inputs(tmp_path):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\n", encoding="utf-8")
    linked = tmp_path / "linked.list"
    try:
        linked.symlink_to(preset)
    except (OSError, NotImplementedError):
        pass
    else:
        with pytest.raises(selection.SelectionError, match="Invalid preset extensions list"):
            restore(tmp_path, linked)
    cache = tmp_path / ".compose-flags"
    cache.mkdir()
    with pytest.raises(selection.SelectionError, match="Compose cache is a directory"):
        restore(tmp_path, preset)
    assert (target / "compose.yaml").is_file()


def test_preset_stops_every_owned_fragment_service_before_disabling(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    (target / "compose.yaml").write_text(
        "services:\n  search: {}\n  search-db: {}\n", encoding="utf-8",
    )
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\n", encoding="utf-8")
    calls = []

    def stopped_before_rename(command, **kwargs):
        calls.append(command)
        assert (target / "compose.yaml").is_file()
        assert not (target / "compose.yaml.disabled").exists()
        return subprocess.CompletedProcess(command, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", stopped_before_rename)
    assert restore(tmp_path, preset) == (0, 1, [])
    assert calls == [[sys.executable, str(helper), "--install-dir", str(tmp_path),
                      "--preserve-restart-policy",
                      "--service", "search", "--service", "search-db"]]
    assert (target / "compose.yaml.disabled").is_file()


def test_preset_does_not_stop_shared_core_service(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / "docker-compose.base.yml").write_text(
        "services:\n  litellm: {}\n", encoding="utf-8",
    )
    target = extension(tmp_path, "langfuse")
    (target / "compose.yaml").write_text(
        "services:\n  langfuse: {}\n  litellm: {}\n", encoding="utf-8",
    )
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:langfuse\n", encoding="utf-8")
    calls = []

    def record(command, **kwargs):
        calls.append(command)
        return subprocess.CompletedProcess(command, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", record)
    assert restore(tmp_path, preset) == (0, 1, [])
    assert calls == [[sys.executable, str(helper), "--install-dir", str(tmp_path),
                      "--preserve-restart-policy",
                      "--service", "langfuse"]]


def test_preset_stops_local_litellm_despite_inactive_external_overlay(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / "docker-compose.base.yml").write_text(
        "services:\n  dashboard-api: {}\n", encoding="utf-8",
    )
    (tmp_path / "docker-compose.external-llm.yml").write_text(
        "services:\n  litellm: {}\n", encoding="utf-8",
    )
    extension(tmp_path, "litellm")
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:litellm\n", encoding="utf-8")
    calls = []

    def record(command, **kwargs):
        calls.append(command)
        return subprocess.CompletedProcess(command, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", record)
    assert restore(tmp_path, preset) == (0, 1, [])
    assert calls == [[sys.executable, str(helper), "--install-dir", str(tmp_path),
                      "--preserve-restart-policy", "--service", "litellm"]]


def test_preset_refuses_litellm_disable_with_selected_external_overlay(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / "docker-compose.base.yml").write_text("services: {}\n", encoding="utf-8")
    (tmp_path / "docker-compose.external-llm.yml").write_text(
        "services:\n  litellm: {}\n", encoding="utf-8",
    )
    target = extension(tmp_path, "litellm")
    unrelated = extension(tmp_path, "zz-unrelated")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:litellm\ndisabled:zz-unrelated\n", encoding="utf-8")
    monkeypatch.setattr(selection.subprocess, "run", lambda *args, **kwargs: pytest.fail(
        "selected external gateway LiteLLM must not be stopped",
    ))
    with pytest.raises(selection.SelectionError, match="requires litellm"):
        restore(tmp_path, preset, compose_flags=(
            "-f docker-compose.base.yml -f docker-compose.external-llm.yml"
        ))
    assert (target / "compose.yaml").is_file()
    assert (unrelated / "compose.yaml").is_file()


def test_preset_disables_library_service_with_selected_mac_native_overlay(tmp_path, monkeypatch):
    """A valid Compose override must not strand an installed Library service."""
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / "docker-compose.base.yml").write_text("services: {}\n", encoding="utf-8")
    native = tmp_path / "installers" / "macos" / "pixel-native.compose.yaml.disabled"
    native.parent.mkdir(parents=True)
    shipped = SCRIPT.parents[1] / "installers" / "macos" / native.name
    native.write_text(shipped.read_text(encoding="utf-8"), encoding="utf-8")
    target = extension(tmp_path, "cyberchef")
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:cyberchef\n", encoding="utf-8")
    calls = []

    def stopped(command, **_kwargs):
        calls.append(command)
        return subprocess.CompletedProcess(command, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", stopped)
    flags = f"-f docker-compose.base.yml -f {native.relative_to(tmp_path).as_posix()}"
    assert selection.restore_preset(tmp_path, preset, compose_flags=flags, strict=True) == (0, 1, [])
    assert calls == [[sys.executable, str(helper), "--install-dir", str(tmp_path),
                      "--preserve-restart-policy", "--service", "cyberchef"]]
    assert (target / "compose.yaml.disabled").is_file()
    assert not (target / "compose.yaml").exists()


def test_unknown_compose_tag_keeps_library_selection_enabled(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    (tmp_path / "docker-compose.base.yml").write_text("services: {}\n", encoding="utf-8")
    native = tmp_path / "installers" / "macos" / "pixel-native.compose.yaml.disabled"
    native.parent.mkdir(parents=True)
    native.write_text("services:\n  pixel-native-ingress:\n    volumes: !unknown [x]\n",
                      encoding="utf-8")
    target = extension(tmp_path, "cyberchef")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:cyberchef\n", encoding="utf-8")
    monkeypatch.setattr(selection.subprocess, "run", lambda *_a, **_k: pytest.fail(
        "unknown tags must be refused before stopping a service"))
    with pytest.raises(selection.SelectionError, match="Cannot inspect selected file"):
        selection.restore_preset(
            tmp_path, preset,
            compose_flags=f"-f docker-compose.base.yml -f {native.relative_to(tmp_path).as_posix()}",
            strict=True,
        )
    assert (target / "compose.yaml").is_file()


def test_preset_stops_shared_service_only_after_last_overlay_is_disabled(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    for service_id in ("first", "second"):
        target = extension(tmp_path, service_id)
        (target / "compose.yaml").write_text(
            f"services:\n  {service_id}: {{}}\n  shared: {{}}\n", encoding="utf-8",
        )
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:first\ndisabled:second\n", encoding="utf-8")
    calls = []

    def record(command, **kwargs):
        calls.append(command)
        return subprocess.CompletedProcess(command, 0, "", "")

    monkeypatch.setattr(selection.subprocess, "run", record)
    assert restore(tmp_path, preset) == (0, 2, [])
    assert calls == [
        [sys.executable, str(helper), "--install-dir", str(tmp_path),
         "--preserve-restart-policy",
         "--service", "second"],
        [sys.executable, str(helper), "--install-dir", str(tmp_path),
         "--preserve-restart-policy",
         "--service", "first", "--service", "shared"],
    ]


def test_preset_stop_failure_keeps_marker_enabled(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "search")
    helper = tmp_path / "scripts" / "stop-owned-containers.py"
    helper.parent.mkdir()
    helper.write_text("", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:search\n", encoding="utf-8")
    monkeypatch.setattr(
        selection.subprocess, "run",
        lambda command, **kwargs: subprocess.CompletedProcess(command, 1, "", "stop refused"),
    )
    with pytest.raises(selection.SelectionError, match="Could not confirm stop for search"):
        restore(tmp_path, preset)
    assert (target / "compose.yaml").is_file()


def test_preset_empty_fragment_never_issues_unfiltered_stop(tmp_path, monkeypatch):
    (tmp_path / "data" / "user-extensions").mkdir(parents=True)
    target = extension(tmp_path, "empty")
    (target / "compose.yaml").write_text("services: {}\n", encoding="utf-8")
    preset = tmp_path / "extensions.list"
    preset.write_text("disabled:empty\n", encoding="utf-8")
    monkeypatch.setattr(selection.subprocess, "run", lambda *args, **kwargs: pytest.fail(
        "empty fragment must not invoke an unfiltered owned-container stop",
    ))
    assert restore(tmp_path, preset) == (0, 1, [])
    assert (target / "compose.yaml.disabled").is_file()