CSHARP-4926: Support token field type with Equals operators (#1565)

Author: adelinowona

src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs

@@ -145,6 +145,7 @@ private static BsonValue ToBsonValue(TField value) =>
                 DateTime v => (BsonDateTime)v,
                 DateTimeOffset v => (BsonDateTime)v.UtcDateTime,
                 ObjectId v => (BsonObjectId)v,
+                string v => (BsonString)v,
                 _ => throw new InvalidCastException()
             };
     }

src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs

@@ -111,7 +111,7 @@ public SearchDefinition<TDocument> EmbeddedDocument<TField>(
         /// <summary>
         /// Creates a search definition that queries for documents where an indexed field is equal
         /// to the specified value.
-        /// Supported value types are boolean, numeric, ObjectId and date.
+        /// Supported value types are boolean, numeric, ObjectId, date and string.
         /// </summary>
         /// <typeparam name="TField">The type of the field.</typeparam>
         /// <param name="path">The indexed field to search.</param>
@@ -121,14 +121,13 @@ public SearchDefinition<TDocument> EmbeddedDocument<TField>(
         public SearchDefinition<TDocument> Equals<TField>(
             FieldDefinition<TDocument, TField> path,
             TField value,
-            SearchScoreDefinition<TDocument> score = null)
-            where TField : struct, IComparable<TField> =>
+            SearchScoreDefinition<TDocument> score = null) =>
                 new EqualsSearchDefinition<TDocument, TField>(path, value, score);
 
         /// <summary>
         /// Creates a search definition that queries for documents where an indexed field is equal
         /// to the specified value.
-        /// Supported value types are boolean, numeric, ObjectId and date.
+        /// Supported value types are boolean, numeric, ObjectId, date and string.
         /// </summary>
         /// <typeparam name="TField">The type of the field.</typeparam>
         /// <param name="path">The indexed field to search.</param>
@@ -138,9 +137,25 @@ public SearchDefinition<TDocument> Equals<TField>(
         public SearchDefinition<TDocument> Equals<TField>(
             Expression<Func<TDocument, TField>> path,
             TField value,
-            SearchScoreDefinition<TDocument> score = null)
-            where TField : struct, IComparable<TField> =>
+            SearchScoreDefinition<TDocument> score = null) =>
                 Equals(new ExpressionFieldDefinition<TDocument, TField>(path), value, score);
+        
+        /// <summary>
+        /// Creates a search definition that queries for documents where at least one element in an indexed array field is equal
+        /// to the specified value.
+        /// Supported value types are boolean, numeric, ObjectId, date and string.
+        /// </summary>
+        /// <typeparam name="TField">The type of elements contained in the indexed array field.</typeparam>
+        /// <param name="path">The indexed array field to search.</param>
+        /// <param name="value">The value to query for.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>An equality search definition.</returns>
+        public SearchDefinition<TDocument> Equals<TField>(
+            Expression<Func<TDocument, IEnumerable<TField>>> path,
+            TField value,
+            SearchScoreDefinition<TDocument> score = null) =>
+            new EqualsSearchDefinition<TDocument, TField>(
+                new ExpressionFieldDefinition<TDocument, IEnumerable<TField>>(path), value, score);
 
         /// <summary>
         /// Creates a search definition that tests if a path to a specified indexed field name
@@ -574,7 +589,7 @@ public SearchDefinition<TDocument> QueryString<TField>(
         /// <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 a range search definition.</returns>
+        /// <returns>A range search definition.</returns>
         public SearchDefinition<TDocument> Range<TField>(
             Expression<Func<TDocument, TField>> path,
             SearchRange<TField> range,
@@ -589,7 +604,7 @@ public SearchDefinition<TDocument> Range<TField>(
         /// <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 a range search definition.</returns>
+        /// <returns>A range search definition.</returns>
         public SearchDefinition<TDocument> Range<TField>(
             SearchPathDefinition<TDocument> path,
             SearchRange<TField> range,

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

@@ -23,7 +23,6 @@
 using MongoDB.Driver.Core.TestHelpers.Logging;
 using MongoDB.Driver.GeoJsonObjectModel;
 using MongoDB.Driver.Search;
-using MongoDB.Driver.TestHelpers;
 using MongoDB.TestHelpers.XunitExtensions;
 using Xunit;
 using Xunit.Abstractions;
@@ -132,6 +131,35 @@ public void EmbeddedDocument()
             }
         }
 
+        [Fact]
+        public void EqualsArrayField()
+        {
+            var results = GetSynonymTestCollection().Aggregate()
+                .Search(Builders<Movie>.Search.Equals(p => p.Genres, "family"))
+                .Limit(3)
+                .ToList();
+            
+            results.Should().HaveCount(3);
+            foreach (var result in results)
+            {
+                result.Genres.Should().Contain("Family");
+            }
+            
+            results[0].Title.Should().Be("The Poor Little Rich Girl");
+            results[1].Title.Should().Be("Robin Hood");
+            results[2].Title.Should().Be("Peter Pan");
+        }
+        
+        [Fact]
+        public void EqualsStringField()
+        {
+            var results = GetSynonymTestCollection().Aggregate()
+                .Search(Builders<Movie>.Search.Equals(p => p.Title, "a corner in wheat"))
+                .ToList();
+            
+            results.Should().ContainSingle().Which.Title.Should().Be("A Corner in Wheat");
+        }
+
         [Fact]
         public void Exists()
         {
@@ -749,6 +777,9 @@ public class Comment
         [BsonIgnoreExtraElements]
         public class Movie
         {
+            [BsonElement("genres")]
+            public string[] Genres { get; set; }
+            
             [BsonElement("title")]
             public string Title { get; set; }
 

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

@@ -261,6 +261,16 @@ public void EmbeddedDocument_typed()
                 subjectFamily.EmbeddedDocument(p => p.Children, subjectPerson.QueryString(p => p.LastName, "berg")),
                 "{ embeddedDocument: { path : 'Children', operator : { 'queryString' : { defaultPath : 'Children.ln', query : 'berg' } } } }");
         }
+        
+        [Fact]
+        public void Equals_with_array_should_render_supported_type()
+        {
+            var subjectTyped = CreateSubject<Person>();
+            
+            AssertRendered(
+                subjectTyped.Equals(p => p.Hobbies, "soccer"),
+                "{ equals: { path: 'hobbies', value: 'soccer' } }");
+        }
 
         [Theory]
         [MemberData(nameof(EqualsSupportedTypesTestData))]
@@ -269,7 +279,6 @@ public void Equals_should_render_supported_type<T>(
             string valueRendered,
             Expression<Func<Person, T>> fieldExpression,
             string fieldRendered)
-            where T : struct, IComparable<T>
         {
             var subject = CreateSubject<BsonDocument>();
             var subjectTyped = CreateSubject<Person>();
@@ -302,12 +311,13 @@ public void Equals_should_render_supported_type<T>(
             new object[] { (double)1, "1", Exp(p => p.Double), nameof(Person.Double) },
             new object[] { DateTime.MinValue, "ISODate(\"0001-01-01T00:00:00Z\")", Exp(p => p.Birthday), "dob" },
             new object[] { DateTimeOffset.MaxValue, "ISODate(\"9999-12-31T23:59:59.999Z\")", Exp(p => p.DateTimeOffset), nameof(Person.DateTimeOffset) },
-            new object[] { ObjectId.Empty, "{ $oid: '000000000000000000000000' }", Exp(p => p.Id), "_id" }
+            new object[] { ObjectId.Empty, "{ $oid: '000000000000000000000000' }", Exp(p => p.Id), "_id" },
+            new object[] { "Jim", "\"Jim\"", Exp(p => p.FirstName), "fn" }
         };
 
         [Theory]
         [MemberData(nameof(EqualsUnsupportedTypesTestData))]
-        public void Equals_should_throw_on_unsupported_type<T>(T value, Expression<Func<Person, T>> fieldExpression) where T : struct, IComparable<T>
+        public void Equals_should_throw_on_unsupported_type<T>(T value, Expression<Func<Person, T>> fieldExpression)
         {
             var subject = CreateSubject<BsonDocument>();
             Record.Exception(() => subject.Equals("x", value)).Should().BeOfType<InvalidCastException>();
@@ -1248,6 +1258,9 @@ public class Person : SimplePerson
 
             [BsonElement("ret")]
             public bool Retired { get; set; }
+            
+            [BsonElement("hobbies")]
+            public string[] Hobbies { get; set; }
 
             public object Object { get; set; }
         }