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 /api/repos/{repo_id}/external-systems dependency registry."""
from __future__ import annotations
import pytest
from httpx import AsyncClient
from sqlalchemy import event, select
from repowise.core.persistence.crud.external_systems import (
build_external_system_link_map,
link_graph_nodes_to_external_systems,
)
from repowise.core.persistence.database import get_session
from repowise.core.persistence.models import ExternalSystem, GraphEdge, GraphNode
from tests.unit.server.conftest import create_test_repo
async def _seed(session_factory, repo_id: str) -> None:
async with get_session(session_factory) as session:
session.add_all(
[
ExternalSystem(
repository_id=repo_id,
name="react",
display_name="React",
ecosystem="npm",
category="framework",
version="^19.0.0",
declared_in="packages/web/package.json",
is_dev_dep=False,
),
ExternalSystem(
repository_id=repo_id,
name="vitest",
display_name="Vitest",
ecosystem="npm",
category="tool",
version="^4.1.5",
declared_in="packages/ui/package.json",
is_dev_dep=True,
),
ExternalSystem(
repository_id=repo_id,
name="fastapi",
display_name="FastAPI",
ecosystem="pypi",
category="framework",
version=">=0.110",
declared_in="packages/server/pyproject.toml",
is_dev_dep=False,
),
]
)
await session.flush()
async def _seed_summary(session_factory, repo_id: str) -> None:
async with get_session(session_factory) as session:
react_web = ExternalSystem(
repository_id=repo_id,
name="react",
display_name="React",
ecosystem="npm",
category="framework",
version="^19.0.0",
declared_in="packages/web/package.json",
is_dev_dep=False,
)
react_ui = ExternalSystem(
repository_id=repo_id,
name="react",
display_name="React",
ecosystem="npm",
category="framework",
version="^18.0.0",
declared_in="packages/ui/package.json",
is_dev_dep=True,
)
next_package = ExternalSystem(
repository_id=repo_id,
name="next",
display_name="Next",
ecosystem="npm",
category="framework",
version="~15.5.0",
declared_in="packages/web/package.json",
is_dev_dep=False,
)
vitest = ExternalSystem(
repository_id=repo_id,
name="vitest",
display_name="Vitest",
ecosystem="npm",
category="tool",
version="^4.1.0",
declared_in="packages/ui/package.json",
is_dev_dep=True,
)
radix = ExternalSystem(
repository_id=repo_id,
name="@radix-ui/react-dialog",
display_name="Radix Dialog",
ecosystem="npm",
category="library",
version="^1.0.0",
declared_in="packages/web/package.json",
is_dev_dep=False,
)
serde = ExternalSystem(
repository_id=repo_id,
name="serde",
display_name="Serde",
ecosystem="cargo",
category="library",
version="1",
declared_in="crates/core/Cargo.toml",
is_dev_dep=False,
)
auxiliary = ExternalSystem(
repository_id=repo_id,
name="aux-only",
display_name="Aux only",
ecosystem="npm",
category="library",
version="1.0.0",
declared_in=".claude/worktrees/demo/package.json",
is_dev_dep=False,
)
session.add_all([react_web, react_ui, next_package, vitest, radix, serde, auxiliary])
await session.flush()
session.add_all(
[
GraphNode(
repository_id=repo_id,
node_id="src/a.ts",
language="typescript",
community_id=1,
community_meta_json='{"label":"Web runtime"}',
),
GraphNode(
repository_id=repo_id,
node_id="src/b.ts",
language="typescript",
community_id=2,
community_meta_json='{"label":"Shared UI"}',
),
GraphNode(
repository_id=repo_id,
node_id="src/dialog.ts",
language="typescript",
community_id=1,
community_meta_json='{"label":"Web runtime"}',
),
GraphNode(
repository_id=repo_id,
node_id="src/lib.rs",
language="rust",
community_id=3,
community_meta_json='{"label":"Core"}',
),
GraphNode(
repository_id=repo_id,
node_id="src/page.ts",
language="typescript",
community_id=1,
community_meta_json='{"label":"Web runtime"}',
),
GraphNode(
repository_id=repo_id,
node_id=".claude/worktrees/demo/src/a.ts",
language="typescript",
community_id=4,
community_meta_json='{"label":"Auxiliary"}',
),
GraphNode(
repository_id=repo_id,
node_id="external:react",
language="external",
),
GraphNode(
repository_id=repo_id,
node_id="external:react/jsx-runtime",
language="external",
),
GraphNode(
repository_id=repo_id,
node_id="external:next/navigation",
language="external",
),
GraphNode(
repository_id=repo_id,
node_id="external:@radix-ui/react-dialog/subpath",
language="external",
),
GraphNode(
repository_id=repo_id,
node_id="external:serde::Deserialize",
language="external",
),
]
)
session.add_all(
[
GraphEdge(
repository_id=repo_id,
source_node_id="src/a.ts",
target_node_id="external:react",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id="src/dialog.ts",
target_node_id="external:@radix-ui/react-dialog/subpath",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id="src/lib.rs",
target_node_id="external:serde::Deserialize",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id="src/a.ts",
target_node_id="external:react/jsx-runtime",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id="src/b.ts",
target_node_id="external:react",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id=".claude/worktrees/demo/src/a.ts",
target_node_id="external:react",
edge_type="imports",
),
GraphEdge(
repository_id=repo_id,
source_node_id="src/page.ts",
target_node_id="external:next/navigation",
edge_type="imports",
),
# Non-import edges do not constitute declared-package usage.
GraphEdge(
repository_id=repo_id,
source_node_id="src/call.ts",
target_node_id="external:react",
edge_type="calls",
),
]
)
await session.flush()
linked = await link_graph_nodes_to_external_systems(
session,
repo_id,
{
"react": react_web.id,
"next": next_package.id,
"vitest": vitest.id,
"@radix-ui/react-dialog": radix.id,
"serde": serde.id,
},
)
assert linked == 5
@pytest.mark.asyncio
async def test_registry_lists_all_rows(client: AsyncClient, app) -> None:
repo = await create_test_repo(client)
await _seed(app.state.session_factory, repo["id"])
resp = await client.get(f"/api/repos/{repo['id']}/external-systems")
assert resp.status_code == 200
data = resp.json()
assert data["total"] == 3
assert data["prod_count"] == 2
assert data["dev_count"] == 1
assert data["ecosystems"] == ["npm", "pypi"]
assert data["manifests"] == [
"packages/server/pyproject.toml",
"packages/ui/package.json",
"packages/web/package.json",
]
# Sorted by category prominence (framework first), then name.
assert [e["name"] for e in data["items"]] == ["fastapi", "react", "vitest"]
react = data["items"][1]
assert react["display_name"] == "React"
assert react["version"] == "^19.0.0"
assert react["declared_in"] == "packages/web/package.json"
assert react["is_dev_dep"] is False
@pytest.mark.asyncio
async def test_registry_empty(client: AsyncClient) -> None:
repo = await create_test_repo(client)
resp = await client.get(f"/api/repos/{repo['id']}/external-systems")
assert resp.status_code == 200
data = resp.json()
assert data["total"] == 0
assert data["items"] == []
@pytest.mark.asyncio
async def test_linker_preserves_cross_ecosystem_ambiguity_and_prefixed_names(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
systems = [
{"name": "shared", "ecosystem": "npm", "declared_in": "package.json"},
{"name": "shared", "ecosystem": "pypi", "declared_in": "pyproject.toml"},
{
"name": "Newtonsoft.Json",
"ecosystem": "nuget",
"declared_in": "app.csproj",
},
{"name": "http", "ecosystem": "pub", "declared_in": "pubspec.yaml"},
]
async with get_session(app.state.session_factory) as session:
rows = [
ExternalSystem(
repository_id=repo["id"],
display_name=system["name"],
category="library",
**system,
)
for system in systems
]
session.add_all(rows)
await session.flush()
id_map = {(row.name, row.declared_in): row.id for row in rows}
links = build_external_system_link_map(systems, id_map)
assert links["shared"] is None
assert links["npm:shared"] == rows[0].id
node_ids = [
"external:shared",
"external:npm:shared",
"external:nuget:Newtonsoft.Json",
"external:pub:http",
]
session.add_all(
GraphNode(
repository_id=repo["id"],
node_id=node_id,
language="external",
external_system_id=(rows[0].id if node_id == "external:shared" else None),
)
for node_id in node_ids
)
await session.flush()
assert await link_graph_nodes_to_external_systems(session, repo["id"], links) == 4
linked = {
node.node_id: node.external_system_id
for node in (
await session.execute(
select(GraphNode).where(GraphNode.repository_id == repo["id"])
)
).scalars()
}
assert linked["external:shared"] is None
assert linked["external:npm:shared"] == rows[0].id
assert linked["external:nuget:Newtonsoft.Json"] == rows[2].id
assert linked["external:pub:http"] == rows[3].id
@pytest.mark.asyncio
async def test_summary_joins_unique_packages_to_import_evidence(client: AsyncClient, app) -> None:
repo = await create_test_repo(client)
await _seed_summary(app.state.session_factory, repo["id"])
resp = await client.get(f"/api/repos/{repo['id']}/external-systems/summary")
assert resp.status_code == 200
data = resp.json()
assert data["total_packages"] == 5
assert data["total_declarations"] == 6
assert data["returned"] == 5
assert data["truncated"] is False
assert data["scope"] == "primary"
assert data["excluded_declarations"] == 1
assert data["linked_packages"] == 4
assert data["unlinked_packages"] == 1
assert data["observed_packages"] == 4
assert data["ecosystems"] == ["cargo", "npm"]
by_name = {item["name"]: item for item in data["items"]}
react = by_name["react"]
assert react["versions"] == ["^18.0.0", "^19.0.0"]
assert react["versions_total"] == 2
assert react["versions_truncated"] is False
assert react["multiple_versions"] is True
assert react["import_edge_count"] == 3
assert react["importing_file_count"] == 2
assert react["link_state"] == "linked"
assert by_name["@radix-ui/react-dialog"]["import_edge_count"] == 1
assert by_name["serde"]["import_edge_count"] == 1
assert by_name["vitest"]["link_state"] == "unlinked"
assert "aux-only" not in by_name
all_data = (
await client.get(f"/api/repos/{repo['id']}/external-systems/summary?scope=all")
).json()
all_react = next(item for item in all_data["items"] if item["name"] == "react")
assert all_react["import_edge_count"] == 4
assert all_react["importing_file_count"] == 3
@pytest.mark.asyncio
async def test_summary_query_count_is_constant(client: AsyncClient, app, test_engine) -> None:
repo = await create_test_repo(client)
async with get_session(app.state.session_factory) as session:
session.add_all(
[
ExternalSystem(
repository_id=repo["id"],
name=f"package-{index}",
display_name=f"Package {index}",
ecosystem="npm",
category="library",
version="1.0.0",
declared_in=f"packages/p{index}/package.json",
is_dev_dep=False,
)
for index in range(250)
]
)
await session.flush()
statements: list[str] = []
def record(*args) -> None:
statements.append(str(args[2]))
event.listen(test_engine.sync_engine, "before_cursor_execute", record)
try:
resp = await client.get(f"/api/repos/{repo['id']}/external-systems/summary")
finally:
event.remove(test_engine.sync_engine, "before_cursor_execute", record)
assert resp.status_code == 200
assert resp.json()["total_packages"] == 250
assert resp.json()["returned"] == 200
assert resp.json()["truncated"] is True
selects = [statement for statement in statements if statement.lstrip().startswith("SELECT")]
assert len(selects) == 3
@pytest.mark.asyncio
async def test_summary_bounds_pages_versions_and_can_include_auxiliary_scope(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
async with get_session(app.state.session_factory) as session:
session.add_all(
[
ExternalSystem(
repository_id=repo["id"],
name="many-versions",
display_name="Many versions",
ecosystem="npm",
category="library",
version=f"{version}.0.0",
declared_in=f"packages/p{version}/package.json",
is_dev_dep=False,
)
for version in range(8)
]
+ [
ExternalSystem(
repository_id=repo["id"],
name="aux-only",
display_name="Aux only",
ecosystem="npm",
category="library",
version="1.0.0",
declared_in="local-stash/example/package.json",
is_dev_dep=True,
)
]
)
await session.flush()
primary = (await client.get(f"/api/repos/{repo['id']}/external-systems/summary?limit=1")).json()
assert primary["returned"] == 1
assert primary["total_packages"] == 1
assert primary["excluded_declarations"] == 1
item = primary["items"][0]
assert item["versions_total"] == 8
assert len(item["versions"]) == 5
assert item["versions_truncated"] is True
all_scopes = (
await client.get(
f"/api/repos/{repo['id']}/external-systems/summary?scope=all&limit=1&offset=1"
)
).json()
assert all_scopes["scope"] == "all"
assert all_scopes["total_packages"] == 2
assert all_scopes["returned"] == 1
assert all_scopes["offset"] == 1
assert all_scopes["excluded_declarations"] == 0
too_large = await client.get(f"/api/repos/{repo['id']}/external-systems/summary?limit=401")
assert too_large.status_code == 422
@pytest.mark.asyncio
async def test_summary_reports_auxiliary_only_declarations(client: AsyncClient, app) -> None:
repo = await create_test_repo(client)
async with get_session(app.state.session_factory) as session:
session.add(
ExternalSystem(
repository_id=repo["id"],
name="aux-only",
display_name="Aux only",
ecosystem="npm",
category="library",
version="1.0.0",
declared_in="local-stash/example/package.json",
is_dev_dep=True,
)
)
await session.flush()
data = (await client.get(f"/api/repos/{repo['id']}/external-systems/summary")).json()
assert data["items"] == []
assert data["total_packages"] == 0
assert data["excluded_declarations"] == 1
@pytest.mark.asyncio
async def test_summary_empty(client: AsyncClient) -> None:
repo = await create_test_repo(client)
resp = await client.get(f"/api/repos/{repo['id']}/external-systems/summary")
assert resp.status_code == 200
assert resp.json() == {
"items": [],
"returned": 0,
"total_packages": 0,
"limit": 200,
"offset": 0,
"truncated": False,
"scope": "primary",
"excluded_declarations": 0,
"total_declarations": 0,
"runtime_packages": 0,
"dev_only_packages": 0,
"observed_packages": 0,
"linked_packages": 0,
"unlinked_packages": 0,
"linked_without_imports": 0,
"ecosystems": [],
"manifest_count": 0,
}
@pytest.mark.asyncio
async def test_relationship_graph_is_aggregate_first_bounded_and_honest(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
await _seed_summary(app.state.session_factory, repo["id"])
response = await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:react/graph?node_limit=1&edge_limit=1"
)
assert response.status_code == 200
data = response.json()
assert data["package_key"] == "npm:react"
assert data["package_node_id"] == "package:npm:react"
assert data["match_basis"] == "mixed"
assert data["matched_external_nodes_total"] == 2
assert data["evidence_target_limit"] == 200
assert data["evidence_truncated"] is False
assert {target["match_basis"] for target in data["matched_external_nodes"]} == {
"exact",
"subpath",
}
assert data["aggregate_total"] == 2
assert data["aggregate_returned"] == 1
assert data["edge_total"] == 2
assert data["edge_returned"] == 1
assert data["importing_file_total"] == 2
assert data["import_edge_total"] == 3
assert data["truncated"] is True
assert data["nodes"][0] == {
"aggregate_key": "community:1",
"label": "Web runtime",
"community_id": 1,
"importing_file_count": 1,
"import_edge_count": 2,
"top_file": "src/a.ts",
}
assert data["edges"] == [
{
"source": "community:1",
"target": "package:npm:react",
"import_edge_count": 2,
}
]
@pytest.mark.asyncio
async def test_relationship_graph_handles_unresolved_missing_and_scoped_packages(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
await _seed_summary(app.state.session_factory, repo["id"])
unresolved = (
await client.get(f"/api/repos/{repo['id']}/external-systems/npm:vitest/graph")
).json()
assert unresolved["match_basis"] == "unresolved"
assert unresolved["matched_external_nodes"] == []
assert unresolved["nodes"] == []
assert unresolved["importing_file_total"] == 0
assert unresolved["truncated"] is False
scoped = await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:%40radix-ui%2Freact-dialog/graph"
)
assert scoped.status_code == 200
assert scoped.json()["package_key"] == "npm:@radix-ui/react-dialog"
assert scoped.json()["match_basis"] == "subpath"
missing = await client.get(f"/api/repos/{repo['id']}/external-systems/npm:not-declared/graph")
assert missing.status_code == 404
@pytest.mark.asyncio
async def test_relationship_file_expansion_is_independently_bounded_and_paginated(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
await _seed_summary(app.state.session_factory, repo["id"])
first = (
await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:react/graph/files",
params={"aggregate_key": "community:1", "limit": 1},
)
).json()
assert first["total"] == 1
assert first["returned"] == 1
assert first["items"][0] == {
"path": "src/a.ts",
"language": "typescript",
"import_edge_count": 2,
"matched_external_node_count": 2,
}
assert first["truncated"] is False
second = (
await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:react/graph/files",
params={"aggregate_key": "community:2", "limit": 1, "offset": 1},
)
).json()
assert second["total"] == 1
assert second["items"] == []
assert second["truncated"] is False
invalid = await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:react/graph/files",
params={"aggregate_key": "directory:src"},
)
assert invalid.status_code == 422
too_large = await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:react/graph/files",
params={"aggregate_key": "community:1", "limit": 101},
)
assert too_large.status_code == 422
missing = await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:not-declared/graph/files",
params={"aggregate_key": "community:1"},
)
assert missing.status_code == 404
@pytest.mark.asyncio
async def test_relationship_graph_and_expansion_share_the_same_capped_target_evidence(
client: AsyncClient, app
) -> None:
repo = await create_test_repo(client)
async with get_session(app.state.session_factory) as session:
package = ExternalSystem(
repository_id=repo["id"],
name="many-targets",
display_name="Many targets",
ecosystem="npm",
category="library",
declared_in="package.json",
is_dev_dep=False,
)
session.add(package)
await session.flush()
session.add_all(
[
GraphNode(
repository_id=repo["id"],
node_id=f"external:many-targets/{index:03}",
node_type="external",
language="external",
external_system_id=package.id,
)
for index in range(201)
]
+ [
GraphNode(
repository_id=repo["id"],
node_id=f"src/file-{index:03}.ts",
language="typescript",
community_id=9,
community_meta_json='{"label":"Many consumers"}',
)
for index in range(201)
]
)
session.add_all(
GraphEdge(
repository_id=repo["id"],
source_node_id=f"src/file-{index:03}.ts",
target_node_id=f"external:many-targets/{index:03}",
edge_type="imports",
)
for index in range(201)
)
await session.flush()
graph = (
await client.get(f"/api/repos/{repo['id']}/external-systems/npm:many-targets/graph")
).json()
assert graph["matched_external_nodes_total"] == 201
assert graph["evidence_target_limit"] == 200
assert graph["evidence_truncated"] is True
assert graph["importing_file_total"] == 200
files = (
await client.get(
f"/api/repos/{repo['id']}/external-systems/npm:many-targets/graph/files",
params={"aggregate_key": "community:9", "limit": 100},
)
).json()
assert files["total"] == 200
assert files["returned"] == 100
assert files["truncated"] is True
@pytest.mark.asyncio
async def test_relationship_graph_query_count_is_constant(
client: AsyncClient, app, test_engine
) -> None:
repo = await create_test_repo(client)
await _seed_summary(app.state.session_factory, repo["id"])
statements: list[str] = []
def record(_conn, _cursor, statement, _parameters, _context, _executemany) -> None:
statements.append(statement)
event.listen(test_engine.sync_engine, "before_cursor_execute", record)
try:
response = await client.get(f"/api/repos/{repo['id']}/external-systems/npm:react/graph")
finally:
event.remove(test_engine.sync_engine, "before_cursor_execute", record)
assert response.status_code == 200
selects = [statement for statement in statements if statement.lstrip().startswith("SELECT")]
# Declarations, resolved external nodes, then the edges reaching them. The
# count is what matters: it does not grow with importers, communities or
# declared packages. Composition moved to a session-free fold, so the third
# read replaces the aggregate the graph query used to push down.
assert len(selects) == 3
@pytest.mark.asyncio
async def test_usage_lists_import_sites_with_line_and_reachability(
client: AsyncClient, app, tmp_path
) -> None:
repo = await create_test_repo(client, tmp_path)
root = tmp_path / "test-repo"
(root / "src").mkdir()
(root / "src/app.py").write_text("import os\nimport fastapi\n", encoding="utf-8")
async with get_session(app.state.session_factory) as session:
system = ExternalSystem(
repository_id=repo["id"],
name="fastapi",
ecosystem="pypi",
declared_in="pyproject.toml",
)
session.add(system)
await session.flush()
session.add_all(
[
GraphNode(
repository_id=repo["id"],
node_id="src/app.py",
node_type="file",
language="python",
is_entry_point=True,
),
GraphNode(
repository_id=repo["id"],
node_id="external:fastapi",
node_type="external",
external_system_id=system.id,
),
GraphEdge(
repository_id=repo["id"],
source_node_id="src/app.py",
target_node_id="external:fastapi",
imported_names_json="[]",
),
]
)
resp = await client.get(f"/api/repos/{repo['id']}/external-systems/pypi:fastapi/usage")
assert resp.status_code == 200, resp.text
data = resp.json()
assert data["ecosystem"] == "pypi"
(site,) = data["sites"]
assert (site["path"], site["line"], site["mapping"]) == ("src/app.py", 2, "declared")
assert site["reachability"] == {"state": "reachable", "basis": "import_graph"}
bare = await client.get(f"/api/repos/{repo['id']}/external-systems/fastapi/usage")
assert bare.json()["summary"]["files"] == 1
missing = await client.get("/api/repos/nope/external-systems/fastapi/usage")
assert missing.status_code == 404