"""Tests for hotspot detection module."""
from datetime import datetime, timedelta
from unittest.mock import Mock, patch
import pytest
from tenets.config import TenetsConfig
from tenets.core.examiner.hotspots import (
FileHotspot,
HotspotDetector,
HotspotMetrics,
HotspotReport,
ModuleHotspot,
detect_hotspots,
)
@pytest.fixture
def config():
"""Create test configuration."""
return TenetsConfig()
@pytest.fixture
def hotspot_detector(config):
"""Create HotspotDetector instance."""
return HotspotDetector(config)
@pytest.fixture
def sample_file_changes():
"""Create sample file change data."""
return {
"hot_file.py": {
"commit_count": 50,
"authors": {"alice@example.com", "bob@example.com", "charlie@example.com"},
"commits": [
{
"sha": f"abc{i:03d}",
"date": datetime.now() - timedelta(days=30 - i),
"message": f"Fix bug #{i}" if i % 3 == 0 else f"Add feature {i}",
"author": f"Author{i % 3}",
}
for i in range(50)
],
"lines_added": 500,
"lines_removed": 300,
"bug_fixes": 15,
"refactors": 5,
"coupled_files": {"related1.py": 10, "related2.py": 8, "related3.py": 5},
"first_commit": datetime.now() - timedelta(days=90),
"last_commit": datetime.now() - timedelta(days=1),
},
"stable_file.py": {
"commit_count": 5,
"authors": {"alice@example.com"},
"commits": [],
"lines_added": 100,
"lines_removed": 20,
"bug_fixes": 1,
"refactors": 0,
"coupled_files": {},
"first_commit": datetime.now() - timedelta(days=180),
"last_commit": datetime.now() - timedelta(days=60),
},
"complex_file.py": {
"commit_count": 30,
"authors": {f"dev{i}@example.com" for i in range(15)},
"commits": [],
"lines_added": 1000,
"lines_removed": 800,
"bug_fixes": 20,
"refactors": 10,
"coupled_files": {f"file{i}.py": i + 1 for i in range(10)},
"first_commit": datetime.now() - timedelta(days=60),
"last_commit": datetime.now() - timedelta(days=2),
},
}
class TestHotspotMetrics:
"""Test suite for HotspotMetrics dataclass."""
def test_hotspot_metrics_creation(self):
"""Test creating HotspotMetrics."""
metrics = HotspotMetrics(
change_frequency=0.5, commit_count=50, author_count=5, complexity=15.0
)
assert metrics.change_frequency == 0.5
assert metrics.commit_count == 50
assert metrics.author_count == 5
assert metrics.complexity == 15.0
def test_hotspot_score(self):
"""Test hotspot_score calculation."""
# Low score (stable file)
stable = HotspotMetrics(
change_frequency=0.05,
commit_count=5,
author_count=2,
complexity=5.0,
bug_fix_commits=0,
coupling=1,
)
stable_score = stable.hotspot_score
assert 0 <= stable_score <= 100
assert stable_score < 30
# High score (problematic file)
problematic = HotspotMetrics(
change_frequency=2.0,
commit_count=100,
author_count=10,
complexity=25.0,
bug_fix_commits=40,
coupling=15,
)
problematic_score = problematic.hotspot_score
assert problematic_score > stable_score
assert problematic_score > 50
def test_risk_level(self):
"""Test risk_level property."""
# Critical risk
critical = HotspotMetrics()
critical.change_frequency = 3.0
critical.complexity = 30.0
critical.commit_count = 100
critical.bug_fix_commits = 50
assert critical.risk_level == "critical"
# High risk
high = HotspotMetrics()
high.change_frequency = 1.0
high.complexity = 15.0
high.commit_count = 50
high.bug_fix_commits = 15
assert high.risk_level == "high"
# Medium risk
medium = HotspotMetrics()
medium.change_frequency = 0.3
medium.complexity = 8.0
assert medium.risk_level == "medium"
# Low risk
low = HotspotMetrics()
assert low.risk_level == "low"
def test_needs_attention(self):
"""Test needs_attention property."""
# Needs attention
critical = HotspotMetrics()
critical.change_frequency = 2.0
critical.complexity = 25.0
critical.commit_count = 50
critical.bug_fix_commits = 20
assert critical.needs_attention == True
# Doesn't need immediate attention
stable = HotspotMetrics()
stable.change_frequency = 0.1
stable.complexity = 5.0
assert stable.needs_attention == False
class TestFileHotspot:
"""Test suite for FileHotspot dataclass."""
def test_file_hotspot_creation(self):
"""Test creating FileHotspot."""
hotspot = FileHotspot(path="src/main.py", name="main.py", size=500, language="Python")
assert hotspot.path == "src/main.py"
assert hotspot.name == "main.py"
assert hotspot.size == 500
assert hotspot.language == "Python"
def test_summary(self):
"""Test summary property."""
hotspot = FileHotspot(path="hot.py", name="hot.py")
# Set problematic metrics
hotspot.metrics.change_frequency = 1.5
hotspot.metrics.complexity = 25.0
hotspot.metrics.bug_fix_commits = 10
hotspot.metrics.author_count = 15
summary = hotspot.summary
assert "hot.py" in summary
assert "changes" in summary
assert "complexity" in summary
assert "bug fixes" in summary
assert "authors" in summary
# Stable file
stable = FileHotspot(path="stable.py", name="stable.py")
stable_summary = stable.summary
assert "stable" in stable_summary
class TestModuleHotspot:
"""Test suite for ModuleHotspot dataclass."""
def test_module_hotspot_creation(self):
"""Test creating ModuleHotspot."""
module = ModuleHotspot(path="src/auth", name="auth", file_count=10)
assert module.path == "src/auth"
assert module.name == "auth"
assert module.file_count == 10
def test_hotspot_density(self):
"""Test hotspot_density property."""
module = ModuleHotspot(path="src", name="src", file_count=10)
# Add hotspot files
for i in range(3):
module.hotspot_files.append(FileHotspot(path=f"file{i}.py", name=f"file{i}.py"))
assert module.hotspot_density == 0.3
# No files
empty_module = ModuleHotspot(path="empty", name="empty", file_count=0)
assert empty_module.hotspot_density == 0.0
def test_module_health(self):
"""Test module_health property."""
# Healthy module
healthy = ModuleHotspot(path="healthy", name="healthy", file_count=10, stability_score=80.0)
assert healthy.module_health == "healthy"
# Warning module
warning = ModuleHotspot(path="warning", name="warning", file_count=10, stability_score=50.0)
for i in range(4):
warning.hotspot_files.append(FileHotspot(path=f"file{i}.py", name=f"file{i}.py"))
assert warning.module_health == "warning"
# Unhealthy module
unhealthy = ModuleHotspot(
path="unhealthy", name="unhealthy", file_count=10, stability_score=30.0
)
for i in range(6):
unhealthy.hotspot_files.append(FileHotspot(path=f"file{i}.py", name=f"file{i}.py"))
assert unhealthy.module_health == "unhealthy"
class TestHotspotReport:
"""Test suite for HotspotReport dataclass."""
def test_hotspot_report_creation(self):
"""Test creating HotspotReport."""
report = HotspotReport(
total_files_analyzed=100, total_hotspots=15, critical_count=3, high_count=5
)
assert report.total_files_analyzed == 100
assert report.total_hotspots == 15
assert report.critical_count == 3
assert report.high_count == 5
def test_total_count(self):
"""Test total_count property."""
report = HotspotReport()
for i in range(5):
report.file_hotspots.append(FileHotspot(path=f"file{i}.py", name=f"file{i}.py"))
assert report.total_count == 5
def test_health_score(self):
"""Test health_score property."""
# Good health
good_report = HotspotReport(
total_files_analyzed=100, total_hotspots=5, critical_count=0, high_count=2
)
good_score = good_report.health_score
assert 60 <= good_score <= 100
# Poor health
poor_report = HotspotReport(
total_files_analyzed=100, total_hotspots=30, critical_count=10, high_count=15
)
poor_report.coupling_clusters = [["f1", "f2", "f3"] for _ in range(5)]
poor_score = poor_report.health_score
assert poor_score < good_score
assert 0 <= poor_score <= 100
def test_to_dict(self):
"""Test to_dict conversion."""
report = HotspotReport(
total_files_analyzed=50, total_hotspots=10, critical_count=2, high_count=3
)
# Add a hotspot
hotspot = FileHotspot(path="hot.py", name="hot.py")
hotspot.metrics.hotspot_score = 75.0
hotspot.metrics.risk_level = "high"
hotspot.problem_indicators = ["High complexity", "Many bugs"]
report.file_hotspots.append(hotspot)
# Add module
module = ModuleHotspot(path="src", name="src")
report.module_hotspots.append(module)
# Add recommendations
report.recommendations = ["Refactor hot.py"]
result = report.to_dict()
assert result["total_files_analyzed"] == 50
assert result["total_hotspots"] == 10
assert len(result["hotspot_summary"]) == 1
assert len(result["module_summary"]) == 1
assert len(result["recommendations"]) == 1
class TestHotspotDetector:
"""Test suite for HotspotDetector class."""
def test_initialization(self, config):
"""Test HotspotDetector initialization."""
detector = HotspotDetector(config)
assert detector.config == config
assert detector.git_analyzer is None
@patch("tenets.core.examiner.hotspots.GitAnalyzer")
def test_detect_no_repo(self, mock_git_class, hotspot_detector, tmp_path):
"""Test detection with no git repository."""
mock_git = Mock()
mock_git.is_repo.return_value = False
mock_git_class.return_value = mock_git
report = hotspot_detector.detect(tmp_path)
assert report.total_files_analyzed == 0
assert report.total_hotspots == 0
@patch("tenets.core.examiner.hotspots.GitAnalyzer")
def test_detect_basic(self, mock_git_class, hotspot_detector, tmp_path):
"""Test basic hotspot detection."""
mock_git = Mock()
mock_git.is_repo.return_value = True
# Create mock commits
commits = []
for i in range(20):
commit = Mock()
commit.hexsha = f"abc{i:03d}"
commit.committed_date = (datetime.now() - timedelta(days=20 - i)).timestamp()
commit.message = "Fix bug" if i % 3 == 0 else "Add feature"
commit.author = Mock(email=f"dev{i % 3}@example.com")
# Add file changes
commit.stats = Mock()
commit.stats.files = {
"hot_file.py": {"insertions": 10, "deletions": 5},
"normal.py": {"insertions": 5, "deletions": 2},
}
commits.append(commit)
mock_git.get_commits_since.return_value = commits
mock_git_class.return_value = mock_git
report = hotspot_detector.detect(tmp_path, since_days=30)
assert report.total_files_analyzed > 0
def test_analyze_file_changes(self, hotspot_detector):
"""Test file change analysis."""
hotspot_detector.git_analyzer = Mock()
# Create mock commits
commits = []
for i in range(10):
commit = Mock()
commit.hexsha = f"abc{i:03d}"
commit.committed_date = (datetime.now() - timedelta(days=10 - i)).timestamp()
commit.message = "Fix critical bug" if i % 2 == 0 else "Refactor code"
commit.author = Mock(email=f"dev{i % 2}@example.com", name=f"Dev{i % 2}")
commit.stats = Mock()
commit.stats.files = {
"file1.py": {"insertions": 20, "deletions": 10},
"file2.py": {"insertions": 15, "deletions": 5},
}
commits.append(commit)
hotspot_detector.git_analyzer.get_commits_since.return_value = commits
file_changes = hotspot_detector._analyze_file_changes(datetime.now() - timedelta(days=30))
assert "file1.py" in file_changes
assert "file2.py" in file_changes
assert file_changes["file1.py"]["commit_count"] == 10
assert file_changes["file1.py"]["bug_fixes"] == 5
assert file_changes["file1.py"]["refactors"] == 5
assert len(file_changes["file1.py"]["authors"]) == 2
def test_analyze_file_hotspot(self, hotspot_detector, sample_file_changes):
"""Test single file hotspot analysis."""
change_data = sample_file_changes["hot_file.py"]
# Create mock analyzed file
analyzed_file = Mock()
analyzed_file.path = "hot_file.py"
analyzed_file.complexity = Mock(cyclomatic=25)
analyzed_file.lines = 500
analyzed_file.language = "Python"
hotspot = hotspot_detector._analyze_file_hotspot(
"hot_file.py", change_data, [analyzed_file], since_days=90
)
assert hotspot.path == "hot_file.py"
assert hotspot.name == "hot_file.py"
assert hotspot.metrics.commit_count == 50
assert hotspot.metrics.author_count == 3
assert hotspot.metrics.bug_fix_commits == 15
assert hotspot.metrics.complexity == 25
assert hotspot.size == 500
assert hotspot.language == "Python"
assert len(hotspot.coupled_files) > 0
assert len(hotspot.problem_indicators) > 0
assert len(hotspot.recommended_actions) > 0
def test_identify_problems(self, hotspot_detector):
"""Test problem identification."""
hotspot = FileHotspot(path="test.py", name="test.py")
# Set various problematic metrics
hotspot.metrics.change_frequency = 1.0
hotspot.metrics.complexity = 25
hotspot.metrics.bug_fix_commits = 12
hotspot.metrics.author_count = 15
hotspot.metrics.coupling = 12
hotspot.metrics.churn_rate = 15
hotspot.metrics.recency_days = 3
hotspot.metrics.commit_count = 10
hotspot.size = 1200
problems = hotspot_detector._identify_problems(hotspot)
assert len(problems) > 0
assert any("change frequency" in p for p in problems)
assert any("complexity" in p for p in problems)
assert any("bug fixes" in p for p in problems)
assert any("contributors" in p for p in problems)
assert any("coupled" in p for p in problems)
assert any("churn" in p for p in problems)
assert any("large file" in p for p in problems)
def test_recommend_actions(self, hotspot_detector):
"""Test action recommendation."""
hotspot = FileHotspot(path="test.py", name="test.py")
# High complexity
hotspot.metrics.complexity = 25
actions = hotspot_detector._recommend_actions(hotspot)
assert any("refactor" in a.lower() for a in actions)
# Large file
hotspot.size = 1500
actions = hotspot_detector._recommend_actions(hotspot)
assert any("split" in a.lower() or "smaller" in a.lower() for a in actions)
# Many bugs
hotspot.metrics.bug_fix_commits = 10
actions = hotspot_detector._recommend_actions(hotspot)
assert any("test" in a.lower() or "review" in a.lower() for a in actions)
# High coupling
hotspot.metrics.coupling = 15
actions = hotspot_detector._recommend_actions(hotspot)
assert any("coupling" in a.lower() or "abstraction" in a.lower() for a in actions)
def test_calculate_stability(self, hotspot_detector):
"""Test stability score calculation."""
# Stable file
stable = FileHotspot(path="stable.py", name="stable.py")
stable.metrics.change_frequency = 0.1
stable.metrics.commit_count = 10
stable.metrics.bug_fix_commits = 1
stable.metrics.author_count = 2
stable.metrics.churn_rate = 1.0
stable.metrics.recency_days = 60
stability = hotspot_detector._calculate_stability(stable)
assert stability > 70
# Unstable file
unstable = FileHotspot(path="unstable.py", name="unstable.py")
unstable.metrics.change_frequency = 2.0
unstable.metrics.commit_count = 50
unstable.metrics.bug_fix_commits = 25
unstable.metrics.author_count = 10
unstable.metrics.churn_rate = 20.0
unstable.metrics.recency_days = 2
instability = hotspot_detector._calculate_stability(unstable)
assert instability < stability
assert instability < 50
def test_detect_coupling_clusters(self, hotspot_detector):
"""Test coupling cluster detection."""
file_changes = {
"file1.py": {"coupled_files": {"file2.py": 10, "file3.py": 8, "file4.py": 2}},
"file2.py": {"coupled_files": {"file1.py": 10, "file3.py": 7, "file4.py": 1}},
"file3.py": {"coupled_files": {"file1.py": 8, "file2.py": 7, "file4.py": 1}},
"file4.py": {"coupled_files": {"file1.py": 2, "file2.py": 1, "file3.py": 1}},
"isolated.py": {"coupled_files": {}},
}
clusters = hotspot_detector._detect_coupling_clusters(file_changes)
assert len(clusters) > 0
# Should find cluster with file1, file2, file3
assert any(
set(["file1.py", "file2.py", "file3.py"]).issubset(set(cluster)) for cluster in clusters
)
def test_estimate_remediation_effort(self, hotspot_detector):
"""Test effort estimation."""
report = HotspotReport()
# Add hotspots with different risk levels
for i in range(3):
hotspot = FileHotspot(path=f"critical{i}.py", name=f"critical{i}.py")
hotspot.metrics.risk_level = "critical"
hotspot.size = 800
hotspot.metrics.complexity = 25
hotspot.metrics.coupling = 12
report.file_hotspots.append(hotspot)
for i in range(5):
hotspot = FileHotspot(path=f"high{i}.py", name=f"high{i}.py")
hotspot.metrics.risk_level = "high"
hotspot.size = 400
hotspot.metrics.complexity = 15
report.file_hotspots.append(hotspot)
effort = hotspot_detector._estimate_remediation_effort(report)
assert effort > 0
# Should be reasonable estimate
assert 50 <= effort <= 500
def test_generate_recommendations(self, hotspot_detector):
"""Test recommendation generation."""
report = HotspotReport(critical_count=5, high_count=10)
# Add coupling clusters
report.coupling_clusters = [
["f1", "f2", "f3"],
["f4", "f5"],
["f6", "f7", "f8"],
["f9", "f10"],
]
# Add unhealthy modules
for i in range(3):
module = ModuleHotspot(path=f"module{i}", name=f"module{i}")
module.module_health = "unhealthy"
report.module_hotspots.append(module)
# Add top problems
report.top_problems = [("High Complexity", 20), ("Frequent Changes", 15), ("Bug Prone", 10)]
# Set poor health score
report.health_score = 30.0
# High effort estimate
report.estimated_effort = 200.0
recommendations = hotspot_detector._generate_recommendations(report)
assert len(recommendations) > 0
assert any("critical" in r.lower() for r in recommendations)
assert any("refactoring" in r.lower() for r in recommendations)
assert any("coupling" in r.lower() for r in recommendations)
class TestDetectHotspotsFunction:
"""Test the detect_hotspots convenience function."""
@patch("tenets.core.examiner.hotspots.HotspotDetector")
def test_detect_hotspots_basic(self, mock_detector_class, tmp_path):
"""Test basic hotspot detection."""
mock_detector = Mock()
mock_report = HotspotReport(total_hotspots=5)
mock_detector.detect.return_value = mock_report
mock_detector_class.return_value = mock_detector
report = detect_hotspots(tmp_path)
assert isinstance(report, HotspotReport)
assert report.total_hotspots == 5
mock_detector.detect.assert_called_once()
@patch("tenets.core.examiner.hotspots.HotspotDetector")
def test_detect_hotspots_with_options(self, mock_detector_class, tmp_path):
"""Test with various options."""
mock_detector = Mock()
mock_detector.detect.return_value = HotspotReport()
mock_detector_class.return_value = mock_detector
files = [Mock()]
report = detect_hotspots(tmp_path, files=files, threshold=15)
assert isinstance(report, HotspotReport)
mock_detector.detect.assert_called_with(tmp_path, files=files, threshold=15)
@patch("tenets.core.examiner.hotspots.HotspotDetector")
def test_detect_hotspots_with_config(self, mock_detector_class, tmp_path, config):
"""Test with custom config."""
mock_detector = Mock()
mock_detector.detect.return_value = HotspotReport()
mock_detector_class.return_value = mock_detector
report = detect_hotspots(tmp_path, config=config)
assert isinstance(report, HotspotReport)
mock_detector_class.assert_called_with(config)
