flow/tests/test_service_bootstrap.py

"""Tests for BootstrapService."""

import pytest

from flow.core.config import AppConfig, FlowContext
from flow.core.console import Console
from flow.core.errors import FlowError
from flow.core.platform import PlatformInfo
from flow.core.runtime import SystemRuntime
from flow.services.bootstrap import BootstrapService


def _make_ctx(manifest=None):
    return FlowContext(
        config=AppConfig(),
        manifest=manifest or {},
        platform=PlatformInfo(),
        console=Console(color=False),
        runtime=SystemRuntime(),
    )


class TestBootstrapService:
    def test_show_profile(self, capsys):
        manifest = {
            "profiles": {
                "work": {
                    "os": "linux",
                    "hostname": "dev",
                    "packages": ["fd"],
                },
            },
            "packages": [{"name": "fd", "type": "pkg"}],
        }
        ctx = _make_ctx(manifest)
        svc = BootstrapService(ctx)
        svc.show("work")
        output = capsys.readouterr().out
        assert "work" in output

    def test_unknown_profile_raises(self):
        ctx = _make_ctx({"profiles": {}})
        svc = BootstrapService(ctx)
        with pytest.raises(FlowError, match="Unknown profile"):
            svc.run("missing")

    def test_list_profiles(self, capsys):
        manifest = {
            "profiles": {
                "work": {"os": "linux", "hostname": "dev"},
                "personal": {"os": "linux"},
            },
        }
        ctx = _make_ctx(manifest)
        svc = BootstrapService(ctx)
        svc.list_profiles()
        output = capsys.readouterr().out
        assert "work" in output
        assert "personal" in output

    def test_list_profiles_empty(self, capsys):
        ctx = _make_ctx({})
        svc = BootstrapService(ctx)
        svc.list_profiles()
        assert "No profiles" in capsys.readouterr().out

    def test_run_preserves_profile_package_overrides(self, monkeypatch):
        captured = {}

        class StubPackageService:
            def __init__(self, ctx):
                pass

            def install(self, packages, *, dry_run=False):
                captured["packages"] = packages

        monkeypatch.setattr("flow.services.packages.PackageService", StubPackageService)
        monkeypatch.setattr("flow.services.dotfiles.DotfilesService.link", lambda self, profile=None: None)

        manifest = {
            "profiles": {
                "linux-auto": {
                    "os": "linux",
                    "packages": [{
                        "name": "docker",
                        "post-install": "sudo groupadd docker || true",
                    }],
                },
            },
            "packages": [{"name": "docker", "type": "pkg", "sources": {"apt": "docker-ce"}}],
        }
        ctx = _make_ctx(manifest)
        BootstrapService(ctx).run("linux-auto")

        assert captured["packages"][0].post_install == "sudo groupadd docker || true"

    def test_unknown_phase_raises(self):
        from flow.domain.bootstrap.models import BootstrapAction, BootstrapPlan
        from flow.domain.bootstrap.models import VALID_PHASES

        manifest = {"profiles": {"work": {"os": "linux"}}}
        ctx = _make_ctx(manifest)
        svc = BootstrapService(ctx)
        # Forge an action with a phase that VALID_PHASES contains but the
        # dispatch can't handle (shouldn't happen, but tests the explicit guard).
        # Use a phase NOT in VALID_PHASES first to confirm the "Unknown" branch.
        action = BootstrapAction.__new__(BootstrapAction)
        object.__setattr__(action, "phase", "no-such-phase")
        object.__setattr__(action, "description", "")
        object.__setattr__(action, "commands", ())
        object.__setattr__(action, "needs_sudo", False)
        plan = BootstrapPlan(profile="work", actions=(), packages_to_install=())
        with pytest.raises(FlowError, match="Unknown bootstrap phase"):
            svc._execute_action(action, plan, "work")

    def test_run_uses_dotfiles_profile_override(self, monkeypatch):
        captured = {}

        monkeypatch.setattr("flow.services.packages.PackageService.install", lambda self, packages, dry_run=False: None)

        class StubDotfilesService:
            def __init__(self, ctx):
                pass

            def link(self, profile=None):
                captured["profile"] = profile

        monkeypatch.setattr("flow.services.dotfiles.DotfilesService", StubDotfilesService)

        manifest = {
            "profiles": {
                "linux-auto": {
                    "os": "linux",
                    "dotfiles-profile": "linux-work",
                },
            },
        }
        ctx = _make_ctx(manifest)
        BootstrapService(ctx).run("linux-auto")
        assert captured["profile"] == "linux-work"