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 background job executor's exclude-pattern handling.
Server-triggered jobs (web sync, full-resync, workspace sync, webhooks,
scheduler) all route through ``execute_job``. These tests prove that the
repository's ``exclude_patterns`` reach ``run_pipeline`` so excluded paths
are not re-indexed.
"""
from __future__ import annotations
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from repowise.core.persistence.crud import (
get_generation_job,
update_job_status,
upsert_generation_job,
upsert_repository,
)
from repowise.server.job_executor import (
JobProgressCallback,
_build_generation_config,
_incremental_page_regen,
_plan_incremental_page_regen,
_repo_exclude_patterns,
execute_job,
)
def _fake_result() -> SimpleNamespace:
"""Minimal stand-in for a PipelineResult (persist is mocked out)."""
return SimpleNamespace(
generated_pages=[],
parsed_files=[],
file_count=1,
symbol_count=2,
)
async def _seed_repo_and_job(
session_factory,
repo_path,
*,
settings: dict | None = None,
) -> str:
"""Insert a repo (with settings) + a pending full_resync job; return job_id."""
async with session_factory() as session:
repo = await upsert_repository(
session,
name="test-repo",
local_path=str(repo_path),
settings=settings or {},
)
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={"mode": "full_resync"},
)
await session.commit()
return job.id
@pytest.mark.asyncio
async def test_execute_job_passes_exclude_patterns_from_settings(session_factory, tmp_path):
"""settings_json exclude_patterns must reach run_pipeline."""
job_id = await _seed_repo_and_job(
session_factory,
tmp_path,
settings={"exclude_patterns": ["tools/", "node_modules/"]},
)
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
),
):
await execute_job(job_id, app_state)
run_pipeline_mock.assert_awaited_once()
assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] == [
"tools/",
"node_modules/",
]
@pytest.mark.asyncio
async def test_execute_job_no_excludes_passes_none(session_factory, tmp_path):
"""With no configured excludes, run_pipeline receives None (not [])."""
job_id = await _seed_repo_and_job(session_factory, tmp_path, settings={})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
),
):
await execute_job(job_id, app_state)
run_pipeline_mock.assert_awaited_once()
assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] is None
def test_repo_exclude_patterns_config_yaml_wins_over_stored(tmp_path):
"""config.yaml is the one source; a legacy DB copy cannot re-add a removed pattern."""
import json
config_dir = tmp_path / ".repowise"
config_dir.mkdir()
(config_dir / "config.yaml").write_text(
"exclude_patterns:\n - node_modules/\n - vendor/\n - vendor/\n", encoding="utf-8"
)
repo = SimpleNamespace(
settings_json=json.dumps({"exclude_patterns": ["tools/", "node_modules/"]})
)
assert _repo_exclude_patterns(repo, str(tmp_path)) == ["node_modules/", "vendor/"]
def test_repo_exclude_patterns_legacy_stored_value_applies_without_config(tmp_path):
"""A repo whose patterns predate config.yaml keeps them until a save moves them."""
import json
repo = SimpleNamespace(settings_json=json.dumps({"exclude_patterns": ["tools/"]}))
assert _repo_exclude_patterns(repo, str(tmp_path)) == ["tools/"]
def test_repo_exclude_patterns_ignores_malformed_sources(tmp_path):
"""Malformed settings_json / missing config are ignored, not fatal."""
repo = SimpleNamespace(settings_json="{not valid json")
assert _repo_exclude_patterns(repo, str(tmp_path)) == []
@pytest.mark.asyncio
async def test_execute_job_passes_wiki_style_from_settings(session_factory, tmp_path):
"""The repo's settings wiki_style must reach run_pipeline."""
job_id = await _seed_repo_and_job(
session_factory,
tmp_path,
settings={"wiki_style": "caveman"},
)
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
),
):
await execute_job(job_id, app_state)
run_pipeline_mock.assert_awaited_once()
assert run_pipeline_mock.await_args.kwargs["wiki_style"] == "caveman"
def test_repo_wiki_style_config_yaml_precedence(tmp_path):
""".repowise/config.yaml wins over a legacy DB copy for wiki_style."""
import json
from repowise.server.job_executor import _repo_wiki_style
config_dir = tmp_path / ".repowise"
config_dir.mkdir()
(config_dir / "config.yaml").write_text("wiki_style: reference\n", encoding="utf-8")
repo = SimpleNamespace(settings_json=json.dumps({"wiki_style": "caveman"}))
assert _repo_wiki_style(repo, str(tmp_path)) == "reference"
def test_repo_wiki_style_falls_back_to_config(tmp_path):
"""With no DB setting, the config.yaml style is used."""
from repowise.server.job_executor import _repo_wiki_style
config_dir = tmp_path / ".repowise"
config_dir.mkdir()
(config_dir / "config.yaml").write_text("wiki_style: tutorial\n", encoding="utf-8")
repo = SimpleNamespace(settings_json="{}")
assert _repo_wiki_style(repo, str(tmp_path)) == "tutorial"
def test_repo_wiki_style_defaults_and_tolerates_bad_input(tmp_path):
"""Unknown / missing / malformed style resolves to the comprehensive default."""
from repowise.server.job_executor import _repo_wiki_style
assert _repo_wiki_style(SimpleNamespace(settings_json="{}"), str(tmp_path)) == "comprehensive"
assert (
_repo_wiki_style(SimpleNamespace(settings_json='{"wiki_style": "nope"}'), str(tmp_path))
== "comprehensive"
)
assert (
_repo_wiki_style(SimpleNamespace(settings_json="{bad json"), str(tmp_path))
== "comprehensive"
)
def test_server_generation_config_reads_repo_output_limit(tmp_path):
config_dir = tmp_path / ".repowise"
config_dir.mkdir()
(config_dir / "config.yaml").write_text("max_tokens: 2468\n", encoding="utf-8")
config = _build_generation_config(tmp_path, {}, "comprehensive")
assert config.max_tokens == 2468
@pytest.mark.asyncio
async def test_execute_job_merges_config_yaml_excludes(session_factory, tmp_path):
"""End-to-end regression: the real user case (tools/ excluded).
Repo settings carry ``exclude_patterns: ["tools/"]``; the job path must
forward exactly that to run_pipeline so ``tools/`` is never re-indexed.
"""
job_id = await _seed_repo_and_job(
session_factory,
tmp_path,
settings={"exclude_patterns": ["tools/"]},
)
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
),
):
await execute_job(job_id, app_state)
run_pipeline_mock.assert_awaited_once()
assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] == ["tools/"]
@pytest.mark.asyncio
async def test_execute_job_uses_repository_vector_store(session_factory, tmp_path):
"""A workspace job must not write vectors to the global primary store."""
job_id = await _seed_repo_and_job(session_factory, tmp_path)
primary_store = object()
repo_store = MagicMock()
app_state = SimpleNamespace(
session_factory=session_factory,
fts=None,
vector_store=primary_store,
)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
resolve_store = AsyncMock(return_value=repo_store)
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.search_helpers.resolve_repo_vector_store",
resolve_store,
),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
),
):
await execute_job(job_id, app_state)
resolve_store.assert_awaited_once()
assert resolve_store.await_args.args[0] is app_state
assert resolve_store.await_args.kwargs == {
"repo_path": str(tmp_path),
"create": True,
}
assert run_pipeline_mock.await_args.kwargs["vector_store"] is repo_store
@pytest.mark.asyncio
async def test_incremental_page_regen_passes_repo_path(tmp_path):
"""Incremental regen must forward repo_path to generate_all.
Without it, generate_all can't load the curated knowledge-graph.json
artifact and silently falls back to community module grouping, which
overwrites curated module pages with the wrong ids.
"""
repo_path = tmp_path
repowise_dir = repo_path / ".repowise"
repowise_dir.mkdir()
(repowise_dir / "state.json").write_text('{"last_sync_commit": "base-sha"}', encoding="utf-8")
result = SimpleNamespace(
file_count=10,
parsed_files=[],
source_map={},
graph_builder=SimpleNamespace(graph=lambda: object(), pagerank=lambda: {}),
repo_structure=object(),
repo_name="test-repo",
git_meta_map={},
)
# Stub git HEAD lookup to a sha != base so regen proceeds.
head_proc = SimpleNamespace(returncode=0, stdout="head-sha\n")
# Detector reports one changed/affected file so generation runs.
detector = MagicMock()
detector.get_changed_files.return_value = [object()]
affected = SimpleNamespace(regenerate=["foo.py"])
detector.get_affected_pages.return_value = affected
generator = MagicMock()
generator.generate_all = AsyncMock(return_value=[])
with (
patch("subprocess.run", return_value=head_proc),
patch(
"repowise.core.ingestion.ChangeDetector",
return_value=detector,
),
patch(
"repowise.core.ingestion.change_detector.compute_adaptive_budget",
return_value=5,
),
patch("repowise.core.generation.PageGenerator", return_value=generator),
patch("repowise.core.generation.ContextAssembler"),
patch("repowise.core.generation.GenerationConfig"),
patch("repowise.core.reasoning.resolve_reasoning", return_value="low"),
patch("repowise.core.repo_config.load_repo_config", return_value={}),
):
await _incremental_page_regen(
Path(repo_path),
result,
llm_client=object(),
job_config={},
progress=None,
)
generator.generate_all.assert_awaited_once()
assert generator.generate_all.await_args.kwargs["repo_path"] == Path(repo_path)
@pytest.mark.asyncio
async def test_incremental_page_regen_offloads_change_detection(session_factory, tmp_path):
"""Async stale lookup feeds the offloaded Git and graph planning unit."""
result = SimpleNamespace()
to_thread = AsyncMock(return_value=None)
stale_pages = {"foo.py": 123.0}
with (
patch("repowise.server.job_executor.asyncio.to_thread", to_thread),
patch(
"repowise.core.persistence.get_stale_file_page_ages",
AsyncMock(return_value=stale_pages),
),
):
pages = await _incremental_page_regen(
tmp_path,
result,
llm_client=object(),
job_config={"before": "base-sha"},
progress=None,
session_factory=session_factory,
repo_id="repo-id",
)
assert pages == []
to_thread.assert_awaited_once_with(
_plan_incremental_page_regen,
tmp_path,
result,
{"before": "base-sha"},
stale_pages,
)
@pytest.mark.asyncio
async def test_incremental_page_regen_sets_file_pages_only(tmp_path):
"""A server sync must scope generation to file pages (the D4 fix).
``_incremental_page_regen`` feeds generate_all a parsed_files filtered to
the changed files. Without ``file_pages_only=True`` on the GenerationConfig,
levels 3+ would rewrite the codebase map, module and overview pages from a
one-commit view. This asserts the config the PageGenerator receives carries
the flag, so repo-wide pages are left untouched on a partial sync.
"""
repo_path = tmp_path
repowise_dir = repo_path / ".repowise"
repowise_dir.mkdir()
(repowise_dir / "state.json").write_text('{"last_sync_commit": "base-sha"}', encoding="utf-8")
result = SimpleNamespace(
file_count=10,
parsed_files=[],
source_map={},
graph_builder=SimpleNamespace(graph=lambda: object(), pagerank=lambda: {}),
repo_structure=object(),
repo_name="test-repo",
git_meta_map={},
)
head_proc = SimpleNamespace(returncode=0, stdout="head-sha\n")
detector = MagicMock()
detector.get_changed_files.return_value = [object()]
detector.get_affected_pages.return_value = SimpleNamespace(regenerate=["foo.py"])
generator = MagicMock()
generator.generate_all = AsyncMock(return_value=[])
page_generator_cls = MagicMock(return_value=generator)
# GenerationConfig is left unpatched so we inspect the real one.
with (
patch("subprocess.run", return_value=head_proc),
patch("repowise.core.ingestion.ChangeDetector", return_value=detector),
patch(
"repowise.core.ingestion.change_detector.compute_adaptive_budget",
return_value=5,
),
patch("repowise.core.generation.PageGenerator", page_generator_cls),
patch("repowise.core.generation.ContextAssembler"),
patch("repowise.core.reasoning.resolve_reasoning", return_value="low"),
patch("repowise.core.repo_config.load_repo_config", return_value={}),
):
await _incremental_page_regen(
Path(repo_path),
result,
llm_client=object(),
job_config={},
progress=None,
)
# PageGenerator(llm_client, assembler, generation_config, ...)
generation_config = page_generator_cls.call_args.args[2]
assert generation_config.file_pages_only is True
# ---------------------------------------------------------------------------
# Deterministic template wiki on a keyless initial index (Part B)
# ---------------------------------------------------------------------------
async def _seed_job_with_config(session_factory, repo_path, config: dict) -> str:
"""Insert a repo + a pending job carrying ``config``; return the job id."""
async with session_factory() as session:
repo = await upsert_repository(
session, name="test-repo", local_path=str(repo_path), settings={}
)
job = await upsert_generation_job(session, repository_id=repo.id, config=config)
await session.commit()
return job.id
def _no_provider():
return patch(
"repowise.server.provider_config.get_chat_provider_instance",
side_effect=RuntimeError("no provider"),
)
@pytest.mark.asyncio
async def test_initial_index_without_provider_renders_deterministic_wiki(session_factory, tmp_path):
"""A keyless first index renders a template wiki instead of nothing.
Without a provider, the pipeline runs in DETERMINISTIC mode (it supplies its
own null TemplateProvider), so the repo gets a complete, upgradable template
wiki rather than an empty index that reads as blank in the web UI.
"""
from repowise.core.pipeline.modes import OrchestratorMode
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_executor._persist_initial_index_state"),
_no_provider(),
):
await execute_job(job_id, app_state)
kwargs = run_pipeline_mock.await_args.kwargs
assert kwargs["mode"] == OrchestratorMode.DETERMINISTIC
assert kwargs["generate_docs"] is True
assert kwargs["llm_client"] is None
@pytest.mark.asyncio
async def test_initial_index_without_provider_writes_deterministic_docs_mode(
session_factory, tmp_path
):
"""The persisted docs mode is 'deterministic' on a keyless first index."""
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
persist_state = MagicMock()
with (
patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
_no_provider(),
):
await execute_job(job_id, app_state)
persist_state.assert_called_once()
assert persist_state.call_args.kwargs["docs_mode"] == "deterministic"
assert persist_state.call_args.kwargs["llm_client"] is None
@pytest.mark.asyncio
async def test_initial_index_with_provider_uses_llm_mode(session_factory, tmp_path):
"""With a provider, a first index writes model docs ('llm'), STANDARD mode."""
from repowise.core.pipeline.modes import OrchestratorMode
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
provider = SimpleNamespace(provider_name="openai", model_name="gpt-x")
run_pipeline_mock = AsyncMock(return_value=_fake_result())
persist_state = MagicMock()
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
return_value=provider,
),
):
await execute_job(job_id, app_state)
assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
assert run_pipeline_mock.await_args.kwargs["generate_docs"] is True
assert persist_state.call_args.kwargs["docs_mode"] == "llm"
@pytest.mark.asyncio
async def test_initial_index_no_provider_generate_docs_false_writes_none(session_factory, tmp_path):
"""An explicit generate_docs=False keyless index generates nothing ('none')."""
from repowise.core.pipeline.modes import OrchestratorMode
job_id = await _seed_job_with_config(
session_factory, tmp_path, {"mode": "initial_index", "generate_docs": False}
)
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
persist_state = MagicMock()
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
_no_provider(),
):
await execute_job(job_id, app_state)
assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
assert persist_state.call_args.kwargs["docs_mode"] == "none"
@pytest.mark.asyncio
async def test_full_resync_without_provider_stays_index_only(session_factory, tmp_path):
"""A keyless full_resync must NOT template-overwrite an existing wiki.
The deterministic fallback is scoped to initial_index; a keyless full_resync
keeps its index-only behaviour so it can never replace a model-written wiki
with templates.
"""
from repowise.core.pipeline.modes import OrchestratorMode
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "full_resync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
_no_provider(),
):
await execute_job(job_id, app_state)
assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
@pytest.mark.asyncio
async def test_index_only_job_does_not_generate_docs(session_factory, tmp_path):
"""The cheap index_only analysis refresh never renders a wiki."""
from repowise.core.pipeline.modes import OrchestratorMode
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "index_only"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
_no_provider(),
):
await execute_job(job_id, app_state)
assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
@pytest.mark.asyncio
async def test_execute_job_fails_on_unknown_mode(session_factory, tmp_path):
"""An unrecognized job mode explicitly fails the job rather than running partial work."""
from repowise.core.persistence.crud import get_generation_job
async with session_factory() as session:
repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={"mode": "incremental"},
)
await session.commit()
job_id = job.id
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
):
await execute_job(job_id, app_state)
# Pipeline should not run when mode is invalid
run_pipeline_mock.assert_not_called()
# Job status should be recorded as failed in the DB with clear error message
async with session_factory() as session:
updated_job = await get_generation_job(session, job_id)
assert updated_job is not None
assert updated_job.status == "failed"
assert "Invalid job mode 'incremental'" in (updated_job.error_message or "")
@pytest.mark.asyncio
async def test_execute_job_defaults_to_sync_when_mode_absent(session_factory, tmp_path):
"""A missing mode key (config={}) defaults to 'sync' and proceeds without failing."""
async with session_factory() as session:
repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={},
)
await session.commit()
job_id = job.id
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
get_provider_mock,
),
):
await execute_job(job_id, app_state)
# Pipeline must have run
run_pipeline_mock.assert_awaited_once()
# Provider lookup was attempted — proves fallback is "sync", not "index_only"
get_provider_mock.assert_called_once()
@pytest.mark.asyncio
async def test_execute_job_defaults_to_sync_when_mode_empty_string(session_factory, tmp_path):
"""An explicit empty-string mode also defaults to 'sync' via the `or` fallback."""
async with session_factory() as session:
repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={"mode": ""},
)
await session.commit()
job_id = job.id
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
get_provider_mock,
),
):
await execute_job(job_id, app_state)
# Pipeline must have run
run_pipeline_mock.assert_awaited_once()
get_provider_mock.assert_called_once()
@pytest.mark.asyncio
async def test_execute_job_resolves_the_provider_the_ui_picked_for_this_repo(
session_factory, tmp_path
):
"""The dashboard's provider picker persists its choice per repo, keyed by
repo id. Resolving on path alone skipped that entry -- the most specific
step in the resolver, and the only one carrying a deliberate user decision
-- so a repo whose settings named a provider still indexed with whatever
auto-detection guessed from the server's own environment.
"""
async with session_factory() as session:
repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={"mode": "sync"},
)
await session.commit()
job_id, repo_id = job.id, repo.id
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
with (
patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
get_provider_mock,
),
):
await execute_job(job_id, app_state)
get_provider_mock.assert_called_once()
assert get_provider_mock.call_args.kwargs.get("repo_id") == repo_id
@pytest.mark.asyncio
async def test_execute_job_dispatches_generate_mode(session_factory, tmp_path):
"""A job with mode='generate' passes validation and dispatches to _run_generate_job."""
async with session_factory() as session:
repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
job = await upsert_generation_job(
session,
repository_id=repo.id,
config={"mode": "generate"},
)
await session.commit()
job_id = job.id
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_generate_mock = AsyncMock()
with (
patch("repowise.server.job_executor._run_generate_job", run_generate_mock),
patch(
"repowise.server.provider_config.get_chat_provider_instance",
MagicMock(return_value=MagicMock()),
),
):
await execute_job(job_id, app_state)
run_generate_mock.assert_awaited_once()
@pytest.mark.asyncio
async def test_phase_start_with_unknown_total_clears_stale_denominator(session_factory, tmp_path):
"""A phase that starts with total=None must zero out a previous phase's
total_pages, not leave the record pairing a fresh numerator with a
denominator that describes different work (issue #2175)."""
job_id = await _seed_repo_and_job(session_factory, tmp_path)
async with session_factory() as session:
await update_job_status(session, job_id, "running", completed_pages=241, total_pages=5)
await session.commit()
callback = JobProgressCallback(job_id, session_factory)
callback.on_phase_start("generation", None)
await callback.drain_and_stop()
async with session_factory() as session:
job = await get_generation_job(session, job_id)
assert job.total_pages == 0
assert job.completed_pages == 0
@pytest.mark.asyncio
async def test_update_job_status_without_total_pages_preserves_existing_value(
session_factory, tmp_path
):
"""Callers that omit total_pages (None) must keep the record's existing
total unchanged, distinct from JobProgressCallback explicitly zeroing it
for an unknown-total phase."""
job_id = await _seed_repo_and_job(session_factory, tmp_path)
async with session_factory() as session:
await update_job_status(session, job_id, "running", completed_pages=241, total_pages=5)
await session.commit()
async with session_factory() as session:
await update_job_status(session, job_id, "running", completed_pages=250)
await session.commit()
async with session_factory() as session:
job = await get_generation_job(session, job_id)
assert job.total_pages == 5
assert job.completed_pages == 250
# ---------------------------------------------------------------------------
# Update lock and analyzer stamp: a server job never overwrites newer health
# ---------------------------------------------------------------------------
def _write_state(repo_path: Path, state: dict) -> None:
import json
path = repo_path / ".repowise" / "state.json"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(state), encoding="utf-8")
async def _job_row(session_factory, job_id: str):
async with session_factory() as session:
return await get_generation_job(session, job_id)
@pytest.mark.asyncio
async def test_sync_job_holds_the_update_lock_and_stamps_its_analyzer(session_factory, tmp_path):
import json
from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION
from repowise.core.update_lock import read_update_lock
_write_state(tmp_path, {"last_sync_commit": "old", "health_analyzer_version": 1})
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
held_during_run: list = []
async def pipeline(*_a, **_k):
held_during_run.append(read_update_lock(tmp_path))
return SimpleNamespace(**vars(_fake_result()), health_report=object())
with (
patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_state._read_head_sha", return_value="new"),
_no_provider(),
):
await execute_job(job_id, app_state)
assert (await _job_row(session_factory, job_id)).status == "completed"
assert held_during_run[0] is not None
assert read_update_lock(tmp_path) is None
state = json.loads((tmp_path / ".repowise" / "state.json").read_text(encoding="utf-8"))
assert state["health_analyzer_version"] == HEALTH_ANALYZER_VERSION
assert state["last_sync_commit"] == "new"
@pytest.mark.asyncio
async def test_sync_job_does_not_run_while_a_cli_update_holds_the_lock(session_factory, tmp_path):
from repowise.core.update_lock import (
read_update_lock,
release_update_lock,
try_acquire_update_lock,
)
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
assert try_acquire_update_lock(tmp_path, "cli-target") is None
run_pipeline_mock = AsyncMock(return_value=_fake_result())
try:
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
_no_provider(),
):
await execute_job(job_id, app_state)
# The CLI's lock is left in place for its owner.
assert read_update_lock(tmp_path)["target_commit"] == "cli-target"
finally:
release_update_lock(tmp_path)
run_pipeline_mock.assert_not_called()
job = await _job_row(session_factory, job_id)
assert job.status == "cancelled"
assert "Another repowise update" in job.error_message
@pytest.mark.asyncio
async def test_older_server_never_overwrites_newer_health_rows(session_factory, tmp_path):
from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION
from repowise.core.update_lock import read_update_lock
_write_state(tmp_path, {"health_analyzer_version": HEALTH_ANALYZER_VERSION + 1})
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
run_pipeline_mock = AsyncMock(return_value=_fake_result())
persist = AsyncMock()
with (
patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
patch("repowise.server.job_executor.persist_pipeline_result", persist),
_no_provider(),
):
await execute_job(job_id, app_state)
run_pipeline_mock.assert_not_called()
persist.assert_not_called()
job = await _job_row(session_factory, job_id)
assert job.status == "failed"
assert f"analyzer version {HEALTH_ANALYZER_VERSION + 1}" in job.error_message
assert read_update_lock(tmp_path) is None
@pytest.mark.asyncio
async def test_newer_stamp_written_during_the_run_blocks_the_persist(session_factory, tmp_path):
from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "full_resync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
async def pipeline(*_a, **_k):
_write_state(tmp_path, {"health_analyzer_version": HEALTH_ANALYZER_VERSION + 1})
return _fake_result()
persist = AsyncMock()
with (
patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
patch("repowise.server.job_executor.persist_pipeline_result", persist),
_no_provider(),
):
await execute_job(job_id, app_state)
persist.assert_not_called()
assert (await _job_row(session_factory, job_id)).status == "failed"
@pytest.mark.asyncio
async def test_cancelled_sync_job_releases_the_update_lock(session_factory, tmp_path):
import asyncio
from repowise.core.update_lock import read_update_lock
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
started = asyncio.Event()
async def pipeline(*_a, **_k):
started.set()
await asyncio.sleep(60)
with (
patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
_no_provider(),
):
task = asyncio.create_task(execute_job(job_id, app_state))
await asyncio.wait_for(started.wait(), 30)
assert read_update_lock(tmp_path) is not None
task.cancel()
await task
assert read_update_lock(tmp_path) is None
assert (await _job_row(session_factory, job_id)).status == "cancelled"
@pytest.mark.asyncio
async def test_sync_job_without_a_health_report_keeps_the_stored_stamp(session_factory, tmp_path):
import json
_write_state(tmp_path, {"health_analyzer_version": 1})
job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
with (
patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
patch("repowise.server.job_state._read_head_sha", return_value="new"),
_no_provider(),
):
await execute_job(job_id, app_state)
state = json.loads((tmp_path / ".repowise" / "state.json").read_text(encoding="utf-8"))
assert state["health_analyzer_version"] == 1