wehub-resource-sync
902 lines
36 KiB
Python
902 lines
36 KiB
Python
"""Tests for graph-powered refactoring operations."""
|
|
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
from code_review_graph.graph import GraphStore
|
|
from code_review_graph.parser import CodeParser, EdgeInfo, NodeInfo
|
|
from code_review_graph.refactor import (
|
|
REFACTOR_EXPIRY_SECONDS,
|
|
_pending_refactors,
|
|
_refactor_lock,
|
|
apply_refactor,
|
|
find_dead_code,
|
|
rename_preview,
|
|
suggest_refactorings,
|
|
)
|
|
|
|
|
|
class TestRenamePreview:
|
|
"""Tests for rename_preview."""
|
|
|
|
def setup_method(self):
|
|
self.tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
self.store = GraphStore(self.tmp.name)
|
|
self._seed()
|
|
|
|
def teardown_method(self):
|
|
self.store.close()
|
|
Path(self.tmp.name).unlink(missing_ok=True)
|
|
# Clean up pending refactors.
|
|
with _refactor_lock:
|
|
_pending_refactors.clear()
|
|
|
|
def _seed(self):
|
|
"""Seed the store with test data for rename tests."""
|
|
# File nodes
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name="/repo/utils.py", file_path="/repo/utils.py",
|
|
line_start=1, line_end=50, language="python",
|
|
))
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name="/repo/main.py", file_path="/repo/main.py",
|
|
line_start=1, line_end=30, language="python",
|
|
))
|
|
# Function to rename
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="helper", file_path="/repo/utils.py",
|
|
line_start=10, line_end=20, language="python",
|
|
))
|
|
# Caller function
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="run", file_path="/repo/main.py",
|
|
line_start=5, line_end=15, language="python",
|
|
))
|
|
# CALLS edge: run -> helper
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="CALLS", source="/repo/main.py::run",
|
|
target="/repo/utils.py::helper", file_path="/repo/main.py", line=10,
|
|
))
|
|
# IMPORTS_FROM edge: main.py imports helper
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="IMPORTS_FROM", source="/repo/main.py",
|
|
target="/repo/utils.py::helper", file_path="/repo/main.py", line=1,
|
|
))
|
|
self.store.commit()
|
|
|
|
def test_rename_preview_returns_edits_with_refactor_id(self):
|
|
"""rename_preview returns a dict with refactor_id and edits."""
|
|
result = rename_preview(self.store, "helper", "new_helper")
|
|
assert result is not None
|
|
assert "refactor_id" in result
|
|
assert len(result["refactor_id"]) == 8
|
|
assert result["type"] == "rename"
|
|
assert result["old_name"] == "helper"
|
|
assert result["new_name"] == "new_helper"
|
|
assert isinstance(result["edits"], list)
|
|
assert len(result["edits"]) > 0
|
|
assert "stats" in result
|
|
assert result["stats"]["high"] > 0
|
|
|
|
def test_rename_finds_callers(self):
|
|
"""rename_preview finds definition + call sites."""
|
|
result = rename_preview(self.store, "helper", "new_helper")
|
|
assert result is not None
|
|
edits = result["edits"]
|
|
# Should have at least: 1 definition + 1 call + 1 import = 3
|
|
assert len(edits) >= 3
|
|
files = {e["file"] for e in edits}
|
|
assert "/repo/utils.py" in files # definition
|
|
assert "/repo/main.py" in files # call site + import site
|
|
|
|
def test_rename_not_found(self):
|
|
"""rename_preview returns None if symbol not found."""
|
|
result = rename_preview(self.store, "nonexistent_function", "new_name")
|
|
assert result is None
|
|
|
|
def test_rename_stores_in_pending(self):
|
|
"""rename_preview stores the preview in _pending_refactors."""
|
|
result = rename_preview(self.store, "helper", "new_helper")
|
|
assert result is not None
|
|
rid = result["refactor_id"]
|
|
with _refactor_lock:
|
|
assert rid in _pending_refactors
|
|
|
|
|
|
class TestFindDeadCode:
|
|
"""Tests for find_dead_code."""
|
|
|
|
def setup_method(self):
|
|
self.tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
self.store = GraphStore(self.tmp.name)
|
|
self._seed()
|
|
|
|
def teardown_method(self):
|
|
self.store.close()
|
|
Path(self.tmp.name).unlink(missing_ok=True)
|
|
|
|
def _seed(self):
|
|
"""Seed with a mix of used and unused functions."""
|
|
# File
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name="/repo/app.py", file_path="/repo/app.py",
|
|
line_start=1, line_end=100, language="python",
|
|
))
|
|
# A function that IS called
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="used_func", file_path="/repo/app.py",
|
|
line_start=10, line_end=20, language="python",
|
|
))
|
|
# A function that is NOT called (dead code)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="dead_func", file_path="/repo/app.py",
|
|
line_start=30, line_end=40, language="python",
|
|
))
|
|
# An entry point function (should be excluded)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="main", file_path="/repo/app.py",
|
|
line_start=50, line_end=60, language="python",
|
|
))
|
|
# A test function (should be excluded)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Test", name="test_something", file_path="/repo/test_app.py",
|
|
line_start=1, line_end=10, language="python", is_test=True,
|
|
))
|
|
|
|
# Caller for used_func
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="caller", file_path="/repo/app.py",
|
|
line_start=70, line_end=80, language="python",
|
|
))
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="CALLS", source="/repo/app.py::caller",
|
|
target="/repo/app.py::used_func", file_path="/repo/app.py", line=75,
|
|
))
|
|
self.store.commit()
|
|
|
|
def test_find_dead_code(self):
|
|
"""find_dead_code detects unreferenced functions."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "dead_func" in dead_names
|
|
|
|
def test_find_dead_code_response_fields(self):
|
|
"""dead_code entries include file_path, relative_path, and language."""
|
|
dead = find_dead_code(self.store, root="/repo")
|
|
entry = next(d for d in dead if d["name"] == "dead_func")
|
|
assert entry["file_path"] == "/repo/app.py"
|
|
assert entry["relative_path"] == "app.py"
|
|
assert entry["language"] == "python"
|
|
# backward compat: 'file' key still present
|
|
assert entry["file"] == "/repo/app.py"
|
|
|
|
def test_find_dead_code_relative_path_without_root(self):
|
|
"""Without root, relative_path falls back to file_path."""
|
|
dead = find_dead_code(self.store)
|
|
entry = next(d for d in dead if d["name"] == "dead_func")
|
|
assert entry["relative_path"] == "/repo/app.py"
|
|
|
|
def test_find_dead_code_excludes_called(self):
|
|
"""find_dead_code does NOT include functions with callers."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "used_func" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_entry_points(self):
|
|
"""Entry points (like 'main') are not flagged as dead code."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "main" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_tests(self):
|
|
"""Test nodes are not flagged as dead code."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "test_something" not in dead_names
|
|
|
|
def test_find_dead_code_kind_filter(self):
|
|
"""kind filter restricts results."""
|
|
dead = find_dead_code(self.store, kind="Class")
|
|
# We have no Class nodes, so should be empty
|
|
assert len(dead) == 0
|
|
|
|
def test_find_dead_code_file_pattern(self):
|
|
"""file_pattern filter works."""
|
|
dead = find_dead_code(self.store, file_pattern="nonexistent")
|
|
assert len(dead) == 0
|
|
|
|
def test_find_dead_code_excludes_dunder(self):
|
|
"""Dunder methods are not flagged as dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="__init__", file_path="/repo/app.py",
|
|
line_start=90, line_end=95, language="python",
|
|
parent_name="MyClass",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "__init__" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_constructor(self):
|
|
"""JS/TS constructors are not flagged as dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="constructor", file_path="/repo/component.ts",
|
|
line_start=10, line_end=15, language="typescript",
|
|
parent_name="MyComponent",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "constructor" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_angular_lifecycle(self):
|
|
"""Angular lifecycle hooks are not flagged as dead code."""
|
|
for name in ("ngOnInit", "ngOnChanges", "ngOnDestroy", "transform",
|
|
"writeValue", "canActivate"):
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name=name, file_path="/repo/component.ts",
|
|
line_start=10, line_end=15, language="typescript",
|
|
parent_name="MyComponent",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
for name in ("ngOnInit", "ngOnChanges", "ngOnDestroy", "transform",
|
|
"writeValue", "canActivate"):
|
|
assert name not in dead_names, f"{name} should not be dead"
|
|
|
|
def test_find_dead_code_excludes_decorated_entry(self):
|
|
"""Functions with framework decorators are not flagged as dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="get_users", file_path="/repo/app.py",
|
|
line_start=90, line_end=95, language="python",
|
|
extra={"decorators": ["app.get('/users')"]},
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "get_users" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_type_referenced_class(self):
|
|
"""Classes referenced in function type annotations are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="UserSchema", file_path="/repo/app.py",
|
|
line_start=5, line_end=15, language="python",
|
|
))
|
|
# A function that uses UserSchema in its params
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="create_user", file_path="/repo/app.py",
|
|
line_start=20, line_end=30, language="python",
|
|
params="body: UserSchema",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "UserSchema" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_return_type_reference(self):
|
|
"""Classes referenced in return types are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="UserResponse", file_path="/repo/app.py",
|
|
line_start=5, line_end=15, language="python",
|
|
))
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="get_user", file_path="/repo/app.py",
|
|
line_start=20, line_end=30, language="python",
|
|
return_type="Optional[UserResponse]",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "UserResponse" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_orm_model(self):
|
|
"""Classes inheriting from known ORM bases are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="User", file_path="/repo/app.py",
|
|
line_start=5, line_end=20, language="python",
|
|
))
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="INHERITS", source="/repo/app.py::User",
|
|
target="Base", file_path="/repo/app.py", line=5,
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "User" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_pydantic_settings(self):
|
|
"""Classes inheriting from BaseSettings are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="AppConfig", file_path="/repo/app.py",
|
|
line_start=5, line_end=15, language="python",
|
|
))
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="INHERITS", source="/repo/app.py::AppConfig",
|
|
target="BaseSettings", file_path="/repo/app.py", line=5,
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "AppConfig" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_agent_tool(self):
|
|
"""Functions with @agent.tool decorator are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="query_data", file_path="/repo/app.py",
|
|
line_start=10, line_end=20, language="python",
|
|
extra={"decorators": ["health_agent.tool"]},
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "query_data" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_alembic_upgrade(self):
|
|
"""upgrade() and downgrade() in alembic files are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="upgrade", file_path="/repo/alembic/versions/001.py",
|
|
line_start=5, line_end=15, language="python",
|
|
))
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="downgrade", file_path="/repo/alembic/versions/001.py",
|
|
line_start=20, line_end=30, language="python",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "upgrade" not in dead_names
|
|
assert "downgrade" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_subclassed_class(self):
|
|
"""Classes with subclasses (INHERITS edges) are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="BaseConnector", file_path="/repo/connectors.py",
|
|
line_start=5, line_end=50, language="python",
|
|
))
|
|
# A subclass inherits from BaseConnector (bare-name target)
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="INHERITS", source="/repo/connectors.py::GarminConnector",
|
|
target="BaseConnector", file_path="/repo/connectors.py", line=60,
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "BaseConnector" not in dead_names
|
|
|
|
def test_find_dead_code_bare_name_not_tricked_by_unrelated_caller(self):
|
|
"""Bare-name CALLS from unrelated files don't save a dead function
|
|
when there are multiple definitions with the same name."""
|
|
# Two unrelated functions named "processor" in different files
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="processor", file_path="/repo/api/routes.py",
|
|
line_start=10, line_end=20, language="python",
|
|
))
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="processor", file_path="/repo/worker/tasks.py",
|
|
line_start=10, line_end=20, language="python",
|
|
))
|
|
# A bare CALLS edge from a third file that imports only routes.py
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="IMPORTS_FROM", source="/repo/main.py",
|
|
target="/repo/api/routes.py", file_path="/repo/main.py", line=1,
|
|
))
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="CALLS", source="/repo/main.py::start",
|
|
target="processor", file_path="/repo/main.py", line=10,
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_qnames = {d["qualified_name"] for d in dead}
|
|
# routes.py processor is saved (caller imports its file)
|
|
assert "/repo/api/routes.py::processor" not in dead_qnames
|
|
# worker/tasks.py processor is dead (no relationship with caller)
|
|
assert "/repo/worker/tasks.py::processor" in dead_qnames
|
|
|
|
def test_find_dead_code_excludes_mock_variables(self):
|
|
"""Mock/stub variables in test files are not flagged as dead code."""
|
|
for name in ("mockDynamoClient", "s3ClientMock", "MockService", "createMockRequest"):
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name=name, file_path="/repo/tests/handler.spec.ts",
|
|
line_start=10, line_end=15, language="typescript",
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
for name in ("mockDynamoClient", "s3ClientMock", "MockService", "createMockRequest"):
|
|
assert name not in dead_names, f"{name} should not be dead (mock pattern)"
|
|
|
|
def test_find_dead_code_excludes_angular_decorated_class(self):
|
|
"""Angular @Component classes are not flagged as dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Class", name="ClipboardButtonComponent",
|
|
file_path="/repo/src/app/clipboard.component.ts",
|
|
line_start=5, line_end=50, language="typescript",
|
|
extra={"decorators": ["Component({selector: 'app-clipboard'})"]},
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "ClipboardButtonComponent" not in dead_names
|
|
|
|
def test_find_dead_code_excludes_property(self):
|
|
"""Functions decorated with @property are not dead code."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="db", file_path="/repo/deps.py",
|
|
line_start=10, line_end=15, language="python",
|
|
extra={"decorators": ["property"]},
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "db" not in dead_names
|
|
|
|
|
|
class TestSuggestRefactorings:
|
|
"""Tests for suggest_refactorings."""
|
|
|
|
def setup_method(self):
|
|
self.tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
self.store = GraphStore(self.tmp.name)
|
|
self._seed()
|
|
|
|
def teardown_method(self):
|
|
self.store.close()
|
|
Path(self.tmp.name).unlink(missing_ok=True)
|
|
|
|
def _seed(self):
|
|
"""Seed with dead code to generate suggestions."""
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name="/repo/lib.py", file_path="/repo/lib.py",
|
|
line_start=1, line_end=50, language="python",
|
|
))
|
|
# Unreferenced function -> removal suggestion
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="orphan_func", file_path="/repo/lib.py",
|
|
line_start=10, line_end=20, language="python",
|
|
))
|
|
self.store.commit()
|
|
|
|
def test_suggest_refactorings(self):
|
|
"""suggest_refactorings returns a list of suggestions."""
|
|
suggestions = suggest_refactorings(self.store)
|
|
assert isinstance(suggestions, list)
|
|
# Should have at least the dead-code removal suggestion
|
|
assert len(suggestions) >= 1
|
|
types = {s["type"] for s in suggestions}
|
|
assert "remove" in types
|
|
|
|
def test_suggestion_structure(self):
|
|
"""Each suggestion has the required fields."""
|
|
suggestions = suggest_refactorings(self.store)
|
|
for s in suggestions:
|
|
assert "type" in s
|
|
assert "description" in s
|
|
assert "symbols" in s
|
|
assert "rationale" in s
|
|
assert s["type"] in ("move", "remove")
|
|
|
|
|
|
class TestApplyRefactor:
|
|
"""Tests for apply_refactor."""
|
|
|
|
def setup_method(self):
|
|
with _refactor_lock:
|
|
_pending_refactors.clear()
|
|
|
|
def teardown_method(self):
|
|
with _refactor_lock:
|
|
_pending_refactors.clear()
|
|
|
|
def test_apply_refactor_validates_id(self):
|
|
"""apply_refactor rejects nonexistent refactor_id."""
|
|
# Use a real temp dir as repo_root (needs .git or .code-review-graph)
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
try:
|
|
result = apply_refactor("nonexistent_id", tmp_dir)
|
|
assert result["status"] == "error"
|
|
assert "not found" in result["error"].lower() or "expired" in result["error"].lower()
|
|
finally:
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
def test_apply_refactor_expiry(self):
|
|
"""apply_refactor rejects expired previews."""
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
try:
|
|
# Insert a preview that is already expired.
|
|
rid = "expired1"
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"type": "rename",
|
|
"old_name": "old",
|
|
"new_name": "new",
|
|
"edits": [],
|
|
"stats": {"high": 0, "medium": 0, "low": 0},
|
|
"created_at": time.time() - REFACTOR_EXPIRY_SECONDS - 10,
|
|
}
|
|
result = apply_refactor(rid, tmp_dir)
|
|
assert result["status"] == "error"
|
|
assert "expired" in result["error"].lower()
|
|
finally:
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
def test_apply_refactor_path_traversal(self):
|
|
"""apply_refactor blocks edits outside repo root."""
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
try:
|
|
rid = "traversal"
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"type": "rename",
|
|
"old_name": "old",
|
|
"new_name": "new",
|
|
"edits": [{
|
|
"file": "/etc/passwd",
|
|
"line": 1,
|
|
"old": "old",
|
|
"new": "new",
|
|
"confidence": "high",
|
|
}],
|
|
"stats": {"high": 1, "medium": 0, "low": 0},
|
|
"created_at": time.time(),
|
|
}
|
|
result = apply_refactor(rid, tmp_dir)
|
|
assert result["status"] == "error"
|
|
assert "outside repo root" in result["error"].lower()
|
|
finally:
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
def test_apply_refactor_success(self):
|
|
"""apply_refactor applies string replacement to a real file."""
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
target_file = tmp_dir / "example.py"
|
|
target_file.write_text("def old_func():\n pass\n", encoding="utf-8")
|
|
try:
|
|
rid = "success1"
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"type": "rename",
|
|
"old_name": "old_func",
|
|
"new_name": "new_func",
|
|
"edits": [{
|
|
"file": str(target_file),
|
|
"line": 1,
|
|
"old": "old_func",
|
|
"new": "new_func",
|
|
"confidence": "high",
|
|
}],
|
|
"stats": {"high": 1, "medium": 0, "low": 0},
|
|
"created_at": time.time(),
|
|
}
|
|
result = apply_refactor(rid, tmp_dir)
|
|
assert result["status"] == "ok"
|
|
assert result["edits_applied"] == 1
|
|
assert len(result["files_modified"]) == 1
|
|
# Verify file content was changed.
|
|
content = target_file.read_text(encoding="utf-8")
|
|
assert "new_func" in content
|
|
assert "old_func" not in content
|
|
finally:
|
|
target_file.unlink(missing_ok=True)
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
def test_apply_refactor_dry_run_returns_diff_without_writing(self):
|
|
"""dry_run=True returns a unified diff without touching disk and
|
|
keeps the refactor_id valid for a follow-up write (#176)."""
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
target_file = tmp_dir / "example.py"
|
|
original = "def old_func():\n pass\n"
|
|
target_file.write_text(original, encoding="utf-8")
|
|
try:
|
|
rid = "dryrun1"
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"type": "rename",
|
|
"old_name": "old_func",
|
|
"new_name": "new_func",
|
|
"edits": [{
|
|
"file": str(target_file),
|
|
"line": 1,
|
|
"old": "old_func",
|
|
"new": "new_func",
|
|
"confidence": "high",
|
|
}],
|
|
"stats": {"high": 1, "medium": 0, "low": 0},
|
|
"created_at": time.time(),
|
|
}
|
|
|
|
# Step 1: dry_run — no writes, returns diff
|
|
result = apply_refactor(rid, tmp_dir, dry_run=True)
|
|
assert result["status"] == "ok"
|
|
assert result["dry_run"] is True
|
|
assert result["edits_applied"] == 1
|
|
assert len(result["would_modify"]) == 1
|
|
assert result["files_modified"] == [] # nothing written yet
|
|
assert str(target_file) in result["would_modify"]
|
|
# Diff should mention both the old and new name
|
|
diff = result["diffs"][str(target_file)]
|
|
assert "-def old_func():" in diff
|
|
assert "+def new_func():" in diff
|
|
# File on disk must be unchanged
|
|
assert target_file.read_text(encoding="utf-8") == original
|
|
|
|
# Step 2: refactor_id should still be valid — dry_run doesn't consume it
|
|
with _refactor_lock:
|
|
assert rid in _pending_refactors
|
|
|
|
# Step 3: real apply — uses same refactor_id
|
|
real_result = apply_refactor(rid, tmp_dir, dry_run=False)
|
|
assert real_result["status"] == "ok"
|
|
assert real_result.get("dry_run") is None # not set on the real path
|
|
assert real_result["edits_applied"] == 1
|
|
assert len(real_result["files_modified"]) == 1
|
|
# File content changed
|
|
new_content = target_file.read_text(encoding="utf-8")
|
|
assert "new_func" in new_content
|
|
assert "old_func" not in new_content
|
|
|
|
# refactor_id consumed after real apply
|
|
with _refactor_lock:
|
|
assert rid not in _pending_refactors
|
|
finally:
|
|
target_file.unlink(missing_ok=True)
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
def test_apply_refactor_dry_run_no_edits(self):
|
|
"""dry_run with an empty edit list returns an empty diff dict."""
|
|
tmp_dir = Path(tempfile.mkdtemp())
|
|
(tmp_dir / ".git").mkdir()
|
|
try:
|
|
rid = "dryrun-empty"
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"type": "rename",
|
|
"old_name": "x",
|
|
"new_name": "y",
|
|
"edits": [],
|
|
"stats": {"high": 0, "medium": 0, "low": 0},
|
|
"created_at": time.time(),
|
|
}
|
|
result = apply_refactor(rid, tmp_dir, dry_run=True)
|
|
assert result["status"] == "ok"
|
|
assert result["dry_run"] is True
|
|
assert result["would_modify"] == []
|
|
assert result["diffs"] == {}
|
|
finally:
|
|
with _refactor_lock:
|
|
_pending_refactors.pop("dryrun-empty", None)
|
|
(tmp_dir / ".git").rmdir()
|
|
tmp_dir.rmdir()
|
|
|
|
|
|
class TestPendingRefactorsThreadSafe:
|
|
"""Tests for thread-safety of the pending refactors storage."""
|
|
|
|
def test_pending_refactors_thread_safe(self):
|
|
"""The _refactor_lock is a threading.Lock instance."""
|
|
assert isinstance(_refactor_lock, type(threading.Lock()))
|
|
|
|
def test_concurrent_access(self):
|
|
"""Multiple threads can safely access _pending_refactors."""
|
|
results = []
|
|
|
|
def writer(rid: str):
|
|
with _refactor_lock:
|
|
_pending_refactors[rid] = {
|
|
"refactor_id": rid,
|
|
"created_at": time.time(),
|
|
}
|
|
results.append(rid)
|
|
|
|
threads = [threading.Thread(target=writer, args=(f"t{i}",)) for i in range(10)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
|
|
with _refactor_lock:
|
|
assert len(results) == 10
|
|
assert len(_pending_refactors) >= 10
|
|
# Clean up
|
|
_pending_refactors.clear()
|
|
|
|
|
|
class TestFindDeadCodeWithReferences:
|
|
"""Tests for REFERENCES-aware dead code detection."""
|
|
|
|
def setup_method(self):
|
|
self.tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
self.store = GraphStore(self.tmp.name)
|
|
self._seed()
|
|
|
|
def teardown_method(self):
|
|
self.store.close()
|
|
Path(self.tmp.name).unlink(missing_ok=True)
|
|
|
|
def _seed(self):
|
|
"""Seed with functions that have REFERENCES edges (map dispatch pattern)."""
|
|
# File
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name="/repo/handlers.ts", file_path="/repo/handlers.ts",
|
|
line_start=1, line_end=100, language="typescript",
|
|
))
|
|
# A function referenced in a map (should NOT be dead)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="handleCreate", file_path="/repo/handlers.ts",
|
|
line_start=10, line_end=20, language="typescript",
|
|
))
|
|
# A function with CALLS edge (should NOT be dead)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="calledFunc", file_path="/repo/handlers.ts",
|
|
line_start=30, line_end=40, language="typescript",
|
|
))
|
|
# A truly dead function (no edges at all)
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="deadFunc", file_path="/repo/handlers.ts",
|
|
line_start=50, line_end=60, language="typescript",
|
|
))
|
|
# Caller
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="dispatch", file_path="/repo/handlers.ts",
|
|
line_start=70, line_end=80, language="typescript",
|
|
))
|
|
# REFERENCES edge: dispatch -> handleCreate (map dispatch pattern)
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="REFERENCES", source="/repo/handlers.ts::dispatch",
|
|
target="/repo/handlers.ts::handleCreate",
|
|
file_path="/repo/handlers.ts", line=75,
|
|
))
|
|
# CALLS edge: dispatch -> calledFunc
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="CALLS", source="/repo/handlers.ts::dispatch",
|
|
target="/repo/handlers.ts::calledFunc",
|
|
file_path="/repo/handlers.ts", line=76,
|
|
))
|
|
self.store.commit()
|
|
|
|
def test_referenced_function_not_dead(self):
|
|
"""Functions with REFERENCES edges should NOT be flagged as dead code."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "handleCreate" not in dead_names
|
|
|
|
def test_called_function_not_dead(self):
|
|
"""Functions with CALLS edges remain excluded (existing behavior)."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "calledFunc" not in dead_names
|
|
|
|
def test_truly_dead_function_still_reported(self):
|
|
"""Functions with no edges at all should still be flagged as dead code."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "deadFunc" in dead_names
|
|
|
|
def test_only_references_edge_sufficient(self):
|
|
"""A function with ONLY a REFERENCES edge (no CALLS/IMPORTS) is not dead."""
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
# handleCreate has only a REFERENCES edge, no CALLS targeting it
|
|
assert "handleCreate" not in dead_names
|
|
|
|
|
|
class TestTransitiveImportResolution:
|
|
"""Tests for 2-hop transitive import resolution in plausible caller."""
|
|
|
|
def setup_method(self):
|
|
self.store = GraphStore(":memory:")
|
|
for f in ("/repo/consumer.ts", "/repo/lib/index.ts", "/repo/lib/utils.ts"):
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="File", name=f, file_path=f,
|
|
line_start=1, line_end=50, language="typescript",
|
|
))
|
|
|
|
def test_transitive_import_via_barrel_file(self):
|
|
"""consumer.ts imports index.ts which re-exports from utils.ts.
|
|
A bare-name CALLS from consumer.ts should be plausible for utils.ts functions."""
|
|
# Function defined in utils.ts
|
|
self.store.upsert_node(NodeInfo(
|
|
kind="Function", name="safeJsonParse",
|
|
file_path="/repo/lib/utils.ts",
|
|
line_start=10, line_end=20, language="typescript",
|
|
))
|
|
# Import chain: consumer -> index -> utils
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="IMPORTS_FROM", source="/repo/consumer.ts",
|
|
target="/repo/lib/index.ts", file_path="/repo/consumer.ts", line=1,
|
|
))
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="IMPORTS_FROM", source="/repo/lib/index.ts",
|
|
target="/repo/lib/utils.ts", file_path="/repo/lib/index.ts", line=1,
|
|
))
|
|
# Bare-name CALLS from consumer
|
|
self.store.upsert_edge(EdgeInfo(
|
|
kind="CALLS", source="/repo/consumer.ts::processData",
|
|
target="safeJsonParse", file_path="/repo/consumer.ts", line=5,
|
|
))
|
|
self.store.commit()
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "safeJsonParse" not in dead_names, (
|
|
"2-hop import chain should make consumer a plausible caller"
|
|
)
|
|
|
|
|
|
class TestFindDeadCodeModuleScope:
|
|
"""End-to-end regression: parse → store → find_dead_code.
|
|
|
|
Pins the contract that functions invoked only from module scope are not
|
|
flagged as dead. Bypasses the hand-built graph fixtures used elsewhere in
|
|
this file so that a regression in any of the parser's 5 module-scope
|
|
CALLS paths is caught.
|
|
"""
|
|
|
|
def setup_method(self):
|
|
self.tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
self.store = GraphStore(self.tmp.name)
|
|
self.parser = CodeParser()
|
|
|
|
def teardown_method(self):
|
|
self.store.close()
|
|
Path(self.tmp.name).unlink(missing_ok=True)
|
|
|
|
def _store_parsed(self, path: Path, source: bytes) -> None:
|
|
nodes, edges = self.parser.parse_bytes(path, source)
|
|
for n in nodes:
|
|
self.store.upsert_node(n)
|
|
for e in edges:
|
|
self.store.upsert_edge(e)
|
|
self.store.commit()
|
|
|
|
def test_module_scope_caller_prevents_dead_code_flag(self, tmp_path):
|
|
"""A function called only from top-level script glue is not dead."""
|
|
# ``run_job`` has no non-dunder name match and no framework decorator,
|
|
# so without the module-scope CALLS fix it would be flagged dead.
|
|
path = tmp_path / "script.py"
|
|
path.write_bytes(
|
|
b"def run_job():\n"
|
|
b" return 1\n"
|
|
b"\n"
|
|
b"run_job()\n"
|
|
)
|
|
self._store_parsed(path, path.read_bytes())
|
|
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "run_job" not in dead_names, (
|
|
"module-scope caller should prevent run_job from being flagged dead"
|
|
)
|
|
|
|
def test_if_main_block_caller_prevents_dead_code_flag(self, tmp_path):
|
|
"""A function called only inside ``if __name__ == '__main__'`` is not dead."""
|
|
path = tmp_path / "cli.py"
|
|
path.write_bytes(
|
|
b"def launch():\n"
|
|
b" return 1\n"
|
|
b"\n"
|
|
b"if __name__ == '__main__':\n"
|
|
b" launch()\n"
|
|
)
|
|
self._store_parsed(path, path.read_bytes())
|
|
|
|
dead = find_dead_code(self.store)
|
|
dead_names = {d["name"] for d in dead}
|
|
assert "launch" not in dead_names
|