use super::*;
use crate::retrieval::reranker::{RerankScore, Reranker, RerankerError};
use crate::types::{Language, SymbolType};
struct NegativeReranker;
impl Reranker for NegativeReranker {
async fn rerank(
&self,
_query: &str,
documents: &[String],
) -> Result<Vec<RerankScore>, RerankerError> {
Ok(documents
.iter()
.enumerate()
.map(|(index, _)| RerankScore {
index,
relevance_score: -1.0 - index as f64,
})
.collect())
}
}
fn make_result(
file: &str,
line_start: u32,
line_end: u32,
score: f64,
symbol_name: Option<&str>,
) -> SearchResult {
SearchResult {
file_path: file.to_string(),
line_start,
line_end,
content: format!("content of {file}:{line_start}"),
language: Language::Rust,
score,
symbol_name: symbol_name.map(|s| s.to_string()),
symbol_type: Some(SymbolType::Function),
}
}
#[test]
fn rrf_single_source_bm25_only() {
let bm25 = vec![
make_result("a.rs", 1, 10, 5.0, Some("func_a")),
make_result("b.rs", 1, 10, 3.0, Some("func_b")),
];
let vector: Vec<SearchResult> = vec![];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
assert_eq!(results.len(), 2);
let expected_score_1 = 1.0 / 61.0;
assert!(
(results[0].score - expected_score_1).abs() < 1e-10,
"first result RRF score: got {}, expected {}",
results[0].score,
expected_score_1
);
assert_eq!(results[0].file_path, "a.rs");
}
#[test]
fn rrf_single_source_vector_only() {
let bm25: Vec<SearchResult> = vec![];
let vector = vec![
make_result("c.rs", 1, 10, 0.9, Some("func_c")),
make_result("d.rs", 1, 10, 0.7, Some("func_d")),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
assert_eq!(results.len(), 2);
let expected_score_1 = 1.0 / 61.0;
assert!(
(results[0].score - expected_score_1).abs() < 1e-10,
"first result RRF score: got {}, expected {}",
results[0].score,
expected_score_1
);
assert_eq!(results[0].file_path, "c.rs");
}
#[test]
fn rrf_overlapping_results_rank_higher() {
let bm25 = vec![
make_result("bm25_only.rs", 1, 10, 5.0, Some("bm25_func")),
make_result("shared.rs", 1, 10, 3.0, Some("shared_func")),
];
let vector = vec![
make_result("shared.rs", 1, 10, 0.9, Some("shared_func")),
make_result("vector_only.rs", 1, 10, 0.7, Some("vector_func")),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
let shared_score = 1.0 / 62.0 + 1.0 / 61.0;
let bm25_only_score = 1.0 / 61.0;
let _vector_only_score = 1.0 / 62.0;
assert!(
shared_score > bm25_only_score,
"overlapping result should have higher RRF score"
);
assert_eq!(
results[0].file_path, "shared.rs",
"result appearing in both lists should rank first"
);
assert!(
(results[0].score - shared_score).abs() < 1e-10,
"shared score: got {}, expected {}",
results[0].score,
shared_score
);
}
#[test]
fn rrf_scores_are_descending() {
let bm25 = vec![
make_result("a.rs", 1, 10, 5.0, Some("func_a")),
make_result("b.rs", 1, 10, 3.0, Some("func_b")),
make_result("c.rs", 1, 10, 1.0, Some("func_c")),
];
let vector = vec![
make_result("d.rs", 1, 10, 0.9, Some("func_d")),
make_result("a.rs", 1, 10, 0.8, Some("func_a")),
make_result("e.rs", 1, 10, 0.5, Some("func_e")),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
for i in 1..results.len() {
assert!(
results[i - 1].score >= results[i].score,
"scores must be descending: {} >= {} at position {i}",
results[i - 1].score,
results[i].score,
);
}
}
#[test]
fn rrf_respects_limit() {
let bm25 = vec![
make_result("a.rs", 1, 10, 5.0, None),
make_result("b.rs", 1, 10, 3.0, None),
make_result("c.rs", 1, 10, 1.0, None),
];
let vector = vec![
make_result("d.rs", 1, 10, 0.9, None),
make_result("e.rs", 1, 10, 0.7, None),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 2);
assert_eq!(results.len(), 2, "should respect the limit");
}
#[test]
fn rrf_empty_inputs_return_empty() {
let results = fuse_rrf(&[], &[], 60.0, 10);
assert!(results.is_empty(), "no inputs should give no results");
}
#[test]
fn rrf_preserves_metadata_from_first_seen() {
let bm25 = vec![make_result("shared.rs", 1, 10, 5.0, Some("func"))];
let vector = vec![make_result("shared.rs", 1, 10, 0.9, Some("func"))];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
assert_eq!(results.len(), 1);
let result = &results[0];
assert_eq!(result.file_path, "shared.rs");
assert_eq!(result.line_start, 1);
assert_eq!(result.line_end, 10);
assert_eq!(result.symbol_name.as_deref(), Some("func"));
assert_eq!(result.symbol_type, Some(SymbolType::Function));
assert_eq!(result.language, Language::Rust);
}
#[test]
fn rrf_k_parameter_affects_scores() {
let bm25 = vec![make_result("a.rs", 1, 10, 5.0, None)];
let vector: Vec<SearchResult> = vec![];
let results_k60 = fuse_rrf(&bm25, &vector, 60.0, 10);
let results_k1 = fuse_rrf(&bm25, &vector, 1.0, 10);
assert!(
results_k1[0].score > results_k60[0].score,
"lower k should produce higher scores: k1={}, k60={}",
results_k1[0].score,
results_k60[0].score
);
}
#[test]
fn rrf_with_known_inputs_produces_exact_scores() {
let bm25 = vec![
make_result("a.rs", 1, 10, 5.0, Some("a")),
make_result("b.rs", 1, 10, 3.0, Some("b")),
make_result("c.rs", 1, 10, 1.0, Some("c")),
];
let vector = vec![
make_result("b.rs", 1, 10, 0.9, Some("b")),
make_result("c.rs", 1, 10, 0.8, Some("c")),
make_result("a.rs", 1, 10, 0.5, Some("a")),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
let score_a = 1.0 / 61.0 + 1.0 / 63.0;
let score_b = 1.0 / 62.0 + 1.0 / 61.0;
let score_c = 1.0 / 63.0 + 1.0 / 62.0;
assert_eq!(results[0].file_path, "b.rs");
assert!(
(results[0].score - score_b).abs() < 1e-10,
"B score: got {}, expected {score_b}",
results[0].score
);
assert_eq!(results[1].file_path, "a.rs");
assert!(
(results[1].score - score_a).abs() < 1e-10,
"A score: got {}, expected {score_a}",
results[1].score
);
assert_eq!(results[2].file_path, "c.rs");
assert!(
(results[2].score - score_c).abs() < 1e-10,
"C score: got {}, expected {score_c}",
results[2].score
);
}
#[test]
fn rrf_distinct_results_no_overlap() {
let bm25 = vec![
make_result("bm25_1.rs", 1, 10, 5.0, None),
make_result("bm25_2.rs", 1, 10, 3.0, None),
];
let vector = vec![
make_result("vec_1.rs", 1, 10, 0.9, None),
make_result("vec_2.rs", 1, 10, 0.7, None),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
assert_eq!(results.len(), 4);
let expected_top = 1.0 / 61.0;
let expected_bottom = 1.0 / 62.0;
assert!((results[0].score - expected_top).abs() < 1e-10);
assert!((results[1].score - expected_top).abs() < 1e-10);
assert!((results[2].score - expected_bottom).abs() < 1e-10);
assert!((results[3].score - expected_bottom).abs() < 1e-10);
}
#[test]
fn rrf_ties_break_on_file_path_then_line_range() {
let bm25 = vec![
make_result("z_bm25.rs", 1, 10, 5.0, None),
make_result("a_bm25.rs", 1, 10, 4.0, None),
make_result("shared.rs", 200, 210, 3.0, None),
make_result("shared.rs", 300, 1000, 2.0, None),
];
let vector = vec![
make_result("m_vec.rs", 1, 10, 0.9, None),
make_result("b_vec.rs", 1, 10, 0.8, None),
make_result("shared.rs", 30, 40, 0.7, None),
make_result("shared.rs", 300, 305, 0.6, None),
];
for _ in 0..8 {
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
let order: Vec<(&str, u32, u32)> = results
.iter()
.map(|result| {
(
result.file_path.as_str(),
result.line_start,
result.line_end,
)
})
.collect();
assert_eq!(
order,
vec![
("m_vec.rs", 1, 10),
("z_bm25.rs", 1, 10),
("a_bm25.rs", 1, 10),
("b_vec.rs", 1, 10),
("shared.rs", 30, 40),
("shared.rs", 200, 210),
("shared.rs", 300, 305),
("shared.rs", 300, 1000),
],
"tied RRF scores must order by (file_path, line_start, line_end)"
);
}
}
#[test]
fn rrf_multi_source_ties_break_on_file_path() {
let sets: Vec<Vec<SearchResult>> = ["e.rs", "c.rs", "f.rs", "a.rs", "d.rs", "b.rs"]
.iter()
.map(|file| vec![make_result(file, 1, 10, 1.0, None)])
.collect();
let refs: Vec<&[SearchResult]> = sets.iter().map(|set| set.as_slice()).collect();
let results = fuse_rrf_multi_weighted(&refs, &[1.0; 6], 60.0, 10);
let order: Vec<&str> = results
.iter()
.map(|result| result.file_path.as_str())
.collect();
assert_eq!(
order,
vec!["a.rs", "b.rs", "c.rs", "d.rs", "e.rs", "f.rs"],
"a tie across all sources must order by file_path, not by insertion or hash order"
);
for result in &results {
assert!(
(result.score - 1.0 / 61.0).abs() < 1e-10,
"all six must tie"
);
}
}
#[test]
fn rrf_different_chunks_same_file_are_separate() {
let bm25 = vec![
make_result("lib.rs", 1, 10, 5.0, Some("func_1")),
make_result("lib.rs", 20, 30, 3.0, Some("func_2")),
];
let vector = vec![make_result("lib.rs", 1, 10, 0.9, Some("func_1"))];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
assert_eq!(results.len(), 2);
assert_eq!(
results[0].line_start, 1,
"overlapping chunk should rank first"
);
assert_eq!(
results[1].line_start, 20,
"single-source chunk should rank second"
);
}
#[test]
fn rrf_scores_are_positive() {
let bm25 = vec![
make_result("a.rs", 1, 10, 5.0, None),
make_result("b.rs", 1, 10, 3.0, None),
];
let vector = vec![
make_result("c.rs", 1, 10, 0.9, None),
make_result("a.rs", 1, 10, 0.8, None),
];
let results = fuse_rrf(&bm25, &vector, 60.0, 10);
for result in &results {
assert!(result.score > 0.0, "RRF scores should be positive");
}
}
#[test]
fn result_key_is_unique_for_different_chunks() {
let r1 = make_result("a.rs", 1, 10, 1.0, None);
let r2 = make_result("a.rs", 20, 30, 1.0, None);
let r3 = make_result("b.rs", 1, 10, 1.0, None);
assert_ne!(result_key(&r1), result_key(&r2));
assert_ne!(result_key(&r1), result_key(&r3));
assert_ne!(result_key(&r2), result_key(&r3));
}
#[test]
fn result_key_is_same_for_same_chunk() {
let r1 = make_result("a.rs", 1, 10, 5.0, Some("func"));
let r2 = make_result("a.rs", 1, 10, 0.9, Some("func"));
assert_eq!(result_key(&r1), result_key(&r2));
}
async fn setup_test_index(tmp: &std::path::Path) -> (std::path::PathBuf, usize) {
use crate::config::VeraConfig;
use crate::embedding::test_helpers::MockProvider;
use crate::parsing;
use crate::storage::bm25::Bm25Index;
use crate::storage::metadata::MetadataStore;
use crate::storage::vector::VectorStore;
let dim = 8;
let provider = MockProvider::new(dim);
let config = VeraConfig::default();
let repo_dir = tmp.join("repo");
std::fs::create_dir_all(&repo_dir).unwrap();
std::fs::write(
repo_dir.join("auth.rs"),
"pub fn authenticate(user: &str, pass: &str) -> Result<Token, Error> {\n \
let hash = hash_password(pass);\n verify_credentials(user, &hash)\n}\n\n\
pub fn authorize(token: &Token, resource: &str) -> bool {\n \
token.has_permission(resource)\n}\n",
)
.unwrap();
std::fs::write(
repo_dir.join("cache.rs"),
"pub fn get_cached(key: &str) -> Option<Value> {\n \
CACHE.lock().unwrap().get(key).cloned()\n}\n\n\
pub fn set_cached(key: &str, value: Value) {\n \
CACHE.lock().unwrap().insert(key.to_string(), value);\n}\n",
)
.unwrap();
let mut all_chunks = Vec::new();
for file in ["auth.rs", "cache.rs"] {
let source = std::fs::read_to_string(repo_dir.join(file)).unwrap();
let lang = crate::types::Language::Rust;
let chunks = parsing::parse_and_chunk(&source, file, lang, &config.indexing).unwrap();
all_chunks.extend(chunks);
}
let index_dir = repo_dir.join(".vera");
std::fs::create_dir_all(&index_dir).unwrap();
let metadata_path = index_dir.join("metadata.db");
let metadata_store = MetadataStore::open(&metadata_path).unwrap();
metadata_store.insert_chunks(&all_chunks).unwrap();
let vector_path = index_dir.join("vectors.db");
let vector_store = VectorStore::open(&vector_path, dim).unwrap();
crate::embedding::test_helpers::embed_and_insert_vectors(&vector_store, &provider, &all_chunks)
.await;
let bm25_dir = index_dir.join("bm25");
let bm25 = Bm25Index::open(&bm25_dir).unwrap();
bm25.insert_chunks(&all_chunks).unwrap();
(index_dir, dim)
}
#[tokio::test]
async fn search_hybrid_keeps_intent_out_of_bm25() {
use crate::embedding::EmbeddingError;
use crate::embedding::test_helpers::MockProvider;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::failing(EmbeddingError::ConnectionError {
message: "vector search disabled for this regression test".to_string(),
});
let (results, _timings) = search_hybrid(
&index_dir,
&provider,
"authenticate",
"intent: find auth handlers | authenticate",
&SearchFilters::default(),
5,
60.0,
dim,
50,
)
.await
.expect("hybrid search must not error when intent prefix is present");
assert!(
results.iter().any(|result| {
result.file_path == "auth.rs" && result.content.contains("authenticate")
}),
"BM25 should return the authenticate chunk for the raw query"
);
}
struct SlowProvider {
inner: crate::embedding::test_helpers::MockProvider,
delay: std::time::Duration,
}
impl crate::embedding::EmbeddingProvider for SlowProvider {
async fn embed_batch(
&self,
texts: &[String],
) -> Result<Vec<Vec<f32>>, crate::embedding::EmbeddingError> {
tokio::time::sleep(self.delay).await;
self.inner.embed_batch(texts).await
}
fn expected_dim(&self) -> Option<usize> {
self.inner.expected_dim()
}
}
#[tokio::test]
async fn search_hybrid_charges_embedding_delay_to_embedding_not_vector() {
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let delay = std::time::Duration::from_millis(300);
let provider = SlowProvider {
inner: crate::embedding::test_helpers::MockProvider::new(dim),
delay,
};
let (_results, timings) = search_hybrid(
&index_dir,
&provider,
"authenticate",
"authenticate",
&SearchFilters::default(),
5,
60.0,
dim,
50,
)
.await
.unwrap();
let embedding = timings.embedding.expect("embedding stage must be reported");
let vector = timings.vector.expect("vector stage must be reported");
assert!(
embedding >= delay,
"embedding must carry the provider cost: {embedding:?} < {delay:?}"
);
assert!(
vector > std::time::Duration::ZERO,
"vector must still carry the storage cost: {vector:?}"
);
assert_ne!(
embedding, vector,
"the two stages must not be one measurement printed twice"
);
}
#[test]
fn charge_vector_span_partitions_the_span() {
let span = std::time::Duration::from_millis(500);
let embed = std::time::Duration::from_millis(300);
let mut timings = HybridTimings::default();
charge_vector_span(&mut timings, span, Some(embed));
assert_eq!(
(timings.embedding, timings.vector),
(Some(embed), Some(std::time::Duration::from_millis(200))),
"embedding takes the model cost and vector takes the remainder"
);
let mut failed = HybridTimings::default();
charge_vector_span(&mut failed, span, None);
assert_eq!(
(failed.embedding, failed.vector),
(None, Some(span)),
"an unmeasured embedding leaves the whole span on vector"
);
}
#[tokio::test]
async fn search_hybrid_reranked_returns_reranked_results() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::new();
let (results, _timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"authenticate",
"authenticate",
&SearchFilters::default(),
5,
5,
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(
!results.is_empty(),
"should find results for 'authenticate'"
);
for i in 1..results.len() {
assert!(
results[i - 1].score >= results[i].score,
"reranked scores must be descending: {} >= {}",
results[i - 1].score,
results[i].score,
);
}
}
#[tokio::test]
async fn reranked_tail_scores_remain_descending_across_score_domains() {
use crate::embedding::test_helpers::MockProvider;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let (results, _) = search_hybrid_reranked(
&index_dir,
&provider,
&NegativeReranker,
"function",
"function",
&SearchFilters::default(),
10,
1,
60.0,
dim,
1,
50,
)
.await
.unwrap();
assert!(results.len() > 1);
assert!(
results
.windows(2)
.all(|pair| pair[0].score >= pair[1].score)
);
}
#[tokio::test]
async fn search_hybrid_reranked_skips_without_surplus_and_runs_with_surplus() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::reranker::RerankerError;
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::failing(RerankerError::ConnectionError {
message: "reranker should only be called for a surplus pool".to_string(),
});
let fetch_limit = 10;
let (fused_results, _) = search_hybrid(
&index_dir,
&provider,
"function",
"function",
&SearchFilters::default(),
fetch_limit,
60.0,
dim,
50,
)
.await
.unwrap();
assert!(!fused_results.is_empty());
let (_, timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"function",
"function",
&SearchFilters::default(),
fetch_limit,
fused_results.len(),
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(
timings.reranking.is_none(),
"reranker should not be called when the fused pool fits the result limit"
);
let (_, timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"function",
"function",
&SearchFilters::default(),
fetch_limit,
fused_results.len() - 1,
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(
timings.reranking.is_some(),
"reranker should be called when the fused pool exceeds the result limit"
);
}
#[tokio::test]
async fn search_hybrid_reranked_degrades_on_reranker_failure() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::reranker::RerankerError;
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::failing(RerankerError::ConnectionError {
message: "reranker timeout".to_string(),
});
let (results, timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"authenticate",
"authenticate",
&SearchFilters::default(),
5,
1,
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(
timings.reranking.is_some(),
"the failing reranker must be attempted when the result limit is below the candidate pool"
);
assert!(
!results.is_empty(),
"should return unreranked results when reranker fails"
);
}
#[tokio::test]
async fn search_hybrid_reranked_degrades_on_embedding_failure() {
use crate::embedding::EmbeddingError;
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::failing(EmbeddingError::ConnectionError {
message: "embedding API down".to_string(),
});
let reranker = MockReranker::new();
let (results, _timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"authenticate",
"authenticate",
&SearchFilters::default(),
5,
5,
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(
!results.is_empty(),
"should return BM25-only results when embedding API fails"
);
}
#[tokio::test]
async fn search_hybrid_reranked_respects_limit() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::new();
let (results, _timings) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"function",
"function",
&SearchFilters::default(),
2,
2,
60.0,
dim,
10,
50,
)
.await
.unwrap();
assert!(results.len() <= 2, "should respect the limit of 2");
}
#[tokio::test]
async fn reranking_preserves_unreranked_tail_for_later_filtering() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::apply_filters;
use crate::retrieval::reranker::test_helpers::MockReranker;
use crate::types::SearchFilters;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::new();
let (hybrid_results, _) = search_hybrid(
&index_dir,
&provider,
"function",
"function",
&SearchFilters::default(),
10,
60.0,
dim,
50,
)
.await
.unwrap();
let first = hybrid_results
.first()
.expect("test index should have results");
let tail_candidate = hybrid_results
.iter()
.skip(1)
.find(|candidate| candidate.file_path != first.file_path)
.expect("test index should have a tail candidate from another file")
.clone();
let (reranked_results, _) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
"function",
"function",
&SearchFilters::default(),
10,
10,
60.0,
dim,
1,
50,
)
.await
.unwrap();
let filtered = apply_filters(
reranked_results,
&SearchFilters {
path_glob: vec![tail_candidate.file_path.clone()],
..Default::default()
},
10,
);
assert!(filtered.iter().any(|result| {
result.file_path == tail_candidate.file_path
&& result.line_start == tail_candidate.line_start
&& result.line_end == tail_candidate.line_end
}));
}
#[test]
fn compute_vector_candidates_minimum_50() {
assert!(compute_vector_candidates(5, 3) >= 50);
assert!(compute_vector_candidates(1, 1) >= 50);
assert!(compute_vector_candidates(10, 3) >= 50);
}
#[test]
fn compute_vector_candidates_default_limit_10() {
assert_eq!(compute_vector_candidates(10, 3), 50);
assert_eq!(compute_vector_candidates(10, 5), 50);
}
#[test]
fn compute_vector_candidates_scales_with_limit() {
assert_eq!(compute_vector_candidates(100, 3), 300);
assert_eq!(compute_vector_candidates(100, 5), 500);
}
#[test]
fn path_queries_expand_bm25_candidate_pool() {
assert_eq!(
compute_bm25_candidates("turbo.json pipeline configuration", 20),
100
);
}
#[test]
fn natural_language_queries_expand_bm25_candidate_pool() {
assert_eq!(
compute_bm25_candidates("request validation and schema enforcement", 20),
80
);
}
#[test]
fn short_identifier_queries_expand_bm25_candidate_pool() {
assert_eq!(compute_bm25_candidates("Config", 20), 80);
}
#[tokio::test]
async fn nl_query_uses_same_rrf_k_as_identifier() {
use crate::embedding::test_helpers::MockProvider;
use crate::retrieval::query_classifier::{QueryType, classify_query, params_for_query_type};
use crate::retrieval::reranker::test_helpers::MockReranker;
let tmp = tempfile::tempdir().unwrap();
let (index_dir, dim) = setup_test_index(tmp.path()).await;
let provider = MockProvider::new(dim);
let reranker = MockReranker::new();
let id_query = "authenticate";
let id_type = classify_query(id_query);
assert_eq!(id_type, QueryType::Identifier);
let id_params = params_for_query_type(id_type);
let (id_results, _) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
id_query,
id_query,
&SearchFilters::default(),
5,
5,
id_params.rrf_k,
dim,
10,
compute_vector_candidates(5, id_params.vector_candidate_multiplier),
)
.await
.unwrap();
let nl_query = "how is authentication handled";
let nl_type = classify_query(nl_query);
assert_eq!(nl_type, QueryType::NaturalLanguage);
let nl_params = params_for_query_type(nl_type);
let (nl_results, _) = search_hybrid_reranked(
&index_dir,
&provider,
&reranker,
nl_query,
nl_query,
&SearchFilters::default(),
5,
5,
nl_params.rrf_k,
dim,
10,
compute_vector_candidates(5, nl_params.vector_candidate_multiplier),
)
.await
.unwrap();
assert!(
!id_results.is_empty(),
"identifier query should find results"
);
assert!(!nl_results.is_empty(), "NL query should find results");
assert_eq!(
id_params.rrf_k, nl_params.rrf_k,
"identifier k ({}) should equal NL k ({})",
id_params.rrf_k, nl_params.rrf_k
);
assert_eq!(id_params.rrf_k, 60.0);
assert_eq!(nl_params.rrf_k, 60.0);
}
#[cfg(test)]
mod indexed_files_cache_tests {
use super::super::SearchStores;
use crate::storage::metadata::MetadataStore;
use crate::types::{Chunk, Language, SymbolType};
use std::sync::Arc;
fn chunk(file_path: &str) -> Chunk {
Chunk {
id: format!("{file_path}:1"),
file_path: file_path.to_string(),
line_start: 1,
line_end: 3,
content: "fn f() {}".to_string(),
language: Language::Rust,
symbol_type: Some(SymbolType::Function),
symbol_name: Some("f".to_string()),
}
}
#[test]
fn indexed_files_cache_refreshes_after_metadata_update() {
let dir = tempfile::tempdir().unwrap();
let index_dir = dir.path();
let metadata_path = index_dir.join("metadata.db");
MetadataStore::open(&metadata_path)
.unwrap()
.insert_chunks(&[chunk("src/a.rs")])
.unwrap();
let stores = SearchStores::open(index_dir).unwrap();
let first = stores.indexed_files().unwrap();
assert_eq!(first.as_slice(), &["src/a.rs".to_string()]);
let second = stores.indexed_files().unwrap();
assert!(Arc::ptr_eq(&first, &second));
MetadataStore::open(&metadata_path)
.unwrap()
.insert_chunks(&[chunk("src/b.rs")])
.unwrap();
let third = stores.indexed_files().unwrap();
assert_eq!(
third.as_slice(),
&["src/a.rs".to_string(), "src/b.rs".to_string()],
"cache must refresh after the metadata database changes"
);
assert!(!Arc::ptr_eq(&first, &third));
}
}