gabriel / musehub public
test_intel_callgraph_parity.py python
265 lines 14.9 KB
Raw
sha256:b4b999434d042d74edc7032f1f2cfd20fda5b3580fe85966351db5b8eef0abb3 feat(intel): every grammar on the hub, and every intel job … Opus 5.5 minor ⚠ breaking 1 day ago
1 """muse#251 — the hub's background jobs compute exactly what the Muse CLI reports, for every language.
2
3 The jobs read stored objects and history rows (never a checkout, never a subprocess) and call the same library the
4 CLI uses, :mod:`muse.plugins.code.analysis`. Each test builds a snapshot in the database, runs one provider, and
5 compares what it stored with the library's answer for the same files.
6
7 PAR_GRAV gravity: real call-graph dependents (Java), not co-change counts.
8 PAR_DEAD dead code: reference-based with framework / native entry points; dismissed flags survive.
9 PAR_RISK blast risk: distinct referencing files, churn and coupling from history, the CLI's labels.
10 PAR_ENT entanglement: the CLI's rate (co-changes / smaller activity); import-linked pairs left out.
11 PAR_MAP codemap: wildcard imports link every file; cycles are closed paths.
12 PAR_LANG languages / api-surface count symbols for tree-sitter languages; clones name every language.
13 """
14 from __future__ import annotations
15
16 import hashlib
17 from datetime import datetime, timedelta, timezone
18
19 import msgpack
20 import pytest
21 import pytest_asyncio
22 from sqlalchemy import select
23
24 from muse.plugins.code import analysis as an
25 from muse.plugins.code.ast_parser import parse_symbols
26 from musehub.db.musehub_intel_models import (
27 MusehubIntelApiSurface,
28 MusehubIntelBlastRisk,
29 MusehubIntelCodemapMeta,
30 MusehubIntelCodemapModule,
31 MusehubIntelDead,
32 MusehubIntelEntangle,
33 MusehubIntelLanguages,
34 MusehubSymbolHistoryEntry,
35 MusehubSymbolIntel,
36 )
37 from musehub.db.musehub_repo_models import MusehubCommit, MusehubCommitRef, MusehubObject, MusehubSnapshot
38 from musehub.services import musehub_intel_providers as P
39 from tests.factories import create_repo
40
41 BASE = datetime(2026, 1, 1, tzinfo=timezone.utc)
42
43 JAVA = {
44 "src/bank/Ledger.java": "package bank;\npublic class Ledger {\n public void post(int a) { System.out.println(a); }\n}\nclass Unused { void never() {} }\n",
45 "src/bank/Account.java": "package bank;\nimport bank.Ledger;\npublic class Account {\n private final Ledger l = new Ledger();\n public int deposit(int x) { l.post(x); return x; }\n}\n",
46 "src/bank/App.java": "package bank;\nimport bank.util.*;\npublic class App {\n public static void main(String[] a) { new Account().deposit(1); }\n}\n",
47 "src/bank/util/A.java": "package bank.util;\npublic class A {}\n",
48 "src/bank/util/B.java": "package bank.util;\nimport bank.App;\npublic class B {}\n",
49 "src/test/java/bank/LedgerTest.java": "package bank;\nclass LedgerTest { void t() { new Ledger().post(1); } }\n",
50 }
51
52
53 def h(seed: str) -> str:
54 return "sha256:" + hashlib.sha256(seed.encode()).hexdigest()
55
56
57 @pytest_asyncio.fixture
58 async def session_factory(db_session, session_factory): # noqa: F811
59 return session_factory
60
61
62 class World:
63 """Commits whose snapshots hold real source files, plus the index rows ``intel.code`` writes for them."""
64
65 def __init__(self, session, repo_id: str) -> None:
66 self.s, self.repo_id = session, repo_id
67 self.commit_ids: dict[str, str] = {}
68
69 async def obj(self, source: str) -> str:
70 oid = hashlib.sha256(source.encode()).hexdigest()
71 if await self.s.get(MusehubObject, oid) is None:
72 self.s.add(MusehubObject(object_id=oid, path="x", size_bytes=len(source), storage_uri="pending", content_cache=source.encode()))
73 await self.s.flush()
74 return oid
75
76 async def commit(self, name: str, files: dict[str, str], changed: list[str], parents: list[str] | None = None, minute: int = 0) -> str:
77 manifest = {path: await self.obj(src) for path, src in files.items()}
78 snap_id = h(f"snap:{self.repo_id}:{name}")
79 self.s.add(MusehubSnapshot(snapshot_id=snap_id, manifest_blob=msgpack.packb(manifest), directories=[], entry_count=len(manifest)))
80 await self.s.flush()
81 cid = h(f"commit:{self.repo_id}:{name}")
82 self.s.add(MusehubCommit(commit_id=cid, message=name, author="gabriel", branch="main",
83 parent_ids=[self.commit_ids[p] for p in (parents or [])], snapshot_id=snap_id,
84 timestamp=BASE + timedelta(minutes=minute)))
85 self.s.add(MusehubCommitRef(repo_id=self.repo_id, commit_id=cid))
86 for addr in changed:
87 self.s.add(MusehubSymbolHistoryEntry(repo_id=self.repo_id, address=addr, commit_id=cid,
88 committed_at=BASE + timedelta(minutes=minute), op="insert"))
89 await self.s.flush()
90 self.commit_ids[name] = cid
91 return cid
92
93 async def index(self, files: dict[str, str]) -> None:
94 """The live-symbol rows ``intel.code`` maintains, one per symbol of *files*."""
95 for path, src in files.items():
96 for addr, rec in parse_symbols(src.encode(), path).items():
97 if rec["kind"] != "import" and await self.s.get(MusehubSymbolIntel, (self.repo_id, addr)) is None:
98 self.s.add(MusehubSymbolIntel(repo_id=self.repo_id, address=addr, symbol_kind=rec["kind"], op="insert"))
99 await self.s.flush()
100
101
102 def _facts(files: dict[str, str]) -> list[an.FileFacts]:
103 return [an.file_facts(p, s.encode()) for p, s in sorted(files.items())]
104
105
106 def _symbols(files: dict[str, str]) -> list[str]:
107 return sorted(a for p, s in files.items() for a, r in parse_symbols(s.encode(), p).items() if r["kind"] != "import")
108
109
110 async def java_world(s, slug: str) -> tuple[World, str]:
111 repo = await create_repo(s, owner="gabriel", slug=slug)
112 w = World(s, repo.repo_id)
113 head = await w.commit("c1", JAVA, _symbols(JAVA))
114 await w.index(JAVA)
115 await s.commit()
116 return w, head
117
118
119 # ── gravity ─────────────────────────────────────────────────────────────────
120
121
122 @pytest.mark.asyncio
123 async def test_PAR_GRAV_01_java_gravity_equals_the_cli(session_factory) -> None:
124 async with session_factory() as s:
125 w, head = await java_world(s, "par-grav")
126 await P.GravityProvider().compute(s, w.repo_id, head, {})
127 await s.commit()
128 rows = {r.address: r for r in (await s.execute(select(MusehubSymbolIntel).where(MusehubSymbolIntel.repo_id == w.repo_id))).scalars()}
129 expected, _ = an.gravity_from_facts(_facts(JAVA))
130 assert expected
131 for rec in expected:
132 row = rows[rec["address"]]
133 assert (row.gravity_pct, row.gravity_direct_dependents, row.gravity_transitive_dependents, row.gravity_max_depth,
134 row.gravity_depth_distribution) == (rec["gravity_pct"], rec["direct_dependents"], rec["transitive_dependents"],
135 rec["max_depth"], rec["depth_distribution"]), rec["address"]
136 post = rows["src/bank/Ledger.java::Ledger.post"]
137 assert (post.gravity_direct_dependents, post.gravity_transitive_dependents) == (1, 2)
138 assert rows["src/test/java/bank/LedgerTest.java::LedgerTest.t"].gravity_pct is None, "test code is outside the production scope"
139
140
141 # ── dead code ───────────────────────────────────────────────────────────────
142
143
144 @pytest.mark.asyncio
145 async def test_PAR_DEAD_01_dead_code_equals_the_cli_and_keeps_dismissals(session_factory) -> None:
146 async with session_factory() as s:
147 w, head = await java_world(s, "par-dead")
148 s.add(MusehubIntelDead(repo_id=w.repo_id, address="src/bank/Ledger.java::Unused", kind="class", confidence="high",
149 reason="x", ref=head, dismissed=True))
150 await s.commit()
151 await P.DeadProvider().compute(s, w.repo_id, head, {})
152 await s.commit()
153 rows = {r.address: r for r in (await s.execute(select(MusehubIntelDead).where(MusehubIntelDead.repo_id == w.repo_id))).scalars()}
154 expected, _, _, _ = an.dead_candidates(_facts(JAVA))
155 assert {"src/bank/Ledger.java::Unused", "src/bank/Ledger.java::Unused.never"} <= {d.address for d in expected}
156 assert "src/bank/App.java::App.main" not in {d.address for d in expected} # a program's main is an entry point
157 assert set(rows) == {d.address for d in expected}
158 for d in expected:
159 assert (rows[d.address].confidence, rows[d.address].reason, rows[d.address].kind) == (d.confidence, d.reason, d.kind)
160 assert rows["src/bank/Ledger.java::Unused"].dismissed is True
161
162
163 # ── blast risk ──────────────────────────────────────────────────────────────
164
165
166 @pytest.mark.asyncio
167 async def test_PAR_RISK_01_blast_risk_equals_the_cli(session_factory) -> None:
168 async with session_factory() as s:
169 repo = await create_repo(s, owner="gabriel", slug="par-risk")
170 w = World(s, repo.repo_id)
171 v2 = {**JAVA, "src/bank/Account.java": JAVA["src/bank/Account.java"].replace("return x;", "return x + 0;")}
172 await w.commit("c1", JAVA, _symbols(JAVA))
173 head = await w.commit("c2", v2, ["src/bank/Account.java::Account.deposit", "src/bank/Ledger.java::Ledger.post"], ["c1"], minute=5)
174 await w.index(v2)
175 await s.commit()
176 await P.BlastRiskProvider().compute(s, w.repo_id, head, {})
177 await s.commit()
178 rows = {r.address: r for r in (await s.execute(select(MusehubIntelBlastRisk).where(MusehubIntelBlastRisk.repo_id == w.repo_id))).scalars()}
179 churn, coupling = an.churn_and_file_coupling([_symbols(JAVA), ["src/bank/Account.java::Account.deposit", "src/bank/Ledger.java::Ledger.post"]])
180 expected = an.blast_risk_records(_facts(v2), churn, coupling)
181 assert set(rows) == {r["address"] for r in expected}
182 for r in expected:
183 row = rows[r["address"]]
184 assert (row.risk_score, row.risk) == (r["risk"], an.risk_label(r["risk"])), r["address"]
185 assert (row.impact_score, row.churn_score, row.test_gap_score, row.coupling_score) == (
186 r["impact_score"] / 100, r["churn_score"] / 100, r["test_gap_score"] / 100, r["coupling_score"] / 100)
187
188
189 # ── entanglement ────────────────────────────────────────────────────────────
190
191
192 @pytest.mark.asyncio
193 async def test_PAR_ENT_01_entangle_rate_and_import_links_equal_the_cli(session_factory) -> None:
194 files = {
195 "a.py": "def f():\n return 1\n",
196 "b.py": "def g():\n return 1\n",
197 "c.py": "from a import f\n\n\ndef k():\n return f()\n",
198 }
199 async with session_factory() as s:
200 repo = await create_repo(s, owner="gabriel", slug="par-ent")
201 w = World(s, repo.repo_id)
202 await w.commit("c1", files, ["a.py::f", "b.py::g", "c.py::k"])
203 await w.commit("c2", files, ["a.py::f", "b.py::g", "c.py::k"], ["c1"], minute=1)
204 head = await w.commit("c3", files, ["a.py::f"], ["c2"], minute=2)
205 await w.index(files)
206 await s.commit()
207 await P.EntangleProvider().compute(s, w.repo_id, head, {})
208 await s.commit()
209 rows = (await s.execute(select(MusehubIntelEntangle).where(MusehubIntelEntangle.repo_id == w.repo_id))).scalars().all()
210 links, _ = an.import_graph({p: parse_symbols(src.encode(), p) for p, src in files.items()})
211 expected = an.entangle_pairs([["a.py::f"], ["a.py::f", "b.py::g", "c.py::k"], ["a.py::f", "b.py::g", "c.py::k"]], import_links=links)
212 got = sorted((r.symbol_a, r.symbol_b, r.co_changes, r.commits_both_active, r.co_change_rate, r.structurally_linked) for r in rows)
213 want = sorted((p["symbol_a"], p["symbol_b"], p["co_changes"], p["commits_both_active"], p["co_change_rate"], p["structurally_linked"]) for p in expected)
214 assert got == want
215 assert ("a.py::f", "c.py::k") not in {(g[0], g[1]) for g in got}, "c.py imports a.py: an expected link, not entanglement"
216 assert ("a.py::f", "b.py::g", 2, 2, 1.0, False) in got
217
218
219 # ── codemap ─────────────────────────────────────────────────────────────────
220
221
222 @pytest.mark.asyncio
223 async def test_PAR_MAP_01_codemap_edges_and_cycles_equal_the_cli(session_factory) -> None:
224 async with session_factory() as s:
225 w, head = await java_world(s, "par-map")
226 await P.CodemapProvider().compute(s, w.repo_id, head, {})
227 await s.commit()
228 mods = {r.file_path: r for r in (await s.execute(select(MusehubIntelCodemapModule).where(MusehubIntelCodemapModule.repo_id == w.repo_id))).scalars()}
229 meta = (await s.execute(select(MusehubIntelCodemapMeta).where(MusehubIntelCodemapMeta.repo_id == w.repo_id))).scalar_one()
230 trees = {p: parse_symbols(src.encode(), p) for p, src in JAVA.items()}
231 imports_out, in_degree = an.import_graph(trees, JAVA.keys())
232 assert set(imports_out["src/bank/App.java"]) == {"src/bank/util/A.java", "src/bank/util/B.java"} # the wildcard links both
233 for path, targets in imports_out.items():
234 assert (mods[path].fan_out, mods[path].fan_in) == (len(targets), in_degree[path]), path
235 assert meta.total_edges == sum(len(t) for t in imports_out.values())
236 assert meta.cycles_json == an.import_cycles(imports_out) and meta.cycle_count == 1 # App → B → App
237
238
239 # ── languages, api surface, clones ──────────────────────────────────────────
240
241
242 @pytest.mark.asyncio
243 async def test_PAR_LANG_01_tree_sitter_languages_have_symbols_on_the_hub(session_factory) -> None:
244 files = {**JAVA, "app/Main.scala": "object Main {\n def main(args: Array[String]): Unit = ()\n}\n",
245 "web/index.php": "<?php\nfunction render() { return 1; }\n", "conf/app.yaml": "server:\n port: 8080\n"}
246 async with session_factory() as s:
247 repo = await create_repo(s, owner="gabriel", slug="par-lang")
248 w = World(s, repo.repo_id)
249 head = await w.commit("c1", files, [])
250 await s.commit()
251 await P.LanguagesProvider().compute(s, w.repo_id, head, {})
252 await P.ApiSurfaceProvider().compute(s, w.repo_id, head, {})
253 await s.commit()
254 langs = {r.language: r for r in (await s.execute(select(MusehubIntelLanguages).where(MusehubIntelLanguages.repo_id == w.repo_id))).scalars()}
255 api = {r.address for r in (await s.execute(select(MusehubIntelApiSurface).where(MusehubIntelApiSurface.repo_id == w.repo_id))).scalars()}
256 for lang in ("Java", "Scala", "PHP", "YAML"):
257 assert langs[lang].symbol_count > 0, lang
258 assert {"src/bank/Ledger.java::Ledger.post", "web/index.php::render", "app/Main.scala::Main$.main"} & api
259
260
261 def test_PAR_LANG_02_clones_name_every_language_muse_knows() -> None:
262 from muse.plugins.code._query import language_of
263
264 for path in ("a/B.scala", "a/b.scss", "a/b.h", "a/b.hpp", "a/b.kts", "a/b.mjs", "a/b.php", "a/b.yml"):
265 assert P._lang_from_address(f"{path}::X") == language_of(path)
File History 1 commit
sha256:b4b999434d042d74edc7032f1f2cfd20fda5b3580fe85966351db5b8eef0abb3 feat(intel): every grammar on the hub, and every intel job … Opus 5.5 minor ⚠ 1 day ago