[Search] Add tests for semantic hybrid search with vector and remove defaults for SearchOptions.QueryAnswerCount and SearchOptions.QueryAnswerThreshold (Azure#36393)

[Search] Add sample for semantic hybrid search with vector

Author: ShivangiReja

sdk/search/Azure.Search.Documents/src/Options/SearchOptions.cs

@@ -3,7 +3,7 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Text;
 using Azure.Core;
 using Azure.Search.Documents.Models;
 
@@ -18,9 +18,7 @@ namespace Azure.Search.Documents
     [CodeGenModel("SearchRequest")]
     public partial class SearchOptions
     {
-        private const string QueryAnswerCountRawSplitter = "|count-";
         private const string QueryAnswerCountRaw = "count-";
-        private const string QueryAnswerThresholdRawSplitter = "|threshold-";
         private const string QueryAnswerThresholdRaw = "threshold-";
         private const string QueryCaptionRawSplitter = "|highlight-";
 
@@ -197,72 +195,71 @@ internal string OrderByRaw
         /// <summary> A value that specifies the threshold of <see cref="SearchResults{T}.Answers"/> that should be returned as part of the search response. </summary>
         public double? QueryAnswerThreshold { get; set; }
 
-        /// <summary> Constructed from <see cref="QueryAnswer"/>, <see cref="QueryAnswerCount"/> and <see cref="QueryAnswerThreshold"/>.</summary>
+        /// <summary> Constructed from <see cref="QueryAnswer"/>, <see cref="QueryAnswerCount"/> and <see cref="QueryAnswerThreshold"/>. For example: "extractive|count-1,threshold-0.7"</summary>
         [CodeGenMember("Answers")]
         internal string QueryAnswerRaw
         {
             get
             {
-                string queryAnswerStringValue = null;
-
                 if (QueryAnswer.HasValue)
                 {
-                    queryAnswerStringValue = $"{QueryAnswer.Value}{QueryAnswerCountRawSplitter}{QueryAnswerCount.GetValueOrDefault(1)}{QueryAnswerThresholdRawSplitter}{QueryAnswerThreshold.GetValueOrDefault(0.7)}";
+                    StringBuilder queryAnswerStringValue = new(QueryAnswer.Value.ToString());
+
+                    int tokens = 0;
+                    char NextToken() => tokens++ == 0 ? '|' : ',';
+
+                    if (QueryAnswerCount.HasValue)
+                    {
+                        queryAnswerStringValue.Append(NextToken()).Append($"{QueryAnswerCountRaw}{QueryAnswerCount.Value}");
+                        tokens = 1;
+                    }
+
+                    if (QueryAnswerThreshold.HasValue)
+                    {
+                        queryAnswerStringValue.Append(NextToken()).Append($"{QueryAnswerThresholdRaw}{QueryAnswerThreshold.Value}");
+                    }
+
+                    return queryAnswerStringValue.ToString();
                 }
 
-                return queryAnswerStringValue;
+                return null;
             }
-
             set
             {
-                if (string.IsNullOrEmpty(value))
-                {
-                    QueryAnswer = null;
-                    QueryAnswerCount = null;
-                    QueryAnswerThreshold = null;
-                }
-                else
+                if (!string.IsNullOrEmpty(value)) // If the value is - "extractive" or "extractive|count-1" or "extractive|threshold-0.7" or "extractive|count-5,threshold-0.9" or "extractive|threshold-0.8,count-4"
                 {
-                    if (value.Contains(QueryAnswerCountRawSplitter) || value.Contains(QueryAnswerThresholdRawSplitter))
+                    string[] queryAnswerValues = value.Split('|');
+                    if (!string.IsNullOrEmpty(queryAnswerValues[0]))
                     {
-                        string[] queryAnswerValues = value.Split('|');
-
-                        var queryAnswerPart = queryAnswerValues[0];
-                        if (string.IsNullOrEmpty(queryAnswerPart))
-                        {
-                            QueryAnswer = null;
-                        }
-                        else
-                        {
-                            QueryAnswer = new QueryAnswerType(queryAnswerPart);
-                        }
+                        QueryAnswer = new QueryAnswerType(queryAnswerValues[0]);
+                    }
 
-                        foreach (var queryAnswerValue in queryAnswerValues)
+                    if (queryAnswerValues.Length == 2)
+                    {
+                        var queryAnswerParams = queryAnswerValues[1].Split(',');
+                        if (queryAnswerParams.Length <= 2)
                         {
-                            if (queryAnswerValue.Contains(QueryAnswerCountRaw))
+                            foreach (var param in queryAnswerParams)
                             {
-                                var countPart = queryAnswerValue.Substring(queryAnswerValue.IndexOf(QueryAnswerCountRaw, StringComparison.OrdinalIgnoreCase) + QueryAnswerCountRaw.Length);
-                                if (int.TryParse(countPart, out int countValue))
+                                if (param.Contains(QueryAnswerCountRaw))
                                 {
-                                    QueryAnswerCount = countValue;
+                                    var countPart = param.Substring(param.IndexOf(QueryAnswerCountRaw, StringComparison.OrdinalIgnoreCase) + QueryAnswerCountRaw.Length);
+                                    if (int.TryParse(countPart, out int countValue))
+                                    {
+                                        QueryAnswerCount = countValue;
+                                    }
                                 }
-                            }
-                            else if (queryAnswerValue.Contains(QueryAnswerThresholdRaw))
-                            {
-                                var thresholdPart = queryAnswerValue.Substring(queryAnswerValue.IndexOf(QueryAnswerThresholdRaw, StringComparison.OrdinalIgnoreCase) + QueryAnswerThresholdRaw.Length);
-                                if (double.TryParse(thresholdPart, out double thresholdValue))
+                                else if (param.Contains(QueryAnswerThresholdRaw))
                                 {
-                                    QueryAnswerThreshold = thresholdValue;
+                                    var thresholdPart = param.Substring(param.IndexOf(QueryAnswerThresholdRaw, StringComparison.OrdinalIgnoreCase) + QueryAnswerThresholdRaw.Length);
+                                    if (double.TryParse(thresholdPart, out double thresholdValue))
+                                    {
+                                        QueryAnswerThreshold = thresholdValue;
+                                    }
                                 }
                             }
                         }
                     }
-                    else
-                    {
-                        QueryAnswer = new QueryAnswerType(value);
-                        QueryAnswerCount = null;
-                        QueryAnswerThreshold = null;
-                    }
                 }
             }
         }

sdk/search/Azure.Search.Documents/tests/DocumentOperations/VectorSearchTests.cs

@@ -20,11 +20,11 @@ public VectorSearch(bool async, SearchClientOptions.ServiceVersion serviceVersio
         }
 
         private async Task AssertKeysEqual<T>(
-            Response<SearchResults<T>> response,
+            SearchResults<T> response,
             Func<SearchResult<T>, string> keyAccessor,
             params string[] expectedKeys)
         {
-            List<SearchResult<T>> docs = await response.Value.GetResultsAsync().ToListAsync();
+            List<SearchResult<T>> docs = await response.GetResultsAsync().ToListAsync();
             CollectionAssert.AreEquivalent(expectedKeys, docs.Select(keyAccessor));
         }
 
@@ -36,7 +36,7 @@ public async Task SingleVectorSearch()
             var vectorizedResult = VectorSearchEmbeddings.SearchVectorizeDescription; // "Top hotels in town"
             await Task.Delay(TimeSpan.FromSeconds(1));
 
-            Response<SearchResults<Hotel>> response = await resources.GetSearchClient().SearchAsync<Hotel>(
+            SearchResults<Hotel> response = await resources.GetSearchClient().SearchAsync<Hotel>(
                    null,
                    new SearchOptions
                    {
@@ -57,7 +57,7 @@ public async Task SingleVectorSearchWithFilter()
 
             var vectorizedResult = VectorSearchEmbeddings.SearchVectorizeDescription; // "Top hotels in town"
 
-            Response<SearchResults<Hotel>> response = await resources.GetSearchClient().SearchAsync<Hotel>(
+            SearchResults<Hotel> response = await resources.GetSearchClient().SearchAsync<Hotel>(
                     null,
                     new SearchOptions
                     {
@@ -79,7 +79,7 @@ public async Task SimpleHybridSearch()
 
             var vectorizedResult = VectorSearchEmbeddings.SearchVectorizeDescription; // "Top hotels in town"
 
-            Response<SearchResults<Hotel>> response = await resources.GetSearchClient().SearchAsync<Hotel>(
+            SearchResults<Hotel> response = await resources.GetSearchClient().SearchAsync<Hotel>(
                     "Top hotels in town",
                     new SearchOptions
                     {
@@ -92,5 +92,48 @@ await AssertKeysEqual(
                 h => h.Document.HotelId,
                 "3", "1", "2", "10", "4", "5", "9");
         }
+
+        [Test]
+        public async Task SemanticHybridSearch()
+        {
+            await using SearchResources resources = await SearchResources.CreateWithHotelsIndexAsync(this);
+
+            var vectorizedResult = VectorSearchEmbeddings.SearchVectorizeDescription; // "Top hotels in town"
+
+            SearchResults<Hotel> response = await resources.GetSearchClient().SearchAsync<Hotel>(
+                    "Is there any hotel located on the main commercial artery of the city in the heart of New York?",
+                    new SearchOptions
+                    {
+                        Vector = new SearchQueryVector { Value = vectorizedResult, K = 3, Fields = "descriptionVector" },
+                        Select = { "hotelId", "hotelName", "description", "category" },
+                        QueryType = SearchQueryType.Semantic,
+                        QueryLanguage = QueryLanguage.EnUs,
+                        SemanticConfigurationName = "my-semantic-config",
+                        QueryCaption = QueryCaptionType.Extractive,
+                        QueryAnswer = QueryAnswerType.Extractive,
+                    });
+
+            Assert.NotNull(response.Answers);
+            Assert.AreEqual(1, response.Answers.Count);
+            Assert.AreEqual("9", response.Answers[0].Key);
+            Assert.NotNull(response.Answers[0].Highlights);
+            Assert.NotNull(response.Answers[0].Text);
+
+            await foreach (SearchResult<Hotel> result in response.GetResultsAsync())
+            {
+                Hotel doc = result.Document;
+
+                Assert.NotNull(result.Captions);
+
+                var caption = result.Captions.FirstOrDefault();
+                Assert.NotNull(caption.Highlights, "Caption highlight is null");
+                Assert.NotNull(caption.Text, "Caption text is null");
+            }
+
+            await AssertKeysEqual(
+                response,
+                h => h.Document.HotelId,
+                "9", "3", "2", "5", "10", "1", "4");
+        }
     }
 }

sdk/search/Azure.Search.Documents/tests/Models/SearchOptionsTests.cs

@@ -56,11 +56,12 @@ public void QueryAnswerOptionWithNoCountAndThreshold()
             Assert.IsNull(searchOptions.QueryAnswerRaw);
 
             searchOptions.QueryAnswer = QueryAnswerType.None;
-            Assert.AreEqual($"{QueryAnswerType.None}|count-1|threshold-0.7", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.None}", searchOptions.QueryAnswerRaw);
             Assert.IsNull(searchOptions.QueryAnswerCount);
+            Assert.IsNull(searchOptions.QueryAnswerThreshold);
 
             searchOptions.QueryAnswer = QueryAnswerType.Extractive;
-            Assert.AreEqual($"{QueryAnswerType.Extractive}|count-1|threshold-0.7", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.Extractive}", searchOptions.QueryAnswerRaw);
             Assert.IsNull(searchOptions.QueryAnswerCount);
 
             searchOptions.QueryAnswerRaw = "none";
@@ -149,7 +150,7 @@ public void QueryAnswerOptionWithCountAndThreshold()
             Assert.IsNull(searchOptions.QueryAnswerRaw);
             Assert.IsNull(searchOptions.QueryAnswer);
 
-            searchOptions.QueryAnswerRaw = "|threshold-0.5|count-3";
+            searchOptions.QueryAnswerRaw = "|threshold-0.5,count-3";
             Assert.AreEqual(3, searchOptions.QueryAnswerCount);
             Assert.AreEqual(0.5, searchOptions.QueryAnswerThreshold);
             Assert.IsNull(searchOptions.QueryAnswer);
@@ -164,25 +165,25 @@ public void QueryAnswerOption()
 
             // We can set `QueryAnswer` to one of the known values, using either a string or a pre-defined value.
             searchOptions.QueryAnswer = "none";
-            Assert.AreEqual($"{QueryAnswerType.None}|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.None}|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
             searchOptions.QueryAnswer = QueryAnswerType.None;
-            Assert.AreEqual($"{QueryAnswerType.None}|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.None}|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
             searchOptions.QueryAnswer = "extractive";
-            Assert.AreEqual($"{QueryAnswerType.Extractive}|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.Extractive}|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
             searchOptions.QueryAnswer = QueryAnswerType.Extractive;
-            Assert.AreEqual($"{QueryAnswerType.Extractive}|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"{QueryAnswerType.Extractive}|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
             // We can also set `QueryAnswer` to a value unknown to the SDK.
             searchOptions.QueryAnswer = "unknown";
-            Assert.AreEqual($"unknown|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"unknown|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
             searchOptions.QueryAnswer = new QueryAnswerType("unknown");
-            Assert.AreEqual($"unknown|count-{searchOptions.QueryAnswerCount}|threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
+            Assert.AreEqual($"unknown|count-{searchOptions.QueryAnswerCount},threshold-{searchOptions.QueryAnswerThreshold}", searchOptions.QueryAnswerRaw);
 
-            searchOptions.QueryAnswerRaw = "unknown|count-10|threshold-0.8";
+            searchOptions.QueryAnswerRaw = "unknown|count-10,threshold-0.8";
             Assert.AreEqual("unknown", $"{searchOptions.QueryAnswer}");
             Assert.AreEqual(10, searchOptions.QueryAnswerCount);
             Assert.AreEqual(0.8, searchOptions.QueryAnswerThreshold);
@@ -279,7 +280,7 @@ public void SearchOptionsForSemanticSearch()
                 QueryCaption = QueryCaptionType.Extractive,
             };
 
-            Assert.AreEqual("extractive|count-5|threshold-0.8", semanticSearchOptions.QueryAnswerRaw);
+            Assert.AreEqual("extractive|count-5,threshold-0.8", semanticSearchOptions.QueryAnswerRaw);
             Assert.AreEqual("extractive|highlight-True", semanticSearchOptions.QueryCaptionRaw);
         }
     }