CSHARP-5442: Atlas Search doesn't respect the correct serializer

src/MongoDB.Driver/FieldValueSerializerHelper.cs

@@ -317,6 +317,8 @@ internal class IEnumerableSerializer<TItem> : SerializerBase<IEnumerable<TItem>>
         {
             private readonly IBsonSerializer<TItem> _itemSerializer;
 
+            public IBsonSerializer<TItem> ItemSerializer => _itemSerializer;
+
             public IEnumerableSerializer(IBsonSerializer<TItem> itemSerializer)
             {
                 _itemSerializer = itemSerializer;

src/MongoDB.Driver/IAggregateFluent.cs

@@ -404,7 +404,6 @@ IAggregateFluent<TNewResult> Lookup<TForeignDocument, TAsElement, TAs, TNewResul
         IAggregateFluent<BsonDocument> SetWindowFields<TWindowFields>(
             AggregateExpressionDefinition<ISetWindowFieldsPartition<TResult>, TWindowFields> output);
 
-        //TODO If I add a parameter here, then this would be a binary breaking change
         /// <summary>
         /// Appends a $search stage to the pipeline.
         /// </summary>

src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs

@@ -17,6 +17,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using MongoDB.Bson;
+using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.GeoJsonObjectModel;
@@ -118,38 +119,88 @@ private protected override BsonDocument RenderArguments(RenderArgs<TDocument> ar
 
     internal sealed class EqualsSearchDefinition<TDocument, TField> : OperatorSearchDefinition<TDocument>
     {
-        private readonly BsonValue _value;
+        private readonly TField _value;
+        private readonly FieldDefinition<TDocument, TField> _field;
+        private readonly FieldDefinition<TDocument, IEnumerable<TField>> _arrayField;
+
+        private readonly List<Type> _validTypes =
+        [
+            typeof(bool),
+            typeof(sbyte),
+            typeof(byte),
+            typeof(short),
+            typeof(ushort),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(float),
+            typeof(double),
+            typeof(DateTime),
+            typeof(DateTimeOffset),
+            typeof(ObjectId),
+            typeof(Guid),
+            typeof(string)
+        ];
+
+        public EqualsSearchDefinition(FieldDefinition<TDocument, TField> path, TField value, SearchScoreDefinition<TDocument> score)
+            : base(OperatorType.Equals, new SingleSearchPathDefinition<TDocument>(path), score)
+        {
+            ValidateType();
+            _value = value;
+            _field = path;
+        }
 
-        public EqualsSearchDefinition(FieldDefinition<TDocument> path, TField value, SearchScoreDefinition<TDocument> score)
-            : base(OperatorType.Equals, path, score)
+        public EqualsSearchDefinition(FieldDefinition<TDocument, IEnumerable<TField>> path, TField value, SearchScoreDefinition<TDocument> score)
+            : base(OperatorType.Equals, new SingleSearchPathDefinition<TDocument>(path), score)
         {
-            _value = ToBsonValue(value);
+            ValidateType();
+            _value = value;
+            _arrayField = path;
         }
 
-        private protected override BsonDocument RenderArguments(RenderArgs<TDocument> args) =>
-            new("value", _value);
+        private protected override BsonDocument RenderArguments(RenderArgs<TDocument> args)
+        {
+            if (_field is null)
+            {
+                var renderedField = _arrayField.Render(args);
+
+                var serializer =
+                    (renderedField.ValueSerializer as FieldValueSerializerHelper.IEnumerableSerializer<TField>)
+                    .ItemSerializer;
+
+                var document = new BsonDocument();
+                using var bsonWriter = new BsonDocumentWriter(document);
+                var context = BsonSerializationContext.CreateRoot(bsonWriter);
+                bsonWriter.WriteStartDocument();
+                bsonWriter.WriteName("value");
+                serializer.Serialize(context, _value);
+                bsonWriter.WriteEndDocument();
+
+                return document;
+            }
+            else
+            {
+                var renderedField = _field.Render(args);
+
+                var document = new BsonDocument();
+                using var bsonWriter = new BsonDocumentWriter(document);
+                var context = BsonSerializationContext.CreateRoot(bsonWriter);
+                bsonWriter.WriteStartDocument();
+                bsonWriter.WriteName("value");
+                renderedField.ValueSerializer.Serialize(context, _value);
+                bsonWriter.WriteEndDocument();
+
+                return document;
+            }
+        }
 
-        private static BsonValue ToBsonValue(TField value) =>
-            value switch
+        private void ValidateType()
+        {
+            if (!_validTypes.Contains(typeof(TField)))
             {
-                bool v => (BsonBoolean)v,
-                sbyte v => (BsonInt32)v,
-                byte v => (BsonInt32)v,
-                short v => (BsonInt32)v,
-                ushort v => (BsonInt32)v,
-                int v => (BsonInt32)v,
-                uint v => (BsonInt64)v,
-                long v => (BsonInt64)v,
-                float v => (BsonDouble)v,
-                double v => (BsonDouble)v,
-                DateTime v => (BsonDateTime)v,
-                DateTimeOffset v => (BsonDateTime)v.UtcDateTime,
-                ObjectId v => (BsonObjectId)v,
-                Guid v => new BsonBinaryData(v, GuidRepresentation.Standard),
-                string v => (BsonString)v,
-                null => BsonNull.Value,
-                _ => throw new InvalidCastException()
-            };
+                throw new InvalidCastException();
+            }
+        }
     }
 
     internal sealed class ExistsSearchDefinition<TDocument> : OperatorSearchDefinition<TDocument>
@@ -243,7 +294,7 @@ public InSearchDefinition(
         private protected override BsonDocument RenderArguments(RenderArgs<TDocument> args) =>
             new("value", _values);
 
-        private static BsonValue ToBsonValue(TField value) =>
+        private static BsonValue ToBsonValue(TField value) =>  //TODO probably we need to change also this
             value switch
             {
                 bool v => (BsonBoolean)v,
@@ -382,7 +433,7 @@ private protected override BsonDocument RenderArguments(RenderArgs<TDocument> ar
                 { _range.IsMaxInclusive ? "lte" : "lt", _max, _max != null },
             };
 
-        private static BsonValue ToBsonValue(TField? value) =>
+        private static BsonValue ToBsonValue(TField? value) =>  //TODO Probably we need to change this too
             value switch
             {
                 sbyte v => (BsonInt32)v,

src/MongoDB.Driver/Search/SearchDefinition.cs

@@ -123,9 +123,9 @@ private protected enum OperatorType
             QueryString,
             Range,
             Regex,
-            Search,
+            Search,  //TODO This is never used
             Span,
-            Term,
+            Term, //TODO This is never used
             Text,
             Wildcard
         }

tests/MongoDB.Driver.Tests/Jira/CSharp5442Tests.cs

@@ -0,0 +1,93 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Serializers;
+using Moq;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Jira
+{
+    public class CSharp5442Tests
+    {
+        [Fact]
+        public void Search_Operators_use_correct_serializers_when_using_attributes_and_expression_path()
+        {
+            var testGuid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
+            var collection = new Mock<IMongoCollection<TestClass>>().Object;
+            var searchDefinition = Builders<TestClass>
+                .Search
+                .Compound()
+                .Must(Builders<TestClass>.Search.Equals(t => t.DefaultGuid, testGuid))
+                .Must(Builders<TestClass>.Search.Equals(t => t.StringGuid, testGuid));
+
+            var result = collection.Aggregate().Search(searchDefinition).ToString();
+
+            const string expected = """aggregate([{ "$search" : { "compound" : { "must" : [{ "equals" : { "value" : { "$binary" : { "base64" : "AQIDBAUGBwgJCgsMDQ4PEA==", "subType" : "04" } }, "path" : "DefaultGuid" } }, { "equals" : { "value" : "01020304-0506-0708-090a-0b0c0d0e0f10", "path" : "StringGuid" } }] } } }])""";
+
+            result.Should().Be(expected);
+        }
+
+        [Fact]
+        public void Search_Operators_use_correct_serializers_when_using_attributes_and_string_path()
+        {
+            var testGuid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
+            var collection = new Mock<IMongoCollection<TestClass>>().Object;
+            var searchDefinition = Builders<TestClass>
+                .Search
+                .Compound()
+                .Must(Builders<TestClass>.Search.Equals("DefaultGuid", testGuid))
+                .Must(Builders<TestClass>.Search.Equals("StringGuid", testGuid));
+
+            var result = collection.Aggregate().Search(searchDefinition).ToString();
+
+            const string expected = """aggregate([{ "$search" : { "compound" : { "must" : [{ "equals" : { "value" : { "$binary" : { "base64" : "AQIDBAUGBwgJCgsMDQ4PEA==", "subType" : "04" } }, "path" : "DefaultGuid" } }, { "equals" : { "value" : "01020304-0506-0708-090a-0b0c0d0e0f10", "path" : "StringGuid" } }] } } }])""";
+
+            result.Should().Be(expected);
+        }
+
+        [Fact(Skip = "This should only be run manually due to the use of BsonSerializer.RegisterSerializer")]  //TODO Put back skip afterwards
+        public void Search_Operators_use_correct_serializers_when_using_serializer_registry()
+        {
+            BsonSerializer.RegisterSerializer(new GuidSerializer(BsonType.String));
+            var testGuid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
+            var collection = new Mock<IMongoCollection<TestClass>>().Object;
+            var searchDefinition = Builders<TestClass>
+                .Search
+                .Equals(t => t.UndefinedRepresentationGuid, testGuid);
+
+            var result = collection.Aggregate().Search(searchDefinition).ToString();
+
+            const string expected = """aggregate([{ "$search" : { "equals" : { "value" : "01020304-0506-0708-090a-0b0c0d0e0f10", "path" : "UndefinedRepresentationGuid" } } }])""";
+
+            result.Should().Be(expected);
+        }
+
+        public class TestClass
+        {
+            [BsonGuidRepresentation(GuidRepresentation.Standard)]
+            public Guid DefaultGuid { get; set; }
+
+            [BsonRepresentation(BsonType.String)]
+            public Guid StringGuid { get; set; }
+
+            public Guid UndefinedRepresentationGuid { get; set; }
+        }
+    }
+}

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

@@ -276,7 +276,7 @@ public void Equals_with_array_should_render_supported_type()
         }
 
         [Theory]
-        [MemberData(nameof(EqualsSupportedTypesTestData))]
+        [MemberData(nameof(EqualsSupportedTypesTestData))]  //TODO Need to fix this
         public void Equals_should_render_supported_type<T>(
             T value,
             string valueRendered,
@@ -290,6 +290,8 @@ public void Equals_should_render_supported_type<T>(
                 subject.Equals("x", value),
                 $"{{ equals: {{ path: 'x', value: {valueRendered} }} }}");
 
+            //For the Guid we get (correctly): GuidSerializer cannot serialize a Guid when GuidRepresentation is Unspecified.
+
             var scoreBuilder = new SearchScoreDefinitionBuilder<BsonDocument>();
             AssertRendered(
                 subject.Equals("x", value, scoreBuilder.Constant(1)),
@@ -313,7 +315,7 @@ public void Equals_should_render_supported_type<T>(
             new object[] { (float)1, "1", Exp(p => p.Float), nameof(Person.Float) },
             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[] { DateTimeOffset.MaxValue, """{ "DateTime" : { "$date" : "9999-12-31T23:59:59.999Z" }, "Ticks" : 3155378975999999999, "Offset" : 0 }""", Exp(p => p.DateTimeOffset), nameof(Person.DateTimeOffset) },
             new object[] { ObjectId.Empty, "{ $oid: '000000000000000000000000' }", Exp(p => p.Id), "_id" },
             new object[] { Guid.Empty, """{ "$binary" : { "base64" : "AAAAAAAAAAAAAAAAAAAAAA==", "subType" : "04" } }""", Exp(p => p.Guid), nameof(Person.Guid) },
             new object[] { null, "null", Exp(p => p.Name), nameof(Person.Name) },