src/tests/test_council_runner.py

"""
test_council_runner.py -- Regression tests for council_runner.

Covers:
- Scope resolution: explicit / full / diff / graph-blast / dynamic.
- Plan hashing stability across invocations.
- Dedup cache: "cached" policy reuses, "fresh" always regenerates.
- Persistence + history listing.
- Atomic write on persist_plan survives a simulated crash.
"""

from __future__ import annotations

import json
import time
from pathlib import Path

import pytest

import council_runner as cr
import toolbox_config as tc


@pytest.fixture()
def tmp_runs(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
    """Redirect RUNS_DIR to a tmp folder."""
    runs = tmp_path / "toolbox-runs"
    monkeypatch.setattr(cr, "RUNS_DIR", runs)
    return runs


@pytest.fixture()
def seeded_tset(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    """Global config has one toolbox; per-repo config absent."""
    tset = tc.ToolboxSet(
        toolboxes={
            "ship-it": tc.Toolbox(
                name="ship-it",
                description="test",
                post=("code-reviewer", "security-reviewer"),
                scope=tc.Scope(analysis="diff"),
                dedup=tc.Dedup(window_seconds=600, policy="cached"),
            ),
            "fresh-box": tc.Toolbox(
                name="fresh-box",
                post=("code-reviewer",),
                scope=tc.Scope(analysis="full"),
                dedup=tc.Dedup(window_seconds=60, policy="fresh"),
            ),
        },
        active=("ship-it",),
    )
    g_path = tmp_path / "global.json"
    tc.save_global(tset, g_path)
    monkeypatch.setattr(tc, "global_config_path", lambda: g_path)
    return tset


def test_scope_explicit_wins(seeded_tset):
    tb = seeded_tset.toolboxes["ship-it"]
    files, mode = cr.resolve_scope(
        tb, repo_root=Path.cwd(), explicit_files=["x.py", "y.py", "x.py"]
    )
    assert files == ["x.py", "y.py"]
    assert mode == "explicit"


def test_scope_full_without_git_returns_empty(seeded_tset, tmp_path: Path):
    tb = seeded_tset.toolboxes["fresh-box"]
    files, mode = cr.resolve_scope(tb, repo_root=tmp_path)
    assert mode == "full"
    assert files == []  # not a git repo


def test_scope_graph_blast_expands_one_hop():
    edges = {"a.py": {"b.py", "c.py"}, "b.py": {"d.py"}}
    # Explicit files path doesn't use edges, so test helper directly
    result = cr._graph_blast_files(["a.py"], edges)
    assert result == ["a.py", "b.py", "c.py"]
    result2 = cr._graph_blast_files(["a.py", "b.py"], edges)
    assert "d.py" in result2


def test_scope_dynamic_falls_back_to_full_when_no_diff(seeded_tset, tmp_path):
    tb = tc.Toolbox(
        name="t", post=("x",),
        scope=tc.Scope(analysis="dynamic"),
    )
    files, mode = cr.resolve_scope(tb, repo_root=tmp_path)
    assert mode == "dynamic:full"


def test_hash_plan_is_stable():
    h1 = cr._hash_plan("ship-it", ("a", "b"), ("x.py",), "diff")
    h2 = cr._hash_plan("ship-it", ("a", "b"), ("x.py",), "diff")
    assert h1 == h2
    h3 = cr._hash_plan("ship-it", ("a", "b"), ("x.py",), "full")
    assert h3 != h1


def test_build_plan_persists_and_dedups(seeded_tset, tmp_runs, monkeypatch):
    # Force resolve_scope to return a known set so we don't depend on git
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "diff"),
    )
    plan1 = cr.build_plan("ship-it", now=1000.0)
    assert plan1.source == "fresh"
    cr.persist_plan(plan1)

    # Same inputs => cached lookup returns the persisted plan
    plan2 = cr.build_plan("ship-it", now=1050.0)
    assert plan2.source == "cached"
    assert plan2.plan_hash == plan1.plan_hash
    # created_at reflects the ORIGINAL plan, not the new call
    assert plan2.created_at == 1000.0


def test_build_plan_cache_expires_outside_window(seeded_tset, tmp_runs, monkeypatch):
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "diff"),
    )
    plan1 = cr.build_plan("ship-it", now=1000.0)
    cr.persist_plan(plan1)
    # window is 600s; ask 700s later
    real_time = cr.time.time
    monkeypatch.setattr(cr.time, "time", lambda: 1700.0)
    plan2 = cr.build_plan("ship-it")
    assert plan2.source == "fresh"
    monkeypatch.setattr(cr.time, "time", real_time)


def test_fresh_policy_never_caches(seeded_tset, tmp_runs, monkeypatch):
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "full"),
    )
    # fresh-box has policy="fresh" \u2014 should never return cached
    plan1 = cr.build_plan("fresh-box", now=1000.0)
    cr.persist_plan(plan1)
    plan2 = cr.build_plan("fresh-box", now=1010.0)
    assert plan2.source == "fresh"


def test_unknown_toolbox_raises(seeded_tset):
    with pytest.raises(KeyError):
        cr.build_plan("does-not-exist")


def test_persist_plan_atomic_on_crash(seeded_tset, tmp_runs, monkeypatch):
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "diff"),
    )
    plan = cr.build_plan("ship-it", now=1000.0)
    # Pre-existing good plan
    persisted = cr.persist_plan(plan)
    original = persisted.read_bytes()

    def boom(*a, **kw):
        raise OSError("simulated")

    monkeypatch.setattr("os.replace", boom)
    with pytest.raises(OSError):
        cr.persist_plan(plan)

    assert persisted.read_bytes() == original


def test_cmd_history_filters_by_toolbox(seeded_tset, tmp_runs, monkeypatch, capsys):
    # Persist two plans for different toolboxes
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "diff"),
    )
    p1 = cr.build_plan("ship-it", now=1000.0)
    cr.persist_plan(p1)
    monkeypatch.setattr(
        cr, "resolve_scope",
        lambda tb, repo_root, explicit_files=None, graph_edges=None: (["a.py"], "full"),
    )
    p2 = cr.build_plan("fresh-box", now=2000.0)
    cr.persist_plan(p2)

    # History of ship-it only shows p1
    assert cr.main(["history", "--toolbox", "ship-it", "--limit", "10"]) == 0
    out = capsys.readouterr().out
    entries = json.loads(out)
    assert len(entries) == 1
    assert entries[0]["toolbox"] == "ship-it"


def test_cmd_purge_removes_old_and_corrupt(tmp_runs, capsys):
    tmp_runs.mkdir(parents=True, exist_ok=True)
    old = tmp_runs / "old.json"
    old.write_text(json.dumps({"toolbox": "x", "created_at": 0}), encoding="utf-8")
    corrupt = tmp_runs / "corrupt.json"
    corrupt.write_text("not json", encoding="utf-8")
    fresh = tmp_runs / "fresh.json"
    fresh.write_text(
        json.dumps({"toolbox": "y", "created_at": time.time()}),
        encoding="utf-8",
    )

    assert cr.main(["purge", "--older-than-days", "1"]) == 0
    assert not old.exists()
    assert not corrupt.exists()
    assert fresh.exists()