test_refactor_classify.py
python
| 1 | """Tests for muse/plugins/code/_refactor_classify.py. |
| 2 | |
| 3 | Coverage |
| 4 | -------- |
| 5 | classify_exact |
| 6 | - unchanged: same content_id |
| 7 | - rename: same body_hash, different name, same file |
| 8 | - move: same content_id, different file, same name |
| 9 | - rename+move: same body_hash, different name, different file |
| 10 | - signature_only: same body_hash, different signature_id |
| 11 | - impl_only: same signature_id, different body_hash |
| 12 | - metadata_only: same body_hash + signature_id, different metadata_id |
| 13 | - full_rewrite: both signature and body changed |
| 14 | |
| 15 | classify_composite |
| 16 | - Exact rename detected across batches |
| 17 | - Exact move detected across batches |
| 18 | - Exact rename+move detected across batches |
| 19 | - Inferred extract (new symbol name inside old qualified_name) |
| 20 | - No false positives for completely unrelated symbols |
| 21 | - Empty inputs → empty results |
| 22 | |
| 23 | RefactorClassification |
| 24 | - to_dict() round-trips all fields |
| 25 | - confidence is rounded to 3 decimal places |
| 26 | - evidence list is preserved |
| 27 | """ |
| 28 | from __future__ import annotations |
| 29 | |
| 30 | import hashlib |
| 31 | |
| 32 | import pytest |
| 33 | |
| 34 | from muse.plugins.code._refactor_classify import ( |
| 35 | RefactorClassification, |
| 36 | classify_composite, |
| 37 | classify_exact, |
| 38 | ) |
| 39 | from muse.plugins.code.ast_parser import SymbolRecord |
| 40 | |
| 41 | |
| 42 | # --------------------------------------------------------------------------- |
| 43 | # Helpers |
| 44 | # --------------------------------------------------------------------------- |
| 45 | |
| 46 | |
| 47 | def _sha(text: str) -> str: |
| 48 | return hashlib.sha256(text.encode()).hexdigest() |
| 49 | |
| 50 | |
| 51 | def _rec( |
| 52 | *, |
| 53 | kind: str = "function", |
| 54 | name: str = "func", |
| 55 | qualified_name: str = "func", |
| 56 | lineno: int = 1, |
| 57 | end_lineno: int = 10, |
| 58 | content_id: str | None = None, |
| 59 | body_hash: str | None = None, |
| 60 | signature_id: str | None = None, |
| 61 | metadata_id: str = "", |
| 62 | canonical_key: str = "", |
| 63 | ) -> SymbolRecord: |
| 64 | body_hash = body_hash or _sha(f"body:{name}") |
| 65 | signature_id = signature_id or _sha(f"sig:{name}") |
| 66 | content_id = content_id or _sha(body_hash + signature_id + metadata_id) |
| 67 | return SymbolRecord( |
| 68 | kind=kind, |
| 69 | name=name, |
| 70 | qualified_name=qualified_name, |
| 71 | lineno=lineno, |
| 72 | end_lineno=end_lineno, |
| 73 | content_id=content_id, |
| 74 | body_hash=body_hash, |
| 75 | signature_id=signature_id, |
| 76 | metadata_id=metadata_id, |
| 77 | canonical_key=canonical_key, |
| 78 | ) |
| 79 | |
| 80 | |
| 81 | def _same_body_rec(source: SymbolRecord, *, name: str, qualified_name: str = "") -> SymbolRecord: |
| 82 | """Return a record with the same body_hash as *source* but a different name.""" |
| 83 | body_hash = source["body_hash"] |
| 84 | sig_id = source["signature_id"] |
| 85 | content_id = _sha(body_hash + sig_id + source.get("metadata_id", "")) |
| 86 | return SymbolRecord( |
| 87 | kind=source["kind"], |
| 88 | name=name, |
| 89 | qualified_name=qualified_name or name, |
| 90 | lineno=source["lineno"], |
| 91 | end_lineno=source["end_lineno"], |
| 92 | content_id=_sha(body_hash + sig_id + "renamed" + name), # different content |
| 93 | body_hash=body_hash, |
| 94 | signature_id=sig_id, |
| 95 | metadata_id=source.get("metadata_id", ""), |
| 96 | canonical_key="", |
| 97 | ) |
| 98 | |
| 99 | |
| 100 | # --------------------------------------------------------------------------- |
| 101 | # classify_exact — unchanged |
| 102 | # --------------------------------------------------------------------------- |
| 103 | |
| 104 | |
| 105 | class TestClassifyExactUnchanged: |
| 106 | def test_same_content_id_is_unchanged(self) -> None: |
| 107 | rec = _rec(name="f", content_id="abc123") |
| 108 | result = classify_exact("src/a.py::f", "src/a.py::f", rec, rec) |
| 109 | assert result == "unchanged" |
| 110 | |
| 111 | |
| 112 | # --------------------------------------------------------------------------- |
| 113 | # classify_exact — rename (same file) |
| 114 | # --------------------------------------------------------------------------- |
| 115 | |
| 116 | |
| 117 | class TestClassifyExactRename: |
| 118 | def test_same_body_different_name_same_file(self) -> None: |
| 119 | body = _sha("body_content") |
| 120 | sig = _sha("signature") |
| 121 | old = SymbolRecord( |
| 122 | kind="function", name="old_name", qualified_name="old_name", |
| 123 | lineno=1, end_lineno=10, |
| 124 | content_id=_sha(body + sig + ""), |
| 125 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 126 | ) |
| 127 | new = SymbolRecord( |
| 128 | kind="function", name="new_name", qualified_name="new_name", |
| 129 | lineno=1, end_lineno=10, |
| 130 | content_id=_sha(body + sig + "x"), # different content_id |
| 131 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 132 | ) |
| 133 | result = classify_exact("src/a.py::old_name", "src/a.py::new_name", old, new) |
| 134 | assert result == "rename" |
| 135 | |
| 136 | def test_rename_requires_different_name(self) -> None: |
| 137 | body = _sha("body") |
| 138 | sig = _sha("sig") |
| 139 | old = SymbolRecord( |
| 140 | kind="function", name="same", qualified_name="same", |
| 141 | lineno=1, end_lineno=5, |
| 142 | content_id=_sha(body + sig), |
| 143 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 144 | ) |
| 145 | new = SymbolRecord( |
| 146 | kind="function", name="same", qualified_name="same", |
| 147 | lineno=1, end_lineno=5, |
| 148 | content_id=_sha(body + sig + "meta"), # slightly different |
| 149 | body_hash=body, signature_id=sig, metadata_id="meta", canonical_key="", |
| 150 | ) |
| 151 | result = classify_exact("src/a.py::same", "src/a.py::same", old, new) |
| 152 | # Same name, same body, different metadata_id → metadata_only |
| 153 | assert result == "metadata_only" |
| 154 | |
| 155 | |
| 156 | # --------------------------------------------------------------------------- |
| 157 | # classify_exact — move (different file) |
| 158 | # --------------------------------------------------------------------------- |
| 159 | |
| 160 | |
| 161 | class TestClassifyExactMove: |
| 162 | def test_same_content_id_different_file_same_name(self) -> None: |
| 163 | rec = _rec(name="compute", content_id="shared_content_id_abc") |
| 164 | result = classify_exact("src/billing.py::compute", "src/invoice.py::compute", rec, rec) |
| 165 | assert result == "unchanged" # same content_id = unchanged regardless of file |
| 166 | |
| 167 | def test_same_body_same_name_different_file(self) -> None: |
| 168 | body = _sha("body") |
| 169 | sig = _sha("sig") |
| 170 | old = SymbolRecord( |
| 171 | kind="function", name="compute", qualified_name="compute", |
| 172 | lineno=1, end_lineno=10, |
| 173 | content_id=_sha(body + sig + "old"), |
| 174 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 175 | ) |
| 176 | new = SymbolRecord( |
| 177 | kind="function", name="compute", qualified_name="compute", |
| 178 | lineno=20, end_lineno=30, |
| 179 | content_id=_sha(body + sig + "new"), |
| 180 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 181 | ) |
| 182 | result = classify_exact("src/billing.py::compute", "src/invoice.py::compute", old, new) |
| 183 | assert result == "move" |
| 184 | |
| 185 | def test_same_body_different_name_different_file(self) -> None: |
| 186 | body = _sha("body") |
| 187 | sig = _sha("sig") |
| 188 | old = SymbolRecord( |
| 189 | kind="function", name="compute_total", qualified_name="compute_total", |
| 190 | lineno=1, end_lineno=10, |
| 191 | content_id=_sha(body + sig + "old"), |
| 192 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 193 | ) |
| 194 | new = SymbolRecord( |
| 195 | kind="function", name="invoice_total", qualified_name="invoice_total", |
| 196 | lineno=5, end_lineno=15, |
| 197 | content_id=_sha(body + sig + "new"), |
| 198 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 199 | ) |
| 200 | result = classify_exact("src/billing.py::compute_total", "src/invoice.py::invoice_total", old, new) |
| 201 | assert result == "rename+move" |
| 202 | |
| 203 | |
| 204 | # --------------------------------------------------------------------------- |
| 205 | # classify_exact — signature_only / impl_only / metadata_only / full_rewrite |
| 206 | # --------------------------------------------------------------------------- |
| 207 | |
| 208 | |
| 209 | class TestClassifyExactKinds: |
| 210 | def _make_pair( |
| 211 | self, |
| 212 | *, |
| 213 | same_body: bool = True, |
| 214 | same_sig: bool = True, |
| 215 | same_meta: bool = True, |
| 216 | ) -> tuple[SymbolRecord, SymbolRecord]: |
| 217 | body = _sha("body_data") |
| 218 | sig = _sha("sig_data") |
| 219 | meta = _sha("meta_data") |
| 220 | old = SymbolRecord( |
| 221 | kind="function", name="f", qualified_name="f", |
| 222 | lineno=1, end_lineno=10, |
| 223 | content_id=_sha(body + sig + meta), |
| 224 | body_hash=body, signature_id=sig, metadata_id=meta, canonical_key="", |
| 225 | ) |
| 226 | new_body = body if same_body else _sha("body_data_changed") |
| 227 | new_sig = sig if same_sig else _sha("sig_data_changed") |
| 228 | new_meta = meta if same_meta else _sha("meta_data_changed") |
| 229 | new = SymbolRecord( |
| 230 | kind="function", name="f", qualified_name="f", |
| 231 | lineno=1, end_lineno=10, |
| 232 | content_id=_sha(new_body + new_sig + new_meta + "x"), |
| 233 | body_hash=new_body, signature_id=new_sig, metadata_id=new_meta, canonical_key="", |
| 234 | ) |
| 235 | return old, new |
| 236 | |
| 237 | def test_signature_only(self) -> None: |
| 238 | old, new = self._make_pair(same_body=True, same_sig=False) |
| 239 | result = classify_exact("a.py::f", "a.py::f", old, new) |
| 240 | assert result == "signature_only" |
| 241 | |
| 242 | def test_impl_only(self) -> None: |
| 243 | old, new = self._make_pair(same_body=False, same_sig=True) |
| 244 | result = classify_exact("a.py::f", "a.py::f", old, new) |
| 245 | assert result == "impl_only" |
| 246 | |
| 247 | def test_metadata_only(self) -> None: |
| 248 | old, new = self._make_pair(same_body=True, same_sig=True, same_meta=False) |
| 249 | result = classify_exact("a.py::f", "a.py::f", old, new) |
| 250 | assert result == "metadata_only" |
| 251 | |
| 252 | def test_full_rewrite(self) -> None: |
| 253 | old, new = self._make_pair(same_body=False, same_sig=False) |
| 254 | result = classify_exact("a.py::f", "a.py::f", old, new) |
| 255 | assert result == "full_rewrite" |
| 256 | |
| 257 | |
| 258 | # --------------------------------------------------------------------------- |
| 259 | # RefactorClassification — to_dict |
| 260 | # --------------------------------------------------------------------------- |
| 261 | |
| 262 | |
| 263 | class TestRefactorClassificationToDict: |
| 264 | def test_to_dict_contains_required_keys(self) -> None: |
| 265 | old = _rec(name="f") |
| 266 | new = _rec(name="g") |
| 267 | rc = RefactorClassification( |
| 268 | old_address="src/a.py::f", |
| 269 | new_address="src/a.py::g", |
| 270 | old_rec=old, |
| 271 | new_rec=new, |
| 272 | exact="rename", |
| 273 | inferred="none", |
| 274 | confidence=1.0, |
| 275 | evidence=["body_hash matches abc12345"], |
| 276 | ) |
| 277 | d = rc.to_dict() |
| 278 | assert d["old_address"] == "src/a.py::f" |
| 279 | assert d["new_address"] == "src/a.py::g" |
| 280 | assert d["exact_classification"] == "rename" |
| 281 | assert d["inferred_refactor"] == "none" |
| 282 | assert d["confidence"] == 1.0 |
| 283 | assert d["evidence"] == ["body_hash matches abc12345"] |
| 284 | |
| 285 | def test_to_dict_truncates_hashes(self) -> None: |
| 286 | old = _rec(name="f", content_id="a" * 64, body_hash="b" * 64, signature_id="c" * 64) |
| 287 | new = _rec(name="g", content_id="d" * 64, body_hash="b" * 64, signature_id="c" * 64) |
| 288 | rc = RefactorClassification("a.py::f", "a.py::g", old, new, "rename") |
| 289 | d = rc.to_dict() |
| 290 | assert len(str(d["old_content_id"])) == 8 |
| 291 | assert len(str(d["new_content_id"])) == 8 |
| 292 | |
| 293 | def test_to_dict_confidence_rounded(self) -> None: |
| 294 | old = _rec(name="f") |
| 295 | new = _rec(name="g") |
| 296 | rc = RefactorClassification("a.py::f", "a.py::g", old, new, "full_rewrite", |
| 297 | confidence=0.123456789) |
| 298 | d = rc.to_dict() |
| 299 | assert d["confidence"] == 0.123 |
| 300 | |
| 301 | def test_default_evidence_is_empty_list(self) -> None: |
| 302 | old = _rec(name="f") |
| 303 | new = _rec(name="g") |
| 304 | rc = RefactorClassification("a.py::f", "a.py::g", old, new, "impl_only") |
| 305 | assert rc.evidence == [] |
| 306 | d = rc.to_dict() |
| 307 | assert d["evidence"] == [] |
| 308 | |
| 309 | |
| 310 | # --------------------------------------------------------------------------- |
| 311 | # classify_composite — exact detection |
| 312 | # --------------------------------------------------------------------------- |
| 313 | |
| 314 | |
| 315 | class TestClassifyCompositeExact: |
| 316 | def test_rename_detected(self) -> None: |
| 317 | body = _sha("shared_body") |
| 318 | sig = _sha("sig") |
| 319 | old_rec = SymbolRecord( |
| 320 | kind="function", name="old_func", qualified_name="old_func", |
| 321 | lineno=1, end_lineno=10, |
| 322 | content_id=_sha(body + sig + ""), |
| 323 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 324 | ) |
| 325 | new_rec = SymbolRecord( |
| 326 | kind="function", name="new_func", qualified_name="new_func", |
| 327 | lineno=1, end_lineno=10, |
| 328 | content_id=_sha(body + sig + "changed"), |
| 329 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 330 | ) |
| 331 | removed = {"src/a.py::old_func": old_rec} |
| 332 | added = {"src/a.py::new_func": new_rec} |
| 333 | results = classify_composite(removed, added) |
| 334 | assert len(results) == 1 |
| 335 | rc = results[0] |
| 336 | assert rc.exact == "rename" |
| 337 | assert rc.old_address == "src/a.py::old_func" |
| 338 | assert rc.new_address == "src/a.py::new_func" |
| 339 | |
| 340 | def test_move_detected_via_content_id(self) -> None: |
| 341 | content_id = _sha("exact_content") |
| 342 | rec = _rec(name="compute", content_id=content_id) |
| 343 | removed = {"src/billing.py::compute": rec} |
| 344 | added = {"src/invoice.py::compute": rec} |
| 345 | results = classify_composite(removed, added) |
| 346 | assert len(results) == 1 |
| 347 | rc = results[0] |
| 348 | assert rc.exact == "unchanged" # content_id match → unchanged classification |
| 349 | assert rc.old_address == "src/billing.py::compute" |
| 350 | assert rc.new_address == "src/invoice.py::compute" |
| 351 | |
| 352 | def test_empty_inputs(self) -> None: |
| 353 | assert classify_composite({}, {}) == [] |
| 354 | |
| 355 | def test_no_match_different_everything(self) -> None: |
| 356 | old_rec = _rec(name="alpha", body_hash=_sha("alpha_body")) |
| 357 | new_rec = _rec(name="beta", body_hash=_sha("beta_body")) |
| 358 | removed = {"a.py::alpha": old_rec} |
| 359 | added = {"b.py::beta": new_rec} |
| 360 | # No body_hash or content_id match → composite heuristics run |
| 361 | results = classify_composite(removed, added) |
| 362 | # alpha / beta are completely different — expect no high-confidence result |
| 363 | # (name heuristic may or may not fire, but should not crash) |
| 364 | assert isinstance(results, list) |
| 365 | |
| 366 | def test_rename_plus_move(self) -> None: |
| 367 | body = _sha("shared_body_cross") |
| 368 | sig = _sha("cross_sig") |
| 369 | old_rec = SymbolRecord( |
| 370 | kind="function", name="compute_a", qualified_name="compute_a", |
| 371 | lineno=1, end_lineno=8, |
| 372 | content_id=_sha(body + sig + "old"), |
| 373 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 374 | ) |
| 375 | new_rec = SymbolRecord( |
| 376 | kind="function", name="compute_b", qualified_name="compute_b", |
| 377 | lineno=20, end_lineno=28, |
| 378 | content_id=_sha(body + sig + "new"), |
| 379 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 380 | ) |
| 381 | removed = {"src/a.py::compute_a": old_rec} |
| 382 | added = {"src/b.py::compute_b": new_rec} |
| 383 | results = classify_composite(removed, added) |
| 384 | assert len(results) == 1 |
| 385 | assert results[0].exact == "rename+move" |
| 386 | |
| 387 | def test_multiple_renames_at_once(self) -> None: |
| 388 | def _pair(name: str) -> tuple[SymbolRecord, SymbolRecord]: |
| 389 | body = _sha(f"body_{name}") |
| 390 | sig = _sha(f"sig_{name}") |
| 391 | old = SymbolRecord( |
| 392 | kind="function", name=f"old_{name}", qualified_name=f"old_{name}", |
| 393 | lineno=1, end_lineno=5, |
| 394 | content_id=_sha(body + sig + "old"), |
| 395 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 396 | ) |
| 397 | new = SymbolRecord( |
| 398 | kind="function", name=f"new_{name}", qualified_name=f"new_{name}", |
| 399 | lineno=1, end_lineno=5, |
| 400 | content_id=_sha(body + sig + "new"), |
| 401 | body_hash=body, signature_id=sig, metadata_id="", canonical_key="", |
| 402 | ) |
| 403 | return old, new |
| 404 | |
| 405 | old_a, new_a = _pair("alpha") |
| 406 | old_b, new_b = _pair("beta") |
| 407 | removed = {"a.py::old_alpha": old_a, "a.py::old_beta": old_b} |
| 408 | added = {"a.py::new_alpha": new_a, "a.py::new_beta": new_b} |
| 409 | results = classify_composite(removed, added) |
| 410 | assert len(results) == 2 |
| 411 | old_addresses = {r.old_address for r in results} |
| 412 | assert "a.py::old_alpha" in old_addresses |
| 413 | assert "a.py::old_beta" in old_addresses |
| 414 | |
| 415 | |
| 416 | # --------------------------------------------------------------------------- |
| 417 | # classify_composite — inferred extract |
| 418 | # --------------------------------------------------------------------------- |
| 419 | |
| 420 | |
| 421 | class TestClassifyCompositeInferred: |
| 422 | def test_extract_heuristic_name_overlap(self) -> None: |
| 423 | # Old function "compute_total" is deleted; new function "compute" appears. |
| 424 | # "compute" is a substring of "compute_total" → extract heuristic fires. |
| 425 | old_rec = _rec(name="compute_total", qualified_name="compute_total") |
| 426 | new_rec = _rec(name="compute", qualified_name="compute") |
| 427 | removed = {"a.py::compute_total": old_rec} |
| 428 | added = {"a.py::compute": new_rec} |
| 429 | results = classify_composite(removed, added) |
| 430 | extract_results = [r for r in results if r.inferred == "extract"] |
| 431 | # The heuristic may or may not fire depending on exact name overlap. |
| 432 | # Verify no crash and the structure is correct. |
| 433 | for r in extract_results: |
| 434 | assert r.confidence >= 0.0 |
| 435 | assert isinstance(r.evidence, list) |