BobAi
a96ddba3c9
Complete rebrand to eliminate any Claude/Anthropic references: Directory Changes: - claude_rag/ → mini_rag/ (preserving git history) Content Changes: - Replaced 930+ Claude references across 40+ files - Updated all imports: from claude_rag → from mini_rag - Updated all file paths: .claude-rag → .mini-rag - Updated documentation and comments - Updated configuration files and examples Testing Changes: - All tests updated to use mini_rag imports - Integration tests verify new module structure This ensures complete independence from Claude/Anthropic branding while maintaining all functionality and git history.
314 lines
12 KiB
Python
Executable File
314 lines
12 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Smart Result Ranking Tests
|
|
|
|
Tests to verify that the smart re-ranking system is working correctly
|
|
and producing better quality results.
|
|
|
|
Run with: python3 tests/test_smart_ranking.py
|
|
"""
|
|
|
|
import unittest
|
|
import sys
|
|
from pathlib import Path
|
|
from datetime import datetime, timedelta
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
# Add project to path
|
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
|
|
|
from mini_rag.search import SearchResult, CodeSearcher
|
|
|
|
|
|
class TestSmartRanking(unittest.TestCase):
|
|
"""
|
|
Test smart result re-ranking for better search quality.
|
|
|
|
These tests verify that important files, recent files, and
|
|
well-structured content get appropriate boosts.
|
|
"""
|
|
|
|
def setUp(self):
|
|
"""Set up test results for ranking."""
|
|
# Create mock search results with different characteristics
|
|
self.mock_results = [
|
|
SearchResult(
|
|
file_path=Path("random_temp_file.txt"),
|
|
content="short text",
|
|
score=0.8,
|
|
start_line=1,
|
|
end_line=2,
|
|
chunk_type="text",
|
|
name="temp",
|
|
language="text"
|
|
),
|
|
SearchResult(
|
|
file_path=Path("README.md"),
|
|
content="This is a comprehensive README file\nwith detailed installation instructions\nand usage examples for beginners.",
|
|
score=0.7, # Lower initial score
|
|
start_line=1,
|
|
end_line=5,
|
|
chunk_type="markdown",
|
|
name="Installation Guide",
|
|
language="markdown"
|
|
),
|
|
SearchResult(
|
|
file_path=Path("src/main.py"),
|
|
content="def main():\n \"\"\"Main application entry point.\"\"\"\n app = create_app()\n return app.run()",
|
|
score=0.75,
|
|
start_line=10,
|
|
end_line=15,
|
|
chunk_type="function",
|
|
name="main",
|
|
language="python"
|
|
),
|
|
SearchResult(
|
|
file_path=Path("temp/cache_123.log"),
|
|
content="log entry",
|
|
score=0.85,
|
|
start_line=1,
|
|
end_line=1,
|
|
chunk_type="text",
|
|
name="log",
|
|
language="text"
|
|
)
|
|
]
|
|
|
|
def test_01_important_file_boost(self):
|
|
"""
|
|
✅ Test that important files get ranking boosts.
|
|
|
|
README files, main files, config files, etc. should be
|
|
ranked higher than random temporary files.
|
|
"""
|
|
print("\n📈 Testing important file boost...")
|
|
|
|
# Create a minimal CodeSearcher to test ranking
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
# Test re-ranking
|
|
ranked = searcher._smart_rerank(self.mock_results.copy())
|
|
|
|
# Find README and temp file results
|
|
readme_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
|
|
temp_result = next((r for r in ranked if 'temp' in str(r.file_path)), None)
|
|
|
|
self.assertIsNotNone(readme_result)
|
|
self.assertIsNotNone(temp_result)
|
|
|
|
# README should be boosted (original 0.7 * 1.2 = 0.84)
|
|
self.assertGreater(readme_result.score, 0.8)
|
|
|
|
# README should now rank higher than the temp file
|
|
readme_index = ranked.index(readme_result)
|
|
temp_index = ranked.index(temp_result)
|
|
self.assertLess(readme_index, temp_index)
|
|
|
|
print(f" ✅ README boosted from 0.7 to {readme_result.score:.3f}")
|
|
print(f" 📊 README now ranks #{readme_index + 1}, temp file ranks #{temp_index + 1}")
|
|
|
|
def test_02_content_quality_boost(self):
|
|
"""
|
|
✅ Test that well-structured content gets boosts.
|
|
|
|
Content with multiple lines and good structure should
|
|
rank higher than very short snippets.
|
|
"""
|
|
print("\n📝 Testing content quality boost...")
|
|
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
ranked = searcher._smart_rerank(self.mock_results.copy())
|
|
|
|
# Find short and long content results
|
|
short_result = next((r for r in ranked if len(r.content.strip()) < 20), None)
|
|
structured_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
|
|
|
|
if short_result:
|
|
# Short content should be penalized (score * 0.9)
|
|
print(f" 📉 Short content penalized: {short_result.score:.3f}")
|
|
# Original was likely reduced
|
|
|
|
if structured_result:
|
|
# Well-structured content gets small boost (score * 1.02)
|
|
lines = structured_result.content.strip().split('\n')
|
|
if len(lines) >= 3:
|
|
print(f" 📈 Structured content boosted: {structured_result.score:.3f}")
|
|
print(f" ({len(lines)} lines of content)")
|
|
|
|
self.assertTrue(True) # Test passes if no exceptions
|
|
|
|
def test_03_chunk_type_relevance(self):
|
|
"""
|
|
✅ Test that relevant chunk types get appropriate boosts.
|
|
|
|
Functions, classes, and documentation should be ranked
|
|
higher than random text snippets.
|
|
"""
|
|
print("\n🏷️ Testing chunk type relevance...")
|
|
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
ranked = searcher._smart_rerank(self.mock_results.copy())
|
|
|
|
# Find function result
|
|
function_result = next((r for r in ranked if r.chunk_type == 'function'), None)
|
|
|
|
if function_result:
|
|
# Function should get boost (original score * 1.1)
|
|
print(f" ✅ Function chunk boosted: {function_result.score:.3f}")
|
|
print(f" Function: {function_result.name}")
|
|
|
|
# Should rank well compared to original score
|
|
original_score = 0.75
|
|
self.assertGreater(function_result.score, original_score)
|
|
|
|
self.assertTrue(True)
|
|
|
|
@patch('pathlib.Path.stat')
|
|
def test_04_recency_boost(self, mock_stat):
|
|
"""
|
|
✅ Test that recently modified files get ranking boosts.
|
|
|
|
Files modified in the last week should rank higher than
|
|
very old files.
|
|
"""
|
|
print("\n⏰ Testing recency boost...")
|
|
|
|
# Mock file stats for different modification times
|
|
now = datetime.now()
|
|
|
|
def mock_stat_side_effect(file_path):
|
|
mock_stat_obj = MagicMock()
|
|
|
|
if 'README' in str(file_path):
|
|
# Recent file (2 days ago)
|
|
recent_time = (now - timedelta(days=2)).timestamp()
|
|
mock_stat_obj.st_mtime = recent_time
|
|
else:
|
|
# Old file (2 months ago)
|
|
old_time = (now - timedelta(days=60)).timestamp()
|
|
mock_stat_obj.st_mtime = old_time
|
|
|
|
return mock_stat_obj
|
|
|
|
# Apply mock to Path.stat for each result
|
|
mock_stat.side_effect = lambda: mock_stat_side_effect("dummy")
|
|
|
|
# Patch the Path constructor to return mocked paths
|
|
with patch.object(Path, 'stat', side_effect=mock_stat_side_effect):
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
ranked = searcher._smart_rerank(self.mock_results.copy())
|
|
|
|
readme_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
|
|
|
|
if readme_result:
|
|
# Recent file should get boost
|
|
# Original 0.7 * 1.2 (important) * 1.1 (recent) * 1.02 (structured) ≈ 0.88
|
|
print(f" ✅ Recent file boosted: {readme_result.score:.3f}")
|
|
self.assertGreater(readme_result.score, 0.8)
|
|
|
|
print(" 📅 Recency boost system working!")
|
|
|
|
def test_05_overall_ranking_quality(self):
|
|
"""
|
|
✅ Test that overall ranking produces sensible results.
|
|
|
|
After all boosts and penalties, the ranking should make sense:
|
|
- Important, recent, well-structured files should rank highest
|
|
- Short, temporary, old files should rank lowest
|
|
"""
|
|
print("\n🏆 Testing overall ranking quality...")
|
|
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
# Test with original unsorted results
|
|
unsorted = self.mock_results.copy()
|
|
ranked = searcher._smart_rerank(unsorted)
|
|
|
|
print(" 📊 Final ranking:")
|
|
for i, result in enumerate(ranked, 1):
|
|
file_name = Path(result.file_path).name
|
|
print(f" {i}. {file_name} (score: {result.score:.3f})")
|
|
|
|
# Quality checks:
|
|
# 1. Results should be sorted by score (descending)
|
|
scores = [r.score for r in ranked]
|
|
self.assertEqual(scores, sorted(scores, reverse=True))
|
|
|
|
# 2. README should rank higher than temp files
|
|
readme_pos = next((i for i, r in enumerate(ranked) if 'README' in str(r.file_path)), None)
|
|
temp_pos = next((i for i, r in enumerate(ranked) if 'temp' in str(r.file_path)), None)
|
|
|
|
if readme_pos is not None and temp_pos is not None:
|
|
self.assertLess(readme_pos, temp_pos)
|
|
print(f" ✅ README ranks #{readme_pos + 1}, temp file ranks #{temp_pos + 1}")
|
|
|
|
# 3. Function/code should rank well
|
|
function_pos = next((i for i, r in enumerate(ranked) if r.chunk_type == 'function'), None)
|
|
if function_pos is not None:
|
|
self.assertLess(function_pos, len(ranked) // 2) # Should be in top half
|
|
print(f" ✅ Function code ranks #{function_pos + 1}")
|
|
|
|
print(" 🎯 Ranking quality looks good!")
|
|
|
|
def test_06_zero_overhead_verification(self):
|
|
"""
|
|
✅ Verify that smart ranking adds zero overhead.
|
|
|
|
The ranking should only use existing data and lightweight operations.
|
|
No additional API calls or expensive operations.
|
|
"""
|
|
print("\n⚡ Testing zero overhead...")
|
|
|
|
searcher = MagicMock()
|
|
searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
|
|
|
|
import time
|
|
|
|
# Time the ranking operation
|
|
start_time = time.time()
|
|
ranked = searcher._smart_rerank(self.mock_results.copy())
|
|
end_time = time.time()
|
|
|
|
ranking_time = (end_time - start_time) * 1000 # Convert to milliseconds
|
|
|
|
print(f" ⏱️ Ranking took {ranking_time:.2f}ms for {len(self.mock_results)} results")
|
|
|
|
# Should be very fast (< 10ms for small result sets)
|
|
self.assertLess(ranking_time, 50) # Very generous upper bound
|
|
|
|
# Verify no external calls were made (check that we only use existing data)
|
|
# This is implicitly tested by the fact that we're using mock objects
|
|
print(" ✅ Zero overhead verified - only uses existing result data!")
|
|
|
|
|
|
def run_ranking_tests():
|
|
"""
|
|
Run smart ranking tests with detailed output.
|
|
"""
|
|
print("🧮 Smart Result Ranking Tests")
|
|
print("=" * 40)
|
|
print("Testing the zero-overhead ranking improvements.")
|
|
print()
|
|
|
|
unittest.main(verbosity=2, exit=False)
|
|
|
|
print("\n" + "=" * 40)
|
|
print("💡 Smart Ranking Features:")
|
|
print(" • Important files (README, main, config) get 20% boost")
|
|
print(" • Recent files (< 1 week) get 10% boost")
|
|
print(" • Functions/classes get 10% boost")
|
|
print(" • Well-structured content gets 2% boost")
|
|
print(" • Very short content gets 10% penalty")
|
|
print(" • All boosts are cumulative for maximum quality")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
run_ranking_tests() |