Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
"""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