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
"""Smoke + characterization tests for the shared CLI helper modules.
These guard the extraction of provider/store/state helpers out of ``init_cmd`` /
``update_cmd``: they assert the command modules route through the single shared
implementation (no divergent copies) and pin the behavior of the pure helpers.
"""
from __future__ import annotations
import types
from typing import ClassVar
import pytest
from repowise.cli import _repo_session, _setup, providers, state_persistence
from repowise.cli.commands import init_cmd, update_cmd
def test_command_modules_import() -> None:
"""Both command modules import cleanly with the helpers in place."""
assert isinstance(init_cmd, types.ModuleType)
assert isinstance(update_cmd, types.ModuleType)
def test_helpers_are_single_source() -> None:
"""The private aliases on ``init_cmd`` point at the shared implementations.
Sibling commands (update/reindex/search) import ``_resolve_embedder`` /
``_build_embedder`` from ``init_cmd``; these must remain the same objects as
the canonical ``providers`` helpers so there's exactly one implementation.
"""
assert init_cmd._resolve_embedder is providers.resolve_embedder
assert init_cmd._build_embedder is providers.build_embedder
def test_resolve_embedder_explicit_flag_wins(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("GEMINI_API_KEY", "x")
assert providers.resolve_embedder("openai") == "openai"
@pytest.mark.parametrize(
("env", "expected"),
[
({"GEMINI_API_KEY": "x"}, "gemini"),
({"GOOGLE_API_KEY": "x"}, "gemini"),
({"OPENAI_API_KEY": "x"}, "openai"),
({"OPENROUTER_API_KEY": "x"}, "openrouter"),
({"OLLAMA_BASE_URL": "http://localhost:11434"}, "mock"),
({"OLLAMA_EMBEDDING_MODEL": "embeddinggemma"}, "ollama"),
({"EDENAI_API_KEY": "x"}, "edenai"),
({"OLLAMA_EMBEDDING_MODEL": "embeddinggemma", "EDENAI_API_KEY": "x"}, "ollama"),
({"REPOWISE_EMBEDDER": "ollama"}, "ollama"),
({}, "mock"),
],
)
def test_resolve_embedder_env_detection(
monkeypatch: pytest.MonkeyPatch, env: dict[str, str], expected: str
) -> None:
for key in (
"GEMINI_API_KEY",
"GOOGLE_API_KEY",
"OPENAI_API_KEY",
"OPENROUTER_API_KEY",
"OLLAMA_BASE_URL",
"OLLAMA_EMBEDDING_MODEL",
"EDENAI_API_KEY",
"REPOWISE_EMBEDDER",
):
monkeypatch.delenv(key, raising=False)
for key, val in env.items():
monkeypatch.setenv(key, val)
assert providers.resolve_embedder(None) == expected
def test_build_embedder_falls_back_to_mock() -> None:
"""Unknown / unavailable backends degrade to the deterministic mock."""
from repowise.core.providers.embedding.base import MockEmbedder
assert isinstance(providers.build_embedder("definitely-not-a-backend"), MockEmbedder)
assert isinstance(providers.build_embedder("mock"), MockEmbedder)
def test_build_embedder_supports_ollama(monkeypatch: pytest.MonkeyPatch) -> None:
from repowise.core.providers.embedding.ollama import OllamaEmbedder
monkeypatch.setenv("OLLAMA_EMBEDDING_MODEL", "qwen3-embedding:0.6b")
embedder = providers.build_embedder("ollama")
assert isinstance(embedder, OllamaEmbedder)
assert embedder._model == "qwen3-embedding:0.6b"
def test_build_embedder_ollama_timeout_from_env(monkeypatch: pytest.MonkeyPatch) -> None:
from repowise.core.providers.embedding.ollama import OllamaEmbedder
monkeypatch.setenv("OLLAMA_EMBEDDING_MODEL", "qwen3-embedding:0.6b")
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "300")
embedder = providers.build_embedder("ollama")
assert isinstance(embedder, OllamaEmbedder)
assert embedder._timeout == 300.0
def test_build_vector_store_returns_a_store(tmp_path) -> None:
from repowise.core.providers.embedding.base import MockEmbedder
store = providers.build_vector_store(tmp_path, MockEmbedder())
assert store is not None
# LanceDB (when installed) creates its dir under .repowise/lancedb.
assert store is not None
class _FakeKG:
nodes: ClassVar[list[dict[str, str]]] = [{"summary": "s"}, {"summary": ""}]
layers: ClassVar[list[int]] = [1, 2, 3]
tour: ClassVar[list[int]] = [1, 2]
fingerprint = "abc123"
def to_dict(self) -> dict:
return {"nodes": self.nodes, "fingerprint": self.fingerprint}
def test_build_kg_state_shape() -> None:
state = state_persistence.build_kg_state(_FakeKG())
assert state == {
"version": "1.0.0",
"node_count": 2,
"layer_count": 3,
"tour_steps": 2,
"has_summaries": True,
"fingerprint": "abc123",
}
def test_build_kg_state_missing_attrs() -> None:
state = state_persistence.build_kg_state(object())
assert state == {
"version": "1.0.0",
"node_count": 0,
"layer_count": 0,
"tour_steps": 0,
"has_summaries": False,
"fingerprint": "",
}
def test_save_knowledge_graph_json_writes_file(tmp_path) -> None:
import json
state_persistence.save_knowledge_graph_json(tmp_path, _FakeKG())
out = tmp_path / ".repowise" / "knowledge-graph.json"
assert out.exists()
assert json.loads(out.read_text(encoding="utf-8"))["fingerprint"] == "abc123"
def test_save_knowledge_graph_json_noop_without_to_dict(tmp_path) -> None:
state_persistence.save_knowledge_graph_json(tmp_path, object())
assert not (tmp_path / ".repowise" / "knowledge-graph.json").exists()
def test_setup_logging_silence_runs() -> None:
import logging
_setup.setup_logging_silence()
assert logging.getLogger("httpx").level == logging.ERROR
assert logging.getLogger("httpcore").level == logging.ERROR
def test_configure_cli_logging_quiet_by_default() -> None:
import logging
prior = {n: logging.getLogger(n).level for n in ("repowise.core", "repowise.server")}
try:
_setup.configure_cli_logging(verbose=False)
assert logging.getLogger("repowise.core").level == logging.ERROR
assert logging.getLogger("repowise.server").level == logging.ERROR
# HTTP libs stay quiet regardless of verbosity.
assert logging.getLogger("httpx").level == logging.ERROR
finally:
for name, level in prior.items():
logging.getLogger(name).setLevel(level)
def test_configure_cli_logging_verbose_shows_repowise_debug() -> None:
import logging
prior = {n: logging.getLogger(n).level for n in ("repowise.core", "repowise.server")}
try:
_setup.configure_cli_logging(verbose=True)
assert logging.getLogger("repowise.core").level == logging.DEBUG
assert logging.getLogger("repowise.server").level == logging.DEBUG
# HTTP libs are HTTP-level noise; kept at ERROR even in verbose mode.
assert logging.getLogger("httpx").level == logging.ERROR
assert logging.getLogger("httpcore").level == logging.ERROR
finally:
for name, level in prior.items():
logging.getLogger(name).setLevel(level)
# Restore the quiet default so verbose state doesn't leak to other tests.
_setup.configure_cli_logging(verbose=False)
def test_repo_session_exposes_open_repo_db() -> None:
assert callable(_repo_session.open_repo_db)