CSHARP-4809: If a string serializer doesn't implement IHasRepresentationSerializer don't assume string values are actually represented as strings.

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/StringExpressionToRegexFilterTranslator.cs

@@ -519,8 +519,11 @@ private static (AstFilterField, Modifiers) TranslateField(TranslationContext con
             {
                 var field = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);
 
-                if (field.Serializer is IRepresentationConfigurable representationConfigurable &&
-                    representationConfigurable.Representation != BsonType.String)
+                if (field.Serializer is not IHasRepresentationSerializer hasRepresentationSerializer)
+                {
+                    throw new ExpressionNotSupportedException(fieldExpression, expression, because: $"it was not possible to determine whether field \"{field.Path}\" is represented as a string");
+                }
+                if (hasRepresentationSerializer.Representation != BsonType.String)
                 {
                     throw new ExpressionNotSupportedException(fieldExpression, expression, because: $"field \"{field.Path}\" is not represented as a string");
                 }

tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp4809Tests.cs

@@ -0,0 +1,99 @@
+/* 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 MongoDB.Driver.Linq;
+using MongoDB.TestHelpers.XunitExtensions;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3Implementation.Jira
+{
+    public class CSharp4809Tests : Linq3IntegrationTest
+    {
+        [Theory]
+        [ParameterAttributeData]
+        public void Filter_by_Id_with_custom_serializer_should_work(
+            [Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
+        {
+            var collection = GetCollection(linqProvider);
+            var id = "111111111111111111111111";
+
+            var filter = Builders<RootDocument>.Filter.Where(x => x.Id == id);
+
+            var renderedFilter = filter.Render(collection.DocumentSerializer, BsonSerializer.SerializerRegistry, linqProvider);
+            renderedFilter.Should().Be("{ _id : ObjectId('111111111111111111111111' ) }");
+
+            var result = collection.FindSync(filter).Single();
+            result.X.Should().Be(1);
+        }
+
+        private IMongoCollection<RootDocument> GetCollection(LinqProvider linqProvider)
+        {
+            var collection = GetCollection<RootDocument>("test", linqProvider);
+            CreateCollection(
+                collection,
+                new RootDocument { Id = "111111111111111111111111", X = 1 },
+                new RootDocument { Id = "222222222222222222222222", X = 2 });
+            return collection;
+        }
+
+        private class RootDocument
+        {
+            [BsonSerializer(typeof(CustomStringRepresentedAsObjectIdSerializer))]
+            public string Id { get; set; }
+            public int X { get; set; }
+        }
+
+        // This custom serializer is a slightly modified version of the custom serializer in the JIRA ticket
+        // note: normally this serializer would implement IHasRepresentationSerializer
+        // but for testing purposes we deliberately chose not to implement it
+        public class CustomStringRepresentedAsObjectIdSerializer : SerializerBase<string>
+        {
+            public override string Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+            {
+                BsonType type = context.Reader.GetCurrentBsonType();
+                switch (type)
+                {
+                    case BsonType.ObjectId: return context.Reader.ReadObjectId().ToString();
+                    default:
+                        var message = $"Cannot convert a {type} to a String.";
+                        throw new NotSupportedException(message);
+                }
+            }
+
+            public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, string value)
+            {
+                context.Writer.WriteObjectId(ToObjectId(value));
+            }
+
+            private static ObjectId ToObjectId(string source)
+            {
+                if (ObjectId.TryParse(source, out ObjectId returnId))
+                {
+                    return returnId;
+                }
+                else
+                {
+                    return ObjectId.Empty;
+                }
+            }
+        }
+    }
+}