test_intel_callgraph_parity.py
python
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