CSHARP-5430: Add array field support for In and Range search operators (#1576)

Author: adelinowona

src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs

@@ -330,7 +330,7 @@ public SearchDefinition<TDocument> In<TField>(
         /// <summary>
         /// Creates a search definition that queries for documents where the value of the field equals to any of specified values.
         /// </summary>
-        /// <typeparam name="TField">The type of the field. Valid types are: boolean, ObjectId, Guid, number, date, string.</typeparam>
+        /// <typeparam name="TField">The type of the field. Valid types are: boolean, ObjectId, Guid, number, date, string, arrays.</typeparam>
         /// <param name="path">The indexed field or fields to search.</param>
         /// <param name="values">Values to compare the field with.</param>
         /// <param name="score">The score modifier.</param>
@@ -340,6 +340,20 @@ public SearchDefinition<TDocument> In<TField>(
             IEnumerable<TField> values,
             SearchScoreDefinition<TDocument> score = null) =>
                 In(new ExpressionFieldDefinition<TDocument>(path), values, score);
+        
+        /// <summary>
+        /// Creates a search definition that queries for documents where the value of the field equals to any of specified values.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field. Valid types are: boolean, ObjectId, Guid, number, date, string, arrays.</typeparam>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="values">Values to compare the field with.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>An In search definition.</returns>
+        public SearchDefinition<TDocument> In<TField>(
+            Expression<Func<TDocument, IEnumerable<TField>>> path,
+            IEnumerable<TField> values,
+            SearchScoreDefinition<TDocument> score = null) =>
+            In(new ExpressionFieldDefinition<TDocument>(path), values, score);
 
         /// <summary>
         /// Creates a search definition that returns documents similar to the input documents.
@@ -596,6 +610,21 @@ public SearchDefinition<TDocument> Range<TField>(
             SearchScoreDefinition<TDocument> score = null)
             where TField : struct, IComparable<TField> =>
                 Range(new ExpressionFieldDefinition<TDocument>(path), range, score);
+        
+        /// <summary>
+        /// Creates a search definition that queries for documents where a field is in the specified range.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="range">The field range.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>A range search definition.</returns>
+        public SearchDefinition<TDocument> Range<TField>(
+            Expression<Func<TDocument, IEnumerable<TField>>> path,
+            SearchRange<TField> range,
+            SearchScoreDefinition<TDocument> score = null)
+            where TField : struct, IComparable<TField> =>
+            Range(new ExpressionFieldDefinition<TDocument>(path), range, score);
 
         /// <summary>
         /// Creates a search definition that queries for documents where a field is in the specified range.

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

@@ -106,6 +106,9 @@ public void Autocomplete_typed()
             AssertRendered(
                 subject.Autocomplete("FirstName", "foo"),
                 "{ autocomplete: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Autocomplete(x => x.Hobbies, "foo"),
+                "{ autocomplete: { query: 'foo', path: 'hobbies' } }");
 
             AssertRendered(
                 subject.Autocomplete(
@@ -352,6 +355,9 @@ public void Exists_typed()
             AssertRendered(
                 subject.Exists(x => x.FirstName),
                 "{ exists: { path: 'fn' } }");
+            AssertRendered(
+                subject.Exists(x => x.Hobbies),
+                "{ exists: { path: 'hobbies' } }");
             AssertRendered(
                 subject.Exists("FirstName"),
                 "{ exists: { path: 'fn' } }");
@@ -599,6 +605,16 @@ public void In_should_throw_when_values_are_not_of_same_type()
             var subjectTyped = CreateSubject<Person>();
             Record.Exception(() => subjectTyped.In(p => p.Object, values)).Should().BeOfType<ArgumentException>();
         }
+        
+        [Fact]
+        public void In_with_array_field_should_render_correctly()
+        {
+            var subjectTyped = CreateSubject<Person>();
+            
+            AssertRendered(
+                subjectTyped.In(p => p.Hobbies, ["dance", "ski"]),
+                "{ in: { path: 'hobbies', value: ['dance', 'ski'] } }");
+        }
 
         [Fact]
         public void MoreLikeThis()
@@ -771,6 +787,9 @@ public void Phrase_typed()
             AssertRendered(
                 subject.Phrase("FirstName", "foo"),
                 "{ phrase: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Phrase(x => x.Hobbies, "foo"),
+                "{ phrase: { query: 'foo', path: 'hobbies' } }");
 
             AssertRendered(
                 subject.Phrase(
@@ -832,6 +851,9 @@ public void QueryString_typed()
             AssertRendered(
                 subject.QueryString("FirstName", "foo"),
                 "{ queryString: { defaultPath: 'fn', query: 'foo' } }");
+            AssertRendered(
+                subject.QueryString(x => x.Hobbies, "foo"),
+                "{ queryString: { defaultPath: 'hobbies', query: 'foo' } }");
         }
 
         [Fact]
@@ -943,6 +965,16 @@ public void Range_should_throw_on_unsupported_types<T>(T value, Expression<Func<
             new object[] { (ulong)1, Exp(p => p.UInt64) },
             new object[] { TimeSpan.Zero, Exp(p => p.TimeSpan) },
         };
+        
+        [Fact]
+        public void Range_with_array_field_should_render_correctly()
+        {
+            var subject = CreateSubject<Person>();
+
+            AssertRendered(
+                subject.Range(x => x.SalaryHistory, SearchRangeBuilder.Gte(1000).Lt(2000)),
+                "{ range: { path: 'salaries', gte: 1000, lt: 2000 } }");
+        }
 
         [Fact]
         public void Regex()
@@ -986,6 +1018,9 @@ public void Regex_typed()
             AssertRendered(
                 subject.Regex("FirstName", "foo"),
                 "{ regex: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Regex(x => x.Hobbies, "foo"),
+                "{ regex: { query: 'foo', path: 'hobbies' } }");
 
             AssertRendered(
                 subject.Regex(
@@ -1100,6 +1135,9 @@ public void Text_typed()
             AssertRendered(
                 subject.Text("FirstName", "foo"),
                 "{ text: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Text(x => x.Hobbies, "foo"),
+                "{ text: { query: 'foo', path: 'hobbies' } }");
 
             AssertRendered(
                 subject.Text(
@@ -1180,6 +1218,9 @@ public void Wildcard_typed()
             AssertRendered(
                 subject.Wildcard("FirstName", "foo"),
                 "{ wildcard: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Wildcard(x => x.Hobbies, "foo"),
+                "{ wildcard: { query: 'foo', path: 'hobbies' } }");
 
             AssertRendered(
                 subject.Wildcard(
@@ -1265,6 +1306,9 @@ public class Person : SimplePerson
             [BsonElement("hobbies")]
             public string[] Hobbies { get; set; }
 
+            [BsonElement("salaries")]
+            public int[] SalaryHistory { get; set; }
+            
             public object Object { get; set; }
 
             public string Name { get; set; }