CSHARP-4576: Atlas search: support score in Compound operator (#1045)

Author: BorisDog

src/MongoDB.Driver/Search/CompoundSearchDefinitionBuilder.cs

@@ -29,6 +29,16 @@ public sealed class CompoundSearchDefinitionBuilder<TDocument>
         private List<SearchDefinition<TDocument>> _should;
         private List<SearchDefinition<TDocument>> _filter;
         private int _minimumShouldMatch = 0;
+        private SearchScoreDefinition<TDocument> _score;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CompoundSearchDefinitionBuilder{TDocument}"/> class.
+        /// </summary>
+        /// <param name="score"></param>
+        public CompoundSearchDefinitionBuilder(SearchScoreDefinition<TDocument> score = null)
+        {
+            _score = score;
+        }
 
         /// <summary>
         /// Adds clauses which must match to produce results.
@@ -117,7 +127,7 @@ public CompoundSearchDefinitionBuilder<TDocument> MinimumShouldMatch(int minimum
         /// </summary>
         /// <returns>A compound search definition.</returns>
         public SearchDefinition<TDocument> ToSearchDefinition() =>
-            new CompoundSearchDefinition<TDocument>(_must, _mustNot, _should, _filter, _minimumShouldMatch);
+            new CompoundSearchDefinition<TDocument>(_must, _mustNot, _should, _filter, _minimumShouldMatch, _score);
 
         /// <summary>
         /// Performs an implicit conversion from a <see cref="CompoundSearchDefinitionBuilder{TDocument}"/>

src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs

@@ -64,8 +64,9 @@ public CompoundSearchDefinition(
             List<SearchDefinition<TDocument>> mustNot,
             List<SearchDefinition<TDocument>> should,
             List<SearchDefinition<TDocument>> filter,
-            int minimumShouldMatch)
-                : base(OperatorType.Compound)
+            int minimumShouldMatch,
+            SearchScoreDefinition<TDocument> score)
+                : base(OperatorType.Compound, score)
         {
             // This constructor should always be called from the compound search definition builder that ensures the arguments are valid.
             _must = must;

src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs

@@ -68,7 +68,7 @@ public SearchDefinition<TDocument> Autocomplete<TField>(
         /// Creates a builder for a compound search definition.
         /// </summary>
         /// <returns></returns>
-        public CompoundSearchDefinitionBuilder<TDocument> Compound() => new CompoundSearchDefinitionBuilder<TDocument>();
+        public CompoundSearchDefinitionBuilder<TDocument> Compound(SearchScoreDefinition<TDocument> score = null) => new CompoundSearchDefinitionBuilder<TDocument>(score);
 
         /// <summary>
         /// Creates a search definition that queries for documents where an indexed field is equal

tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs

@@ -80,12 +80,20 @@ public void Autocomplete()
         [Fact]
         public void Compound()
         {
-            var result = SearchSingle(Builders.Search.Compound()
+            const int score = 42;
+            var searchDefinition = Builders.Search.Compound(Builders.SearchScore.Constant(score))
                 .Must(Builders.Search.Text(x => x.Body, "life"), Builders.Search.Text(x => x.Body, "liberty"))
                 .MustNot(Builders.Search.Text(x => x.Body, "property"))
-                .Must(Builders.Search.Text(x => x.Body, "pursuit of happiness")));
+                .Must(Builders.Search.Text(x => x.Body, "pursuit of happiness"));
 
+            var projectionDefinition = Builders.Projection
+                .Include(x => x.Body)
+                .Include(x => x.Title)
+                .MetaSearchScore("score");
+
+            var result = SearchSingle(searchDefinition, projectionDefinition);
             result.Title.Should().Be("Declaration of Independence");
+            result.Score.Should().Be(score);
         }
 
         [Fact]
@@ -436,13 +444,17 @@ public void Wildcard()
         private List<AirbnbListing> GeoSearch(SearchDefinition<AirbnbListing> searchDefintion) =>
             GetGeoTestCollection().Aggregate().Search(searchDefintion).ToList();
 
-        private HistoricalDocument SearchSingle(SearchDefinition<HistoricalDocument> searchDefintion) =>
-            GetTestCollection()
-                .Aggregate()
-                .Search(searchDefintion)
-                .Limit(1)
-                .ToList()
-                .Single();
+        private HistoricalDocument SearchSingle(SearchDefinition<HistoricalDocument> searchDefintion, ProjectionDefinition<HistoricalDocument, HistoricalDocument> projectionDefinition = null)
+        {
+            var fluent = GetTestCollection().Aggregate().Search(searchDefintion);
+
+            if (projectionDefinition != null)
+            {
+                fluent = fluent.Project(projectionDefinition);
+            }
+
+            return fluent.Limit(1).ToList().Single();
+        }
 
         private IMongoCollection<HistoricalDocument> GetTestCollection() => _disposableMongoClient
             .GetDatabase("sample_training")

tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs

@@ -157,6 +157,11 @@ public void Compound()
                     .Must(
                         subject.Exists("z")),
                 "{ compound: { must: [{ exists: { path: 'x' } }, { exists: { path: 'y' } }, { exists: { path: 'z' } }], mustNot: [{ exists: { path: 'foo' } }, { exists: { path: 'bar' } }] } }");
+
+            var scoreBuilder = new SearchScoreDefinitionBuilder<BsonDocument>();
+            AssertRendered<BsonDocument>(
+                    subject.Compound(scoreBuilder.Constant(123)).Must(subject.Exists("x"), subject.Exists("y")),
+                    "{ compound: { must: [{ exists: { path: 'x' } }, { exists: { path: 'y' } } ], score: { constant: { value: 123 } }  } }");
         }
 
         [Fact]
@@ -175,6 +180,11 @@ public void Compound_typed()
                     .Must(
                         subject.Exists(p => p.LastName)),
                 "{ compound: { must: [{ exists: { path: 'age' } }, { exists: { path: 'fn' } }, { exists: { path: 'ln' } }], mustNot: [{ exists: { path: 'ret' } }, { exists: { path: 'dob' } }] } }");
+
+            var scoreBuilder = new SearchScoreDefinitionBuilder<Person>();
+            AssertRendered<Person>(
+                    subject.Compound(scoreBuilder.Constant(123)).Must(subject.Exists(p => p.Age)),
+                    "{ compound: { must: [{ exists: { path: 'age' } } ], score: { constant: { value: 123 } }  } }");
         }
 
         [Theory]