CSHARP-1884: Make In filter method changes backward compatible.

Author: rstam

src/MongoDB.Driver/FieldValueSerializerHelper.cs

@@ -59,7 +59,7 @@ public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSer
             }
 
             // synthesize an EnumConvertingSerializer using the field serializer
-            if (fieldTypeInfo.IsEnum)
+            if (fieldTypeInfo.IsEnum && valueType.IsConvertibleToEnum())
             {
                 var enumConvertingSerializerType = typeof(EnumConvertingSerializer<,>).MakeGenericType(valueType, fieldType);
                 var enumConvertingSerializerConstructor = enumConvertingSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType });
@@ -95,17 +95,15 @@ public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSer
                 return (IBsonSerializer)ienumerableSerializerConstructor.Invoke(new object[] { itemSerializer });
             }
 
-            // use the item serializer if fieldSerializer is an IBsonArraySerializer of valueType items
+            // if the fieldSerializer is an array serializer try to adapt its itemSerializer for valueType
             IBsonArraySerializer arraySerializer;
             if ((arraySerializer = fieldSerializer as IBsonArraySerializer) != null)
             {
                 BsonSerializationInfo itemSerializationInfo;
                 if (arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
                 {
-                    if (itemSerializationInfo.Serializer.ValueType == valueType)
-                    {
-                        return itemSerializationInfo.Serializer;
-                    }
+                    var itemSerializer = itemSerializationInfo.Serializer;
+                    return GetSerializerForValueType(itemSerializer, valueType);
                 }
             }
 

src/MongoDB.Driver/FilterDefinitionBuilder.cs

@@ -1585,8 +1585,8 @@ public override BsonDocument Render(IBsonSerializer<TDocument> documentSerialize
         {
             var renderedField = _field.Render(documentSerializer, serializerRegistry);
 
-            IBsonSerializer itemSerializer;
-            if (renderedField.FieldSerializer != null)
+            IBsonSerializer itemSerializer = null;
+            if (itemSerializer == null && renderedField.FieldSerializer != null)
             {
                 var arraySerializer = renderedField.FieldSerializer as IBsonArraySerializer;
                 BsonSerializationInfo itemSerializationInfo;
@@ -1595,9 +1595,9 @@ public override BsonDocument Render(IBsonSerializer<TDocument> documentSerialize
                     var message = string.Format("The serializer for field '{0}' must implement IBsonArraySerializer and provide item serialization info.", renderedField.FieldName);
                     throw new InvalidOperationException(message);
                 }
-                itemSerializer = itemSerializationInfo.Serializer;
+                itemSerializer = FieldValueSerializerHelper.GetSerializerForValueType(itemSerializationInfo.Serializer, typeof(TItem));
             }
-            else
+            if (itemSerializer == null)
             {
                 itemSerializer = serializerRegistry.GetSerializer<TItem>();
             }

src/MongoDB.Driver/Support/ReflectionExtensions.cs

@@ -1,4 +1,4 @@
-/* Copyright 2015-2016 MongoDB Inc.
+/* Copyright 2015-2017 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -74,6 +74,20 @@ public static bool IsNumeric(this Type type)
                 type == typeof(Decimal128);
         }
 
+        public static bool IsConvertibleToEnum(this Type type)
+        {
+            return
+                type == typeof(sbyte) ||
+                type == typeof(short) ||
+                type == typeof(int) ||
+                type == typeof(long) ||
+                type == typeof(byte) ||
+                type == typeof(ushort) ||
+                type == typeof(uint) ||
+                type == typeof(ulong) ||
+                type == typeof(Enum);
+        }
+
         public static Type GetNullableUnderlyingType(this Type type)
         {
             if (!IsNullable(type))

tests/MongoDB.Driver.Tests/FilterDefinitionBuilderTests.cs

@@ -491,6 +491,33 @@ public void In_Typed()
             Assert(subject.AnyIn("FavoriteColors", new[] { "blue", "green" }), "{colors: {$in: ['blue','green']}}");
         }
 
+        [Fact]
+        public void In_with_enum()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.In("E", new[] { EnumForClassWithEnums.A, EnumForClassWithEnums.B }), "{ E : { $in : [ 0, 1 ] } }");
+            Assert(subject.AnyIn("A", new[] { EnumForClassWithEnums.A, EnumForClassWithEnums.B }), "{ A : { $in : [ 0, 1 ] } }");
+        }
+
+        [Fact]
+        public void In_typed_with_enum()
+        {
+            var subject = CreateSubject<ClassWithEnums>();
+
+            Assert(subject.In("E", new[] { 0, 1 }), "{ E : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.In("A", new[] { 0, 1 }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.AnyIn("A", new[] { 0, 1 }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+
+            Assert(subject.In("E", new[] { "A", "B" }), "{ E : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.In("A", new[] { "A", "B" }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.AnyIn("A", new[] { "A", "B" }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+
+            Assert(subject.In("E", new[] { EnumForClassWithEnums.A, EnumForClassWithEnums.B }), "{ E : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.In("A", new[] { EnumForClassWithEnums.A, EnumForClassWithEnums.B }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+            Assert(subject.AnyIn("A", new[] { EnumForClassWithEnums.A, EnumForClassWithEnums.B }), "{ A : { $in : [ \"A\", \"B\" ] } }");
+        }
+
         [Fact]
         public void Lt()
         {
@@ -985,6 +1012,17 @@ private FilterDefinitionBuilder<TDocument> CreateSubject<TDocument>()
             return new FilterDefinitionBuilder<TDocument>();
         }
 
+        private enum EnumForClassWithEnums { A, B }
+
+        private class ClassWithEnums
+        {
+            public int Id { get; set; }
+            [BsonRepresentation(BsonType.String)]
+            public EnumForClassWithEnums E { get; set; }
+            [BsonRepresentation(BsonType.String)]
+            public EnumForClassWithEnums[] A { get; set; }
+        }
+
         private class Person
         {
             [BsonElement("fn")]