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
"""Integration tests for --mode fast and pipeline checkpointing.
Runs the real pipeline against the sample repo (no LLM, no external services)
to prove:
* FAST mode skips doc generation and the co-change walk (ESSENTIAL git tier);
* a supplied JobStore receives a COMPLETED record for each major phase;
* an interrupted phase (left RUNNING) is excluded from the resume set.
"""
from __future__ import annotations
from datetime import UTC, datetime
from pathlib import Path
from repowise.core.persistence._interfaces.job_store import JobRecord, JobState
from repowise.core.pipeline import run_pipeline
from repowise.core.pipeline.checkpoint import find_completed_phases
from repowise.core.pipeline.modes import OrchestratorMode
class _FakeJobStore:
def __init__(self) -> None:
self.jobs: dict[str, JobRecord] = {}
self._seq = 0
async def create_job(self, *, repository_id, phase, metadata=None) -> JobRecord:
self._seq += 1
jid = f"job{self._seq}"
now = datetime.now(UTC)
rec = JobRecord(
jid, repository_id, phase, JobState.PENDING, None, now, now, None, metadata or {}
)
self.jobs[jid] = rec
return rec
async def update_state(self, job_id, state, *, cursor=None, error=None) -> JobRecord:
old = self.jobs[job_id]
rec = JobRecord(
old.id, old.repository_id, old.phase, state, cursor or old.cursor,
old.started_at, datetime.now(UTC), error, old.metadata,
)
self.jobs[job_id] = rec
return rec
async def list_jobs(self, *, repository_id=None, phase=None, state=None, limit=100):
# Honour every filter SqlJobStore applies: callers push predicates down
# to the store, so a double that ignores them hides real bugs.
matches = [
j
for j in self.jobs.values()
if (repository_id is None or j.repository_id == repository_id)
and (phase is None or j.phase == phase)
and (state is None or j.state == state)
]
return matches[:limit]
async def test_fast_mode_skips_generation_and_co_change(sample_repo_copy: Path) -> None:
store = _FakeJobStore()
result = await run_pipeline(
sample_repo_copy,
generate_docs=True, # FAST must override this to False (no LLM client passed)
mode=OrchestratorMode.FAST,
job_store=store,
)
# No LLM generation happened.
assert result.generated_pages is None
# ESSENTIAL git tier: per-file metadata exists but no co-change partners.
assert result.git_metadata_list, "expected git metadata for sample repo"
for meta in result.git_metadata_list:
assert meta.get("co_change_partners_json", "[]") == "[]"
async def test_checkpoints_recorded_for_completed_phases(sample_repo_copy: Path) -> None:
store = _FakeJobStore()
await run_pipeline(
sample_repo_copy,
mode=OrchestratorMode.FAST,
job_store=store,
)
completed = await find_completed_phases(store, str(Path(sample_repo_copy).resolve()))
# parse + git always run; both should be recorded COMPLETED.
assert "parse" in completed
assert "git" in completed
# Every recorded job reached a terminal COMPLETED state on the success path.
assert all(j.state == JobState.COMPLETED for j in store.jobs.values())
async def test_interrupted_phase_excluded_from_resume_set() -> None:
store = _FakeJobStore()
j = await store.create_job(repository_id="r", phase="generation")
await store.update_state(j.id, JobState.RUNNING) # simulate a crash mid-phase
completed = await find_completed_phases(store, "r")
assert "generation" not in completed