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.

18.2 KB
Raw Blame
"""Tests for the HTTP scoped-generation surface.

Covers the ``/api/repos/{id}/generate`` + ``/generate/estimate`` endpoints, the
``generate`` job mode in the executor (the shared core engine), the D1 launch fix
on the regenerate endpoint, and the D3 wiring on the incremental sync path.
"""

from __future__ import annotations

import json
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest
from httpx import AsyncClient

from repowise.core.generation.cascade import build_page_dependencies
from repowise.core.generation.page_selection import PageRecord, PageSelectionIntent
from repowise.core.persistence import crud
from repowise.core.persistence.database import get_session
from repowise.core.pipeline.scoped_generation import RehydratedRepo, ScopedGenerationResult
from repowise.server.job_executor import _build_generate_intent
from tests.unit.server.conftest import create_test_repo

# ---------------------------------------------------------------------------
# _build_generate_intent
# ---------------------------------------------------------------------------


@pytest.mark.parametrize(
    ("config", "expected"),
    [
        ({"selection": {"kind": "all"}}, PageSelectionIntent(all_pages=True)),
        ({"selection": {"kind": "unwritten"}}, PageSelectionIntent(unwritten=True)),
        ({"selection": {"kind": "stale"}}, PageSelectionIntent(stale=True)),
        (
            {"selection": {"kind": "page_ids", "page_ids": ["file_page:a.py"]}},
            PageSelectionIntent(page_ids=("file_page:a.py",)),
        ),
        (
            {"selection": {"kind": "path_prefix", "path_prefix": "src/"}},
            PageSelectionIntent(path_globs=("src/",)),
        ),
        ({}, PageSelectionIntent(unwritten=True)),
        (
            {"mode": "single_page", "page_id": "file_page:a.py"},
            PageSelectionIntent(page_ids=("file_page:a.py",)),
        ),
        # Ranked short-circuits resolve_scope via the seed, so the intent is empty.
        ({"selection": {"kind": "ranked", "coverage_pct": 0.2}}, PageSelectionIntent()),
    ],
)
def test_build_generate_intent(config: dict, expected: PageSelectionIntent) -> None:
    assert _build_generate_intent(config) == expected


# ---------------------------------------------------------------------------
# cascade + ranked-coverage helpers
# ---------------------------------------------------------------------------


@pytest.mark.parametrize(
    ("config", "expected"),
    [
        ({"cascade": "full"}, "full"),  # explicit always wins
        ({"selection": {"kind": "ranked", "coverage_pct": 0.2}}, "none"),
        ({"mode": "single_page"}, "none"),
        ({"selection": {"kind": "unwritten"}}, "dependents"),
        ({}, "dependents"),
        # Explicit cascade wins even for a ranked selection.
        ({"selection": {"kind": "ranked", "top_n": 5}, "cascade": "dependents"}, "dependents"),
    ],
)
def test_effective_cascade(config: dict, expected: str) -> None:
    from repowise.server.job_executor import _effective_cascade

    assert _effective_cascade(config) == expected


@pytest.mark.parametrize(
    ("selection", "n_files", "expected"),
    [
        ({"coverage_pct": 0.3}, 100, 0.3),  # coverage_pct passes through
        ({"top_n": 5}, 100, 0.05),  # top_n maps to n / n_files
        ({"top_n": 500}, 100, 1.0),  # clamped to 1.0
        ({}, 100, 0.0),  # neither set (guarded upstream) is a no-op fraction
    ],
)
def test_ranked_coverage_pct(selection: dict, n_files: int, expected: float) -> None:
    from repowise.server.job_executor import _ranked_coverage_pct

    assert _ranked_coverage_pct(selection, n_files) == pytest.approx(expected)


# ---------------------------------------------------------------------------
# POST /generate + /generate/estimate endpoints
# ---------------------------------------------------------------------------


async def _job_config(session_factory, job_id: str) -> dict:
    async with get_session(session_factory) as session:
        job = await crud.get_generation_job(session, job_id)
        return json.loads(job.config_json) if job.config_json else {}


@pytest.mark.asyncio
async def test_generate_endpoint_creates_and_launches_job(client: AsyncClient, app) -> None:
    repo = await create_test_repo(client)
    with patch("repowise.server.routers.repos._launch_job_task") as launch:
        resp = await client.post(
            f"/api/repos/{repo['id']}/generate",
            json={"selection": {"kind": "unwritten"}, "cascade": "dependents"},
        )
    assert resp.status_code == 202
    job_id = resp.json()["job_id"]
    launch.assert_called_once()

    cfg = await _job_config(app.state.session_factory, job_id)
    assert cfg["mode"] == "generate"
    assert cfg["selection"] == {"kind": "unwritten"}
    assert cfg["cascade"] == "dependents"


@pytest.mark.asyncio
async def test_generate_endpoint_page_ids_selection(client: AsyncClient, app) -> None:
    repo = await create_test_repo(client)
    with patch("repowise.server.routers.repos._launch_job_task"):
        resp = await client.post(
            f"/api/repos/{repo['id']}/generate",
            json={
                "selection": {"kind": "page_ids", "page_ids": ["module_page:src/foo"]},
                "cascade": "none",
                "style": "caveman",
            },
        )
    assert resp.status_code == 202
    cfg = await _job_config(app.state.session_factory, resp.json()["job_id"])
    assert cfg["selection"] == {"kind": "page_ids", "page_ids": ["module_page:src/foo"]}
    assert cfg["style"] == "caveman"


@pytest.mark.asyncio
async def test_generate_endpoint_rejects_structural_page_id(client: AsyncClient) -> None:
    """generate writes the concept layer only, so a structural page id is a clear
    error rather than a silent no-op re-render of a template."""
    repo = await create_test_repo(client)
    resp = await client.post(
        f"/api/repos/{repo['id']}/generate",
        json={"selection": {"kind": "page_ids", "page_ids": ["file_page:a.py"]}},
    )
    assert resp.status_code == 400
    assert "file_page:a.py" in resp.json()["detail"]


@pytest.mark.asyncio
async def test_generate_endpoint_ranked_selection(client: AsyncClient, app) -> None:
    """A ranked coverage selection is carried into the job config."""
    repo = await create_test_repo(client)
    with patch("repowise.server.routers.repos._launch_job_task"):
        resp = await client.post(
            f"/api/repos/{repo['id']}/generate",
            json={"selection": {"kind": "ranked", "coverage_pct": 0.2}, "cascade": "none"},
        )
    assert resp.status_code == 202
    cfg = await _job_config(app.state.session_factory, resp.json()["job_id"])
    assert cfg["selection"] == {"kind": "ranked", "coverage_pct": 0.2}
    assert cfg["cascade"] == "none"


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("selection", "needle"),
    [
        # Ranked needs exactly one sizing knob.
        ({"kind": "ranked"}, "exactly one"),
        ({"kind": "ranked", "coverage_pct": 0.2, "top_n": 5}, "exactly one"),
        # Out-of-range coverage / non-positive top_n.
        ({"kind": "ranked", "coverage_pct": 1.5}, "fraction"),
        ({"kind": "ranked", "coverage_pct": 0}, "fraction"),
        ({"kind": "ranked", "top_n": 0}, "positive"),
        # Ranked cannot also carry explicit page selectors.
        ({"kind": "ranked", "coverage_pct": 0.2, "page_ids": ["file_page:a.py"]}, "page_ids"),
        # coverage_pct / top_n only belong to a ranked selection.
        ({"kind": "unwritten", "coverage_pct": 0.2}, "ranked"),
        ({"kind": "all", "top_n": 5}, "ranked"),
    ],
)
async def test_generate_endpoint_rejects_bad_ranked(
    client: AsyncClient, selection: dict, needle: str
) -> None:
    repo = await create_test_repo(client)
    resp = await client.post(f"/api/repos/{repo['id']}/generate", json={"selection": selection})
    assert resp.status_code == 400, resp.text
    assert needle in resp.json()["detail"].lower()


@pytest.mark.asyncio
async def test_generate_endpoint_rejects_unknown_style(client: AsyncClient) -> None:
    repo = await create_test_repo(client)
    resp = await client.post(
        f"/api/repos/{repo['id']}/generate",
        json={"selection": {"kind": "all"}, "style": "bogus"},
    )
    assert resp.status_code == 400
    assert "style" in resp.json()["detail"].lower()


@pytest.mark.asyncio
async def test_generate_endpoint_404_unknown_repo(client: AsyncClient) -> None:
    resp = await client.post("/api/repos/nope/generate", json={})
    assert resp.status_code == 404


@pytest.mark.asyncio
async def test_generate_endpoint_409_when_job_active(client: AsyncClient, app) -> None:
    repo = await create_test_repo(client)
    async with get_session(app.state.session_factory) as session:
        await crud.upsert_generation_job(
            session, repository_id=repo["id"], status="running", config={"mode": "sync"}
        )
        await session.commit()
    resp = await client.post(f"/api/repos/{repo['id']}/generate", json={})
    assert resp.status_code == 409


@pytest.mark.asyncio
async def test_generate_estimate_no_pages(client: AsyncClient) -> None:
    """A repo with no wiki pages returns a zero estimate, not a crash."""
    repo = await create_test_repo(client)
    with patch(
        "repowise.server.provider_config.get_chat_provider_instance",
        side_effect=RuntimeError("no provider"),
    ):
        resp = await client.post(
            f"/api/repos/{repo['id']}/generate/estimate",
            json={"selection": {"kind": "unwritten"}},
        )
    assert resp.status_code == 200, resp.text
    body = resp.json()
    assert body["total_pages"] == 0
    assert body["estimate"] is None
    assert body["provider"]["error"] is not None


@pytest.mark.asyncio
async def test_generate_estimate_prices_a_provider_override(client: AsyncClient) -> None:
    """``?provider=`` prices a provider the repo has not chosen yet."""
    repo = await create_test_repo(client)
    llm = SimpleNamespace(provider_name="anthropic", model_name="claude-haiku-4-5")
    with patch(
        "repowise.server.provider_config.get_chat_provider_instance", return_value=llm
    ) as build:
        resp = await client.post(
            f"/api/repos/{repo['id']}/generate/estimate?provider=anthropic",
            json={"selection": {"kind": "unwritten"}},
        )
    assert resp.status_code == 200, resp.text
    assert build.call_args.kwargs["provider_override"] == "anthropic"
    assert resp.json()["provider"] == {
        "name": "anthropic",
        "model": "claude-haiku-4-5",
        "error": None,
    }


# ---------------------------------------------------------------------------
# generate job execution (shared core engine)
# ---------------------------------------------------------------------------


def _fake_rehydrated(template_ids: list[str]) -> RehydratedRepo:
    records = [
        PageRecord(
            page_id=pid,
            page_type=pid.split(":", 1)[0],
            target_path=pid.split(":", 1)[1],
            is_template=True,
            freshness_status="fresh",
        )
        for pid in template_ids
    ]
    deps = build_page_dependencies(
        module_groups=[], scc_groups=[], repo_wide_ids=[]
    )
    return RehydratedRepo(
        graph_builder=MagicMock(),
        git_meta_map={},
        parsed_files=[],
        source_map={},
        repo_structure=MagicMock(),
        records=records,
        kg_ctx=MagicMock(available=False),
        deps=deps,
        repo_name="test-repo",
    )


async def _seed_generate_job(session_factory, repo_path: Path, config: dict) -> str:
    async with session_factory() as session:
        repo = await crud.upsert_repository(session, name="test-repo", local_path=str(repo_path))
        job = await crud.upsert_generation_job(session, repository_id=repo.id, config=config)
        await session.commit()
        return job.id


@pytest.mark.asyncio
async def test_generate_job_runs_scoped_engine(session_factory, tmp_path) -> None:
    """A generate job resolves the scope and drives the shared core engine."""
    from repowise.server.job_executor import execute_job

    (tmp_path / ".git").mkdir()
    job_id = await _seed_generate_job(
        session_factory,
        tmp_path,
        {"mode": "generate", "selection": {"kind": "unwritten"}, "cascade": "none"},
    )
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    # generate writes the concept layer, so the resolved plan is model-written
    # ids; the scope helper narrows structural ids out.
    template_ids = ["module_page:a", "module_page:b"]
    written = SimpleNamespace(
        page_id="module_page:a", title="a", content="x", input_tokens=10, output_tokens=20
    )
    execute_mock = AsyncMock(
        return_value=ScopedGenerationResult(generated_pages=[written], marked_stale=0)
    )
    with (
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            return_value=MagicMock(provider_name="openai", model_name="gpt"),
        ),
        patch(
            "repowise.server.search_helpers.resolve_repo_vector_store",
            AsyncMock(return_value=None),
        ),
        patch(
            "repowise.core.pipeline.scoped_generation.rehydrate_repo",
            AsyncMock(return_value=_fake_rehydrated(template_ids)),
        ),
        patch(
            "repowise.core.pipeline.scoped_generation.execute_scoped_generation",
            execute_mock,
        ),
    ):
        await execute_job(job_id, app_state)

    execute_mock.assert_awaited_once()
    plan = execute_mock.await_args.kwargs["plan"]
    assert plan.generate_ids == set(template_ids)

    async with get_session(session_factory) as session:
        job = await crud.get_generation_job(session, job_id)
        assert job.status == "completed"
        cfg = json.loads(job.config_json)
        assert cfg["pages_generated"] == 1


def test_resolve_generate_scope_ranked_uses_build_ranked_seed() -> None:
    """A ranked config resolves through build_ranked_seed, so the estimate and
    the job (both callers of this one helper) plan the identical page set."""
    from repowise.server.job_executor import _resolve_generate_scope

    template_ids = ["module_page:a", "module_page:b", "module_page:c"]
    rehydrated = _fake_rehydrated(template_ids)
    # A non-empty parsed_files so top_n mapping (if used) has a denominator.
    rehydrated.parsed_files = [SimpleNamespace(path=f"{p}.py") for p in "abc"]
    seed = {"module_page:a"}

    config = {"selection": {"kind": "ranked", "coverage_pct": 0.2}, "cascade": "none"}
    gen_config = SimpleNamespace(coverage_pct=0.2, max_pages_pct=0.2, deterministic=False)
    with patch("repowise.core.generation.scope.build_ranked_seed", return_value=seed) as ranked:
        plan = _resolve_generate_scope(config, rehydrated, gen_config)

    ranked.assert_called_once()
    assert ranked.call_args.kwargs["coverage_pct"] == pytest.approx(0.2)
    assert ranked.call_args.kwargs["repo_name"] == "test-repo"
    # Cascade none + empty deps: the plan is exactly the ranked seed, nothing
    # invented and nothing dropped (the estimate's page count == the job's).
    assert plan.generate_ids == seed


def test_resolve_generate_scope_explicit_skips_ranked_seed() -> None:
    """An explicit selection never builds a ranked seed."""
    from repowise.server.job_executor import _resolve_generate_scope

    rehydrated = _fake_rehydrated(["module_page:a", "module_page:b"])
    config = {"selection": {"kind": "unwritten"}, "cascade": "none"}
    gen_config = SimpleNamespace(coverage_pct=0.2, max_pages_pct=0.2, deterministic=False)
    with patch("repowise.core.generation.scope.build_ranked_seed") as ranked:
        plan = _resolve_generate_scope(config, rehydrated, gen_config)

    ranked.assert_not_called()
    assert plan.generate_ids == {"module_page:a", "module_page:b"}


@pytest.mark.asyncio
async def test_generate_job_fails_without_provider(session_factory, tmp_path) -> None:
    from repowise.server.job_executor import execute_job

    (tmp_path / ".git").mkdir()
    job_id = await _seed_generate_job(
        session_factory, tmp_path, {"mode": "generate", "selection": {"kind": "all"}}
    )
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    with (
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
        patch(
            "repowise.server.search_helpers.resolve_repo_vector_store",
            AsyncMock(return_value=None),
        ),
    ):
        await execute_job(job_id, app_state)

    async with get_session(session_factory) as session:
        job = await crud.get_generation_job(session, job_id)
        assert job.status == "failed"


# ---------------------------------------------------------------------------
# D3: incremental sync hands the regen a vector store + prior pages
# ---------------------------------------------------------------------------


@pytest.mark.asyncio
async def test_sync_regen_receives_vector_store_and_prior_pages(session_factory, tmp_path) -> None:
    from repowise.server.job_executor import execute_job

    (tmp_path / ".git").mkdir()
    job_id = await _seed_generate_job(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    fake_result = SimpleNamespace(generated_pages=[], parsed_files=[], file_count=1, symbol_count=1)
    regen_mock = AsyncMock(return_value=[])
    with (
        patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=fake_result)),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock(return_value=[])),
        patch("repowise.server.job_executor._incremental_page_regen", regen_mock),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            return_value=MagicMock(provider_name="openai", model_name="gpt"),
        ),
        patch(
            "repowise.server.search_helpers.resolve_repo_vector_store",
            AsyncMock(return_value=None),
        ),
    ):
        await execute_job(job_id, app_state)

    regen_mock.assert_awaited_once()
    assert "vector_store" in regen_mock.await_args.kwargs
    assert "prior_pages" in regen_mock.await_args.kwargs