Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

6.6 KB
Raw Blame
"""Unit tests for the ``repowise generate`` scope/cascade resolution."""

from __future__ import annotations

from dataclasses import dataclass

from repowise.cli.commands.generate_cmd.scope import (
    _ranked_ids_to_seed,
    build_cost_plans,
    load_page_records,
    resolve_scope,
    selection_page_ids,
)
from repowise.core.generation.cascade import build_page_dependencies
from repowise.core.generation.models import compute_page_id
from repowise.core.generation.page_selection import PageRecord, PageSelectionIntent


@dataclass
class _Row:
    """Duck-typed persisted Page row."""

    id: str
    page_type: str
    target_path: str
    provider_name: str
    freshness_status: str = "fresh"
    metadata_json: str = "{}"


def test_load_page_records_flags_templates_by_provider_or_metadata() -> None:
    rows = [
        _Row("file_page:a.py", "file_page", "a.py", "template"),
        _Row("file_page:b.py", "file_page", "b.py", "openai"),
        _Row(
            "file_page:c.py",
            "file_page",
            "c.py",
            "openai",
            metadata_json='{"deterministic": true}',
        ),
    ]
    records = load_page_records(rows)
    by_id = {r.page_id: r for r in records}
    assert by_id["file_page:a.py"].is_template is True
    assert by_id["file_page:b.py"].is_template is False
    # deterministic metadata still marks it template even with a real provider.
    assert by_id["file_page:c.py"].is_template is True


def test_build_cost_plans_groups_by_type_and_orders_by_level() -> None:
    ids = {
        "file_page:a.py",
        "file_page:b.py",
        "repo_overview:demo",
        "module_page:src",
    }
    plans = build_cost_plans(ids)
    counts = {p.page_type: p.count for p in plans}
    assert counts == {"file_page": 2, "module_page": 1, "repo_overview": 1}
    # Ordered by generation level (file_page=2 < module_page=4 < repo_overview=6).
    assert [p.page_type for p in plans] == ["file_page", "module_page", "repo_overview"]


def test_resolve_scope_unwritten_with_cascade_none() -> None:
    rows = [
        _Row("file_page:src/a.py", "file_page", "src/a.py", "template"),
        _Row("file_page:src/b.py", "file_page", "src/b.py", "openai"),
        _Row("module_page:src", "module_page", "src", "template"),
        _Row("repo_overview:demo", "repo_overview", "demo", "template"),
    ]
    records = load_page_records(rows)

    @dataclass(frozen=True)
    class _MG:
        key: str
        file_paths: tuple[str, ...]

    deps = build_page_dependencies(
        module_groups=[_MG("src", ("src/a.py", "src/b.py"))],
        scc_groups=[],
        repo_wide_ids=("repo_overview:demo",),
    )
    plan = resolve_scope(
        records=records,
        intent=PageSelectionIntent(unwritten=True),
        cascade_mode="none",
        deps=deps,
    )
    # Seeds are the model-written template pages: module_page:src and
    # repo_overview:demo. a.py is a structural page, so it is never "unwritten".
    assert plan.generate_ids == {
        "module_page:src",
        "repo_overview:demo",
    }
    # No file page is seeded, so nothing is marked stale.
    assert plan.stale_ids == set()
    assert plan.seed_count == 2


class _FakeGroup:
    """Duck-typed selection ``ModuleGroup``."""

    def __init__(self, key: str) -> None:
        self.key = key


class _FakeSelection:
    """Minimal duck-typed :class:`Selection` for ``selection_page_ids``."""

    def __init__(self) -> None:
        self.file_page_paths = ["src/a.py", "src/b.py"]
        self.module_groups = [_FakeGroup("src")]
        self.scc_groups = [("cycle-1", ["src/a.py", "src/b.py"])]
        self.api_contract_paths = ["openapi.yaml"]
        self.infra_paths = ["Dockerfile"]
        self.symbol_spotlights = [("src/a.py", "Widget")]
        self.emit_repo_overview = True


def test_selection_page_ids_mirrors_generation_id_assignment() -> None:
    ids = selection_page_ids(_FakeSelection(), "demo")
    assert ids == {
        compute_page_id("file_page", "src/a.py"),
        compute_page_id("file_page", "src/b.py"),
        compute_page_id("module_page", "src"),
        compute_page_id("scc_page", "cycle-1"),
        compute_page_id("api_contract", "openapi.yaml"),
        compute_page_id("infra_page", "Dockerfile"),
        compute_page_id("symbol_spotlight", "src/a.py::Widget"),
        compute_page_id("repo_overview", "demo"),
    }


def test_selection_page_ids_honors_emit_flags() -> None:
    sel = _FakeSelection()
    sel.emit_repo_overview = False
    ids = selection_page_ids(sel, "demo")
    assert compute_page_id("repo_overview", "demo") not in ids


def test_ranked_ids_to_seed_keeps_unwritten_and_adds_structural() -> None:
    records = [
        PageRecord("file_page:a.py", "file_page", "a.py", is_template=True),
        PageRecord("file_page:b.py", "file_page", "b.py", is_template=False),
        PageRecord("layer_page:core", "layer_page", "core", is_template=True),
        PageRecord("onboarding:tour", "onboarding", "tour", is_template=True),
        PageRecord("onboarding:map", "onboarding", "map", is_template=False),
    ]
    # Ranked picks both file pages; the written one (b.py) must drop, and the
    # unwritten onboarding page must be pulled in even though the ranked set
    # never named it.
    #
    # The stored layer page is unwritten too, and stays out: layer pages are
    # retired, so seeding one would ask generation for a page it will not
    # produce and the run would report it missing every time.
    seed = _ranked_ids_to_seed({"file_page:a.py", "file_page:b.py"}, records)
    assert seed == {"file_page:a.py", "onboarding:tour"}


def test_ranked_ids_to_seed_drops_ids_with_no_page() -> None:
    # A ranked id for a file added since indexing has no page row; it is dropped
    # rather than fabricated (generate only rewrites existing pages).
    records = [PageRecord("file_page:a.py", "file_page", "a.py", is_template=True)]
    seed = _ranked_ids_to_seed({"file_page:a.py", "file_page:new.py"}, records)
    assert seed == {"file_page:a.py"}


def test_resolve_scope_uses_ranked_seed_verbatim() -> None:
    records = [
        PageRecord("file_page:a.py", "file_page", "a.py", is_template=True),
        PageRecord("file_page:b.py", "file_page", "b.py", is_template=True),
    ]
    deps = build_page_dependencies(module_groups=[], scc_groups=[], repo_wide_ids=())
    # An all-selecting intent would pick both; the ranked seed overrides it.
    plan = resolve_scope(
        records=records,
        intent=PageSelectionIntent(all_pages=True),
        cascade_mode="none",
        deps=deps,
        ranked_seed={"file_page:a.py"},
    )
    assert plan.generate_ids == {"file_page:a.py"}
    assert plan.seed_count == 1
    assert plan.unknown_page_ids == ()