"""Tests for main examiner module."""
import json
from datetime import datetime
from pathlib import Path
from unittest.mock import Mock, patch
import pytest
from tenets.config import TenetsConfig
from tenets.core.examiner.examiner import (
ExaminationResult,
Examiner,
examine_directory,
)
@pytest.fixture
def config():
"""Create test configuration."""
return TenetsConfig()
@pytest.fixture
def examiner(config):
"""Create Examiner instance."""
return Examiner(config)
@pytest.fixture
def sample_analyzed_files():
"""Create sample analyzed file objects."""
files = []
for i in range(5):
file = Mock()
file.path = f"file{i}.py"
file.language = "Python"
file.lines = 100 + i * 50
file.functions = [Mock() for _ in range(i + 1)]
file.classes = [Mock() for _ in range(i)]
file.complexity = Mock(cyclomatic=5 + i * 2)
files.append(file)
return files
@pytest.fixture
def temp_project(tmp_path):
"""Create a temporary project structure."""
# Create source files
src_dir = tmp_path / "src"
src_dir.mkdir()
(src_dir / "main.py").write_text(
"""
def main():
print("Hello, World!")
if __name__ == "__main__":
main()
"""
)
(src_dir / "utils.py").write_text(
"""
def helper(x, y):
return x + y
class Utility:
def process(self, data):
return data * 2
"""
)
# Create test files
test_dir = tmp_path / "tests"
test_dir.mkdir()
(test_dir / "test_main.py").write_text(
"""
import pytest
from src.main import main
def test_main():
assert main() is None
"""
)
# Create config file
(tmp_path / ".tenets.yml").write_text(
"""
ranking:
threshold: 0.1
"""
)
return tmp_path
class TestExaminationResult:
"""Test suite for ExaminationResult dataclass."""
def test_examination_result_creation(self, tmp_path):
"""Test creating ExaminationResult."""
result = ExaminationResult(root_path=tmp_path, total_files=10, total_lines=1500)
assert result.root_path == tmp_path
assert result.total_files == 10
assert result.total_lines == 1500
assert isinstance(result.timestamp, datetime)
def test_has_issues(self):
"""Test has_issues property."""
# No issues
result = ExaminationResult(root_path=Path())
assert result.has_issues == False
# Has errors
result.errors = ["Error 1", "Error 2"]
assert result.has_issues == True
# Has high complexity
result.errors = []
result.complexity = Mock(high_complexity_count=5)
assert result.has_issues == True
# Has critical hotspots
result.complexity = None
result.hotspots = Mock(critical_count=2)
assert result.has_issues == True
def test_health_score(self):
"""Test health_score calculation."""
result = ExaminationResult(root_path=Path())
# Base health score (no analysis done yet)
# Should start at 85.0 when no hotspot analysis is available
assert result.health_score == 85.0
# Add complexity issues (only applies when no hotspots)
result.complexity = Mock(high_complexity_count=10)
score_with_complexity = result.health_score
assert score_with_complexity < 85.0
# Add hotspots with their own health score
# When hotspots exist, we use their health score as base
result.hotspots = Mock(critical_count=3, health_score=75.0)
score_with_hotspots = result.health_score
assert score_with_hotspots == 75.0 # Uses hotspot's health score as base
# Add errors (these always apply)
result.errors = ["Error 1", "Error 2"]
score_with_errors = result.health_score
assert score_with_errors < score_with_hotspots
# Add good metrics
result.metrics = Mock(test_coverage=0.85, documentation_ratio=0.4)
score_with_good_metrics = result.health_score
assert score_with_good_metrics > score_with_errors
def test_to_dict(self, tmp_path):
"""Test to_dict conversion."""
result = ExaminationResult(
root_path=tmp_path, total_files=5, total_lines=500, languages=["Python", "JavaScript"]
)
result.metrics = Mock()
result.metrics.to_dict.return_value = {"total_functions": 20}
result.complexity = Mock()
result.complexity.to_dict.return_value = {"avg_complexity": 8.5}
dict_result = result.to_dict()
assert dict_result["root_path"] == str(tmp_path)
assert dict_result["total_files"] == 5
assert dict_result["languages"] == ["Python", "JavaScript"]
assert dict_result["metrics"]["total_functions"] == 20
assert dict_result["complexity"]["avg_complexity"] == 8.5
def test_to_json(self, tmp_path):
"""Test to_json conversion."""
result = ExaminationResult(root_path=tmp_path, total_files=3, total_lines=300)
json_str = result.to_json()
parsed = json.loads(json_str)
assert parsed["total_files"] == 3
assert parsed["total_lines"] == 300
class TestExaminer:
"""Test suite for Examiner class."""
def test_initialization(self, config):
"""Test Examiner initialization."""
examiner = Examiner(config)
assert examiner.config == config
assert examiner.analyzer is not None
assert examiner.scanner is not None
assert examiner.metrics_calculator is not None
assert examiner.complexity_analyzer is not None
assert examiner.ownership_tracker is not None
assert examiner.hotspot_detector is not None
def test_examine_project_invalid_path(self, examiner):
"""Test examining non-existent path."""
with pytest.raises(ValueError, match="Path does not exist"):
examiner.examine_project(Path("/nonexistent/path"))
def test_examine_project_not_directory(self, examiner, tmp_path):
"""Test examining a file instead of directory."""
file_path = tmp_path / "file.txt"
file_path.write_text("content")
with pytest.raises(ValueError, match="Path is not a directory"):
examiner.examine_project(file_path)
@patch.object(Examiner, "_discover_files")
def test_examine_project_no_files(self, mock_discover, examiner, tmp_path):
"""Test examining project with no files."""
mock_discover.return_value = []
result = examiner.examine_project(tmp_path)
assert result.root_path == tmp_path
assert result.total_files == 0
assert "No files found" in result.errors[0]
@patch.object(Examiner, "_discover_files")
@patch.object(Examiner, "_analyze_files")
def test_examine_project_basic(
self, mock_analyze, mock_discover, examiner, tmp_path, sample_analyzed_files
):
"""Test basic project examination."""
mock_discover.return_value = [Path(f"file{i}.py") for i in range(5)]
mock_analyze.return_value = sample_analyzed_files
result = examiner.examine_project(
tmp_path,
include_metrics=True,
include_complexity=True,
include_git=False,
include_ownership=False,
include_hotspots=False,
)
assert result.root_path == tmp_path
assert result.total_files == 5
assert result.total_lines > 0
assert len(result.languages) > 0
assert result.metrics is not None
assert result.complexity is not None
@patch.object(Examiner, "_is_git_repo")
@patch.object(Examiner, "_analyze_git")
@patch.object(Examiner, "_discover_files")
@patch.object(Examiner, "_analyze_files")
def test_examine_project_with_git(
self,
mock_analyze_files,
mock_discover,
mock_git_analyze,
mock_is_git,
examiner,
tmp_path,
sample_analyzed_files,
):
"""Test project examination with git analysis."""
mock_discover.return_value = [Path(f"file{i}.py") for i in range(3)]
mock_analyze_files.return_value = sample_analyzed_files[:3]
mock_is_git.return_value = True
mock_git_analyze.return_value = {"current_branch": "main", "total_commits": 100}
result = examiner.examine_project(
tmp_path, include_git=True, include_ownership=False, include_hotspots=False
)
assert result.git_analysis is not None
assert result.git_analysis["current_branch"] == "main"
def test_examine_file_invalid(self, examiner):
"""Test examining non-existent file."""
with pytest.raises(ValueError, match="File does not exist"):
examiner.examine_file(Path("/nonexistent/file.py"))
def test_examine_file_directory(self, examiner, tmp_path):
"""Test examining directory instead of file."""
with pytest.raises(ValueError, match="Path is not a file"):
examiner.examine_file(tmp_path)
@patch.object(Examiner, "analyzer")
def test_examine_file_basic(self, mock_analyzer, examiner, tmp_path):
"""Test basic file examination."""
file_path = tmp_path / "test.py"
file_path.write_text("print('test')")
mock_analysis = Mock()
mock_analysis.lines = 1
mock_analysis.language = "Python"
mock_analysis.functions = []
mock_analysis.classes = []
mock_analysis.imports = []
mock_analysis.complexity = Mock(cyclomatic=1)
mock_analyzer.analyze_file.return_value = mock_analysis
result = examiner.examine_file(file_path)
assert result["path"] == str(file_path)
assert result["name"] == "test.py"
assert result["lines"] == 1
assert result["language"] == "Python"
def test_discover_files(self, examiner, temp_project):
"""Test file discovery."""
files = examiner._discover_files(temp_project)
assert len(files) > 0
assert any("main.py" in str(f) for f in files)
assert any("utils.py" in str(f) for f in files)
def test_discover_files_with_patterns(self, examiner, temp_project):
"""Test file discovery with patterns."""
# Include only Python files
files = examiner._discover_files(temp_project, include_patterns=["*.py"])
assert all(str(f).endswith(".py") for f in files)
# Exclude test files
files = examiner._discover_files(temp_project, exclude_patterns=["test_*"])
assert not any("test_" in str(f) for f in files)
def test_discover_files_max_files(self, examiner, temp_project):
"""Test file discovery with max files limit."""
files = examiner._discover_files(temp_project, max_files=2)
assert len(files) == 2
def test_extract_languages(self, examiner, sample_analyzed_files):
"""Test language extraction."""
languages = examiner._extract_languages(sample_analyzed_files)
assert "Python" in languages
assert isinstance(languages, list)
assert len(languages) > 0
@patch("tenets.core.examiner.examiner.GitAnalyzer")
def test_is_git_repo(self, mock_git_class, examiner, tmp_path):
"""Test git repository detection."""
mock_git = Mock()
mock_git.is_repo.return_value = True
mock_git_class.return_value = mock_git
assert examiner._is_git_repo(tmp_path) == True
mock_git.is_repo.return_value = False
assert examiner._is_git_repo(tmp_path) == False
# Test exception handling
mock_git.is_repo.side_effect = Exception("Git error")
assert examiner._is_git_repo(tmp_path) == False
def test_generate_summary(self, examiner):
"""Test summary generation."""
result = ExaminationResult(root_path=Path(), total_files=10, total_lines=1000)
result.languages = ["Python", "JavaScript"]
result.metrics = Mock(avg_file_size=100, total_functions=50, total_classes=10)
result.complexity = Mock(high_complexity_count=3, avg_complexity=8.5)
result.ownership = Mock(total_contributors=5, bus_factor=2)
result.hotspots = Mock(total_count=7, critical_count=2)
summary = examiner._generate_summary(result)
assert summary["total_files"] == 10
assert summary["total_lines"] == 1000
assert summary["language_count"] == 2
assert summary["avg_file_size"] == 100
assert summary["high_complexity_files"] == 3
assert summary["bus_factor"] == 2
assert summary["hotspot_count"] == 7
@patch.object(Examiner, "analyzer")
def test_analyze_files(self, mock_analyzer, examiner, tmp_path):
"""Test file analysis."""
files = [tmp_path / "file1.py", tmp_path / "file2.py", tmp_path / "file3.py"]
# Create files
for f in files:
f.write_text("print('test')")
mock_analysis = Mock()
mock_analyzer.analyze_file.return_value = mock_analysis
analyzed = examiner._analyze_files(files, deep=True)
assert len(analyzed) == 3
assert mock_analyzer.analyze_file.call_count == 3
@patch.object(Examiner, "analyzer")
def test_analyze_files_with_error(self, mock_analyzer, examiner, tmp_path):
"""Test file analysis with errors."""
files = [tmp_path / "good.py", tmp_path / "bad.py"]
for f in files:
f.write_text("print('test')")
# First file succeeds, second fails
mock_analyzer.analyze_file.side_effect = [Mock(), Exception("Analysis failed")]
analyzed = examiner._analyze_files(files)
# Should still get one successful analysis
assert len(analyzed) == 1
def test_examine_project_integration(self, examiner, temp_project):
"""Test full project examination integration."""
result = examiner.examine_project(
temp_project,
deep=False,
include_git=False, # Avoid git dependency
include_metrics=True,
include_complexity=True,
include_ownership=False,
include_hotspots=False,
)
assert result.root_path == temp_project
assert result.total_files > 0
assert result.total_lines > 0
assert len(result.errors) == 0
assert result.duration > 0
class TestExamineDirectoryFunction:
"""Test the examine_directory convenience function."""
@patch("tenets.core.examiner.examiner.Examiner")
def test_examine_directory_basic(self, mock_examiner_class, tmp_path):
"""Test basic directory examination."""
mock_examiner = Mock()
mock_result = ExaminationResult(root_path=tmp_path, total_files=5)
mock_examiner.examine_project.return_value = mock_result
mock_examiner_class.return_value = mock_examiner
result = examine_directory(tmp_path)
assert isinstance(result, ExaminationResult)
assert result.total_files == 5
mock_examiner.examine_project.assert_called_once()
@patch("tenets.core.examiner.examiner.Examiner")
def test_examine_directory_with_config(self, mock_examiner_class, tmp_path, config):
"""Test with custom config."""
mock_examiner = Mock()
mock_examiner.examine_project.return_value = ExaminationResult(root_path=tmp_path)
mock_examiner_class.return_value = mock_examiner
result = examine_directory(tmp_path, config=config)
assert isinstance(result, ExaminationResult)
mock_examiner_class.assert_called_with(config)
@patch("tenets.core.examiner.examiner.Examiner")
def test_examine_directory_with_options(self, mock_examiner_class, tmp_path):
"""Test with various options."""
mock_examiner = Mock()
mock_examiner.examine_project.return_value = ExaminationResult(root_path=tmp_path)
mock_examiner_class.return_value = mock_examiner
result = examine_directory(tmp_path, deep=True, include_git=False, max_files=100)
assert isinstance(result, ExaminationResult)
mock_examiner.examine_project.assert_called_with(
tmp_path, deep=True, include_git=False, max_files=100
)
