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
"""Callers one hop past a forwarding wrapper (``_wrapper_callers``).
Synthetic graphs in three languages: the hop is added and marked for a real
wrapper, and withheld for a caller that does other work.
"""
from __future__ import annotations
import json
from datetime import UTC, datetime
import pytest
from repowise.core.persistence.models import GraphEdge, GraphNode, Repository
from repowise.server.mcp_server import _basis, _wrapper_callers
from repowise.server.mcp_server.tool_context import call_graph, enrichment
_NOW = datetime(2026, 3, 19, 12, 0, 0, tzinfo=UTC)
@pytest.fixture(autouse=True)
def _fresh_basis_cache():
_basis.reset_cache()
yield
_basis.reset_cache()
def _sym(rid, node_id, *, lines=(10, 30), kind="function", language="typescript", name=None):
file_path, _, qual = node_id.partition("::")
return GraphNode(
id=f"w_{node_id}",
repository_id=rid,
node_id=node_id,
node_type="symbol",
name=name or qual.split(".")[-1],
file_path=file_path,
kind=kind,
language=language,
start_line=lines[0],
end_line=lines[1],
created_at=_NOW,
)
def _edge(rid, source, target, *, edge_type="calls", confidence=0.9, **extra):
return GraphEdge(
id=f"w_{source}->{target}:{edge_type}",
repository_id=rid,
source_node_id=source,
target_node_id=target,
edge_type=edge_type,
confidence=confidence,
created_at=_NOW,
**extra,
)
async def _callers(session, rid, target, **kw) -> dict:
out: dict = {}
await enrichment._resolve_call_graph(
session,
await session.get(Repository, rid),
target,
"symbol",
out,
want_callers=True,
**kw,
)
return out
@pytest.mark.asyncio
async def test_ts_same_named_runtime_wrapper_lists_its_callers_marked(session, populated_db):
rid = populated_db
session.add_all(
[
_sym(rid, "src/poll.ts::prune", lines=(59, 70)),
_sym(rid, "src/poll.runtime.ts::prune", lines=(9, 13)),
_sym(rid, "src/diag.ts::tick", lines=(100, 140)),
_sym(rid, "src/poll.test.ts::__module__", lines=(1, 200), kind="module"),
_edge(rid, "src/poll.runtime.ts::prune", "src/poll.ts::prune"),
_edge(rid, "src/poll.test.ts::__module__", "src/poll.ts::prune"),
_edge(rid, "src/diag.ts::tick", "src/poll.runtime.ts::prune", resolution_origin="import_scoped"),
]
)
await session.flush()
out = await _callers(session, rid, "src/poll.ts::prune")
ids = [r.get("symbol_id") for r in out["callers"]]
assert set(ids[:2]) == {"src/poll.runtime.ts::prune", "src/poll.test.ts::__module__"}
hop = out["callers"][2]
assert hop["symbol_id"] == "src/diag.ts::tick"
assert hop["file"] == "src/diag.ts"
assert hop["edge_type"] == "calls"
assert hop["via"] == "import_scoped"
assert hop["via_wrapper"] == "src/poll.runtime.ts::prune"
assert all("via_wrapper" not in r for r in out["callers"][:2])
# Direct-caller counts are untouched by the hop rows.
assert "callers_total" not in out
@pytest.mark.asyncio
async def test_python_pass_through_with_another_name_is_a_wrapper(session, populated_db):
rid = populated_db
session.add_all(
[
_sym(rid, "pkg/core.py::_load_impl", lines=(5, 40), language="python"),
_sym(rid, "pkg/api.py::load", lines=(12, 14), language="python"),
_sym(rid, "app/main.py::run", lines=(3, 20), language="python"),
_edge(rid, "pkg/api.py::load", "pkg/core.py::_load_impl"),
_edge(rid, "app/main.py::run", "pkg/api.py::load"),
]
)
await session.flush()
out = await _callers(session, rid, "pkg/core.py::_load_impl")
assert [(r["symbol_id"], r.get("via_wrapper")) for r in out["callers"]] == [
("pkg/api.py::load", None),
("app/main.py::run", "pkg/api.py::load"),
]
@pytest.mark.asyncio
async def test_go_caller_doing_other_work_is_not_expanded(session, populated_db):
"""Short but calls something else too, or same-named but long: neither is a wrapper."""
rid = populated_db
go = {"language": "go"}
session.add_all(
[
_sym(rid, "store/db.go::Open", lines=(10, 50), **go),
_sym(rid, "cmd/main.go::handle", lines=(5, 7), **go),
_sym(rid, "cmd/main.go::logf", lines=(20, 22), **go),
_sym(rid, "srv/db.go::Open", lines=(10, 60), kind="method", **go),
_sym(rid, "cmd/run.go::serve", lines=(1, 9), **go),
_edge(rid, "cmd/main.go::handle", "store/db.go::Open"),
_edge(rid, "cmd/main.go::handle", "cmd/main.go::logf"),
_edge(rid, "srv/db.go::Open", "store/db.go::Open"),
_edge(rid, "cmd/run.go::serve", "cmd/main.go::handle"),
_edge(rid, "cmd/run.go::serve", "srv/db.go::Open"),
]
)
await session.flush()
out = await _callers(session, rid, "store/db.go::Open")
assert {r["symbol_id"] for r in out["callers"]} == {"cmd/main.go::handle", "srv/db.go::Open"}
@pytest.mark.asyncio
async def test_go_method_forwarder_is_expanded(session, populated_db):
rid = populated_db
go = {"language": "go"}
session.add_all(
[
_sym(rid, "store/db.go::Open", lines=(10, 50), **go),
_sym(rid, "store/client.go::Client.Open", lines=(30, 32), kind="method", **go),
_sym(rid, "cmd/main.go::main", lines=(1, 30), **go),
_edge(rid, "store/client.go::Client.Open", "store/db.go::Open"),
_edge(rid, "cmd/main.go::main", "store/client.go::Client.Open"),
]
)
await session.flush()
out = await _callers(session, rid, "store/db.go::Open")
assert out["callers"][-1]["symbol_id"] == "cmd/main.go::main"
assert out["callers"][-1]["via_wrapper"] == "store/client.go::Client.Open"
@pytest.mark.asyncio
async def test_wrapper_cycle_adds_nothing_already_listed(session, populated_db):
"""A forwarder the target calls back: its caller is the target, which is never listed."""
rid = populated_db
session.add_all(
[
_sym(rid, "a.ts::run", lines=(1, 30)),
_sym(rid, "b.ts::run", lines=(1, 4)),
_edge(rid, "b.ts::run", "a.ts::run"),
_edge(rid, "a.ts::run", "b.ts::run"),
]
)
await session.flush()
out = await _callers(session, rid, "a.ts::run")
assert [r["symbol_id"] for r in out["callers"]] == ["b.ts::run"]
assert all("via_wrapper" not in r for r in out["callers"])
@pytest.mark.asyncio
async def test_same_named_caller_that_calls_more_is_not_a_wrapper(session, populated_db):
"""Same name, other file, short: still not a wrapper once it resolves another call."""
rid = populated_db
session.add_all(
[
_sym(rid, "lib/impl.ts::save", lines=(1, 40)),
_sym(rid, "app/model.ts::save", lines=(10, 18)),
_sym(rid, "app/model.ts::validate", lines=(30, 40)),
_sym(rid, "app/form.ts::submit", lines=(1, 20)),
_edge(rid, "app/model.ts::save", "lib/impl.ts::save"),
_edge(rid, "app/model.ts::save", "app/model.ts::validate"),
_edge(rid, "app/form.ts::submit", "app/model.ts::save"),
]
)
await session.flush()
out = await _callers(session, rid, "lib/impl.ts::save")
assert [r["symbol_id"] for r in out["callers"]] == ["app/model.ts::save"]
@pytest.mark.asyncio
async def test_hop_rows_are_capped(session, populated_db):
rid = populated_db
rows = [
_sym(rid, "lib/impl.py::work", lines=(1, 40), language="python"),
_sym(rid, "lib/__init__.py::work", lines=(1, 2), language="python"),
_edge(rid, "lib/__init__.py::work", "lib/impl.py::work"),
]
for i in range(15):
rows.append(_sym(rid, f"app/m{i:02}.py::use", lines=(1, 9), language="python"))
rows.append(_edge(rid, f"app/m{i:02}.py::use", "lib/__init__.py::work"))
session.add_all(rows)
await session.flush()
out = await _callers(session, rid, "lib/impl.py::work")
hop = [r for r in out["callers"] if "via_wrapper" in r]
assert len(hop) == _wrapper_callers.MAX_WRAPPER_CALLER_ROWS
assert [r["symbol_id"] for r in hop] == [f"app/m{i:02}.py::use" for i in range(10)]
target = await session.get(GraphNode, "w_lib/impl.py::work")
capped = await _wrapper_callers.forwarding_wrapper_callers(
session, rid, target, ["lib/__init__.py::work"], limit=3
)
assert len(capped) == 3
@pytest.mark.asyncio
async def test_unreached_wrapper_falls_back_to_files_importing_it(session, populated_db):
"""A dynamic import consumed in a callback leaves no call edge; the import edge names the file."""
rid = populated_db
session.add_all(
[
_sym(rid, "src/poll.ts::prune", lines=(59, 70)),
_sym(rid, "src/poll.runtime.ts::prune", lines=(9, 13)),
_edge(rid, "src/poll.runtime.ts::prune", "src/poll.ts::prune"),
_edge(rid, "src/diag.ts", "src/poll.runtime.ts", edge_type="imports", confidence=1.0,
imported_names_json='["*"]'),
_edge(rid, "src/other.ts", "src/poll.runtime.ts", edge_type="imports", confidence=1.0,
imported_names_json='["unrelated"]'),
_edge(rid, "src/cli.ts", "src/poll.runtime.ts", edge_type="imports", confidence=1.0,
imported_names_json='["prune"]'),
]
)
await session.flush()
out = await _callers(session, rid, "src/poll.ts::prune")
named = out["callers"][1]
assert named["file"] == "src/cli.ts" and "wholesale" not in named
assert out["callers"][-1] == {
"file": "src/diag.ts",
"imports": True,
"confidence": 1.0,
"wholesale": True,
"via_wrapper": "src/poll.runtime.ts::prune",
}
assert len(out["callers"]) == 3
@pytest.mark.asyncio
async def test_output_is_byte_identical_when_no_caller_is_a_wrapper(
session, populated_db, monkeypatch
):
rid = populated_db
session.add_all(
[
_sym(rid, "x.py::target", lines=(1, 30), language="python"),
_sym(rid, "y.py::big", lines=(1, 80), language="python"),
_sym(rid, "z.py::top", lines=(1, 5), language="python"),
_edge(rid, "y.py::big", "x.py::target"),
_edge(rid, "z.py::top", "y.py::big"),
]
)
await session.flush()
with_hop = await _callers(session, rid, "x.py::target")
async def _none(*_a, **_k):
return []
monkeypatch.setattr(call_graph, "forwarding_wrapper_callers", _none)
without = await _callers(session, rid, "x.py::target")
assert json.dumps(with_hop, sort_keys=False) == json.dumps(without, sort_keys=False)