test(rag): update Hybrid/MultiQuery tests for RRF fusion + real query variations

Seven pre-existing HybridRetrieverTests/MultiQueryRetrieverTests asserted the old
behavior that the RRF-fusion (#27) and real-query-expansion (#19) changes correctly
replaced: exact weighted-sum scores (0.7*d+0.3*s) and the "{query} variation N"
placeholder. RRF is rank-based (scores are small, order is what matters) and MultiQuery
now emits real reformulations. Reassert the meaningful properties: fused doc presence +
ranking, and original-query-first with distinct variations. All 105 pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: franklinic

tests/AiDotNet.Tests/UnitTests/RetrievalAugmentedGeneration/HybridRetrieverTests.cs

@@ -318,10 +318,10 @@ public async Task Retrieve_OverlappingResults_CombinesScores()
 
             // Assert
             Assert.Equal(3, results.Count);
-            // doc1 should have combined score: 0.9 * 0.7 + 0.8 * 0.3 = 0.63 + 0.24 = 0.87
+            // doc1 appears in BOTH lists, so RRF fuses its two rank contributions and it ranks first.
             var doc1 = results.First(r => r.Id == "doc1");
             Assert.True(doc1.HasRelevanceScore);
-            Assert.True(doc1.RelevanceScore > 0.8); // Combined should be higher than either alone
+            Assert.Equal("doc1", results[0].Id);
         }
 
         [Fact(Timeout = 60000)]
@@ -452,8 +452,9 @@ public async Task Retrieve_EqualWeights_ProducesEqualContribution()
 
             // Assert
             Assert.Single(results);
-            // Score should be 1.0 * 0.5 + 1.0 * 0.5 = 1.0
-            Assert.Equal(1.0, results[0].RelevanceScore, 3);
+            // Equal weights → both lists contribute equally to the RRF fusion; the doc is returned.
+            Assert.Equal("doc1", results[0].Id);
+            Assert.True(results[0].RelevanceScore > 0);
         }
 
         [Fact(Timeout = 60000)]
@@ -497,8 +498,9 @@ public async Task Retrieve_ZeroDenseWeight_OnlyUsesSparseScore()
 
             // Assert
             Assert.Single(results);
-            // Score should be 1.0 * 0.0 + 0.5 * 1.0 = 0.5
-            Assert.Equal(0.5, results[0].RelevanceScore, 3);
+            // With zero dense weight only the sparse ranking contributes to RRF; the doc is still returned.
+            Assert.Equal("doc1", results[0].Id);
+            Assert.True(results[0].RelevanceScore > 0);
         }
 
         [Fact(Timeout = 60000)]
@@ -519,8 +521,10 @@ public async Task Retrieve_ZeroSparseWeight_OnlyUsesDenseScore()
 
             // Assert
             Assert.Single(results);
-            // Score should be 0.8 * 1.0 + 1.0 * 0.0 = 0.8
-            Assert.Equal(0.8, results[0].RelevanceScore, 3);
+            // With zero sparse weight the sparse list contributes nothing to the RRF fusion; the doc is
+            // still returned via the dense ranking with a positive fused score.
+            Assert.Equal("doc1", results[0].Id);
+            Assert.True(results[0].RelevanceScore > 0);
         }
 
         #endregion
@@ -776,8 +780,10 @@ public async Task Constructor_DefaultWeights_Uses70Dense30Sparse()
 
             // Assert
             Assert.Single(results);
-            // Default weights: 0.7 dense + 0.3 sparse = 1.0 * 0.7 + 1.0 * 0.3 = 1.0
-            Assert.Equal(1.0, results[0].RelevanceScore, 3);
+            // Hybrid fusion is now Reciprocal Rank Fusion (rank-based, scale-free) rather than a raw
+            // weighted sum of scores. A doc ranked #1 in both lists is returned with a positive fused score.
+            Assert.Equal("doc1", results[0].Id);
+            Assert.True(results[0].RelevanceScore > 0);
         }
 
         [Fact(Timeout = 60000)]

tests/AiDotNet.Tests/UnitTests/RetrievalAugmentedGeneration/MultiQueryRetrieverTests.cs

@@ -333,9 +333,11 @@ public async Task Retrieve_QueriesContainVariations()
             var results = retriever.Retrieve("test").ToList();
 
             // Assert
-            // Should have variations like "test variation 1", "test variation 2"
-            Assert.Contains(baseRetriever.QueriesReceived, q => q.Contains("variation 1"));
-            Assert.Contains(baseRetriever.QueriesReceived, q => q.Contains("variation 2"));
+            // MultiQuery now produces real query variations (LLM when a generator is supplied, deterministic
+            // template reformulations otherwise) rather than the old "{query} variation N" placeholder. The
+            // base retriever should see the original query plus additional distinct variations.
+            Assert.Contains("test", baseRetriever.QueriesReceived);
+            Assert.True(baseRetriever.QueriesReceived.Distinct().Count() >= 3);
         }
 
         [Fact(Timeout = 60000)]
@@ -698,11 +700,10 @@ public async Task Retrieve_VariationsAppendToOriginal()
             var results = retriever.Retrieve("my query").ToList();
 
             // Assert
-            // Variations should start with original query
-            foreach (var query in baseRetriever.QueriesReceived.Skip(1))
-            {
-                Assert.StartsWith("my query", query);
-            }
+            // The original query is retrieved first; the remaining queries are distinct reformulations
+            // (which embed, but no longer necessarily start with, the original text).
+            Assert.Equal("my query", baseRetriever.QueriesReceived.First());
+            Assert.True(baseRetriever.QueriesReceived.Distinct().Count() >= 2);
         }
 
         #endregion