Fix for Error occurs when you check whether a string or integer literal is in an enum collection

src/Microsoft.OData.Core/UriParser/Binders/InBinder.cs

@@ -58,6 +58,13 @@ internal QueryNode BindInOperator(InToken inToken, BindingState state)
                     inToken.Right, new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetUntyped())), state.Model);
             }
 
+            // If the left operand is either an integral or a string type and the right operand is a collection of enums,
+            // Calls the MetadataBindingUtils.ConvertToTypeIfNeeded() method to convert the left operand to the same enum type as the right operand.
+            if ((right is CollectionPropertyAccessNode && right.ItemType.IsEnum()) && (left.TypeReference.IsString() || left.TypeReference.IsIntegral()))
+            {
+                left = MetadataBindingUtils.ConvertToTypeIfNeeded(left, right.ItemType);
+            }
+
             return new InNode(left, right);
         }
 

test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/UriParser/EnumFilterFunctionalTests.cs

@@ -10,6 +10,7 @@
 using Microsoft.OData.UriParser;
 using Microsoft.OData.Edm;
 using Xunit;
+using System.Linq;
 
 namespace Microsoft.OData.Tests.ScenarioTests.UriParser
 {
@@ -70,6 +71,10 @@ public EnumFilterFunctionalTests()
             var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, true);
             this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
 
+            // add colors collection
+            EdmCollectionTypeReference colorCollectionTypeRef = new EdmCollectionTypeReference(new EdmCollectionType(new EdmEnumTypeReference(enumType, true)));
+            this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Colors", colorCollectionTypeRef));
+
             this.userModel.AddElement(this.entityType);
 
             var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
@@ -515,13 +520,205 @@ public void ParseFilterEnumTypesWrongCast3()
             parse.Throws<ODataException>(Strings.MetadataBinder_CastOrIsOfFunctionWithoutATypeArgument);
         }
 
+        [Fact]
+        public void ParseFilterWithInOperatorWithEnumsFullyQualifiedMemberName()
+        {
+            // Arrange
+            string enumValue = "White";
+            string filterQuery = $"NS.Color'{enumValue}' in Colors"; // "NS.Color'White' in Colors"
+            string expectedLiteral = "NS.Color'White'";
+
+            IEdmEnumType colorType = this.GetColorType(this.userModel);
+            IEdmEnumMember enumMember = colorType.Members.Single(m => m.Name == enumValue);
+
+            // Act
+            FilterClause filterQueryNode = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+            SingleValueNode expression = filterQueryNode.Expression;
+
+            // Assert
+            Assert.Equal("NS.Color'White' in Colors", filterQuery);
+            InNode inNode = expression.ShouldBeInNode();
+            ConstantNode leftNode = Assert.IsType<ConstantNode>(inNode.Left);
+            leftNode.ShouldBeEnumNode(colorType, enumMember.Value.Value);
+
+            Assert.True(leftNode.TypeReference.IsEnum());
+            Assert.Equal(enumMember.Value.Value.ToString(), leftNode.Value.ToString());
+            Assert.Equal(expectedLiteral, leftNode.LiteralText);
+
+            CollectionPropertyAccessNode rightNode = Assert.IsType<CollectionPropertyAccessNode>(inNode.Right);
+            rightNode.ShouldBeCollectionPropertyAccessQueryNode(this.GetColorsProperty(this.userModel));
+            Assert.Equal(colorType, rightNode.ItemType.Definition);
+        }
+
+        [Fact]
+        public void ParseFilterWithInOperatorWithEnumsMemberNameWithoutFullyQualifiedName()
+        {
+            // Arrange
+            string enumValue = "Green";
+            string filterQuery = $"'{enumValue}' in Colors"; // "'Green' in Colors"
+            string expectedLiteral = "'Green'";
+
+            IEdmEnumType colorType = this.GetColorType(this.userModel);
+
+            // Act
+            FilterClause filterQueryNode = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+            SingleValueNode expression = filterQueryNode.Expression;
+
+            // Assert
+            Assert.Equal("'Green' in Colors", filterQuery);
+            InNode inNode = expression.ShouldBeInNode();
+            ConstantNode leftNode = Assert.IsType<ConstantNode>(inNode.Left);
+            leftNode.ShouldBeEnumNode(colorType, enumValue);
+
+            Assert.True(leftNode.TypeReference.IsEnum());
+            Assert.Equal(enumValue, leftNode.Value.ToString());
+            Assert.Equal(expectedLiteral, leftNode.LiteralText);
+
+            CollectionPropertyAccessNode rightNode = Assert.IsType<CollectionPropertyAccessNode>(inNode.Right);
+            rightNode.ShouldBeCollectionPropertyAccessQueryNode(this.GetColorsProperty(this.userModel));
+            Assert.Equal(colorType, rightNode.ItemType.Definition);
+        }
+
+        [Fact]
+        public void ParseFilterWithInOperatorWithEnumsMemberIntegralValueWithSingleQuotes()
+        {
+            // Arrange
+            int enumValue = 1;
+            string filterQuery = $"'{enumValue}' in Colors"; // "'1' in Colors"
+            string expectedLiteral = "'Red'";
+
+            IEdmEnumType colorType = this.GetColorType(this.userModel);
+            bool success = colorType.TryParse(enumValue, out IEdmEnumMember enumMember);
+
+            // Act
+            FilterClause filterQueryNode = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+            SingleValueNode expression = filterQueryNode.Expression;
+
+            // Assert
+            Assert.Equal("'1' in Colors", filterQuery);
+            Assert.True(success);
+            InNode inNode = expression.ShouldBeInNode();
+            ConstantNode leftNode = Assert.IsType<ConstantNode>(inNode.Left);
+            leftNode.ShouldBeEnumNode(colorType, enumMember.Name);
+
+            Assert.True(leftNode.TypeReference.IsEnum());
+            Assert.Equal(enumMember.Name, leftNode.Value.ToString());
+            Assert.Equal(expectedLiteral, leftNode.LiteralText);
+
+            CollectionPropertyAccessNode rightNode = Assert.IsType<CollectionPropertyAccessNode>(inNode.Right);
+            rightNode.ShouldBeCollectionPropertyAccessQueryNode(this.GetColorsProperty(this.userModel));
+            Assert.Equal(colorType, rightNode.ItemType.Definition);
+        }
+
+        [Fact]
+        public void ParseFilterWithInOperatorWithEnumsMemberIntegralValueWithoutSingleQuotes()
+        {
+            // Arrange
+            int enumValue = 3;
+            string filterQuery = $"{enumValue} in Colors"; // "3 in Colors"
+            string expectedLiteral = "'Blue'";
+
+            IEdmEnumType colorType = this.GetColorType(this.userModel);
+            bool success = colorType.TryParse(enumValue, out IEdmEnumMember enumMember);
+
+            // Act
+            FilterClause filterQueryNode = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+            SingleValueNode expression = filterQueryNode.Expression;
+
+            // Assert
+            Assert.Equal("3 in Colors", filterQuery);
+            Assert.True(success);
+            InNode inNode = expression.ShouldBeInNode();
+            ConstantNode leftNode = Assert.IsType<ConstantNode>(inNode.Left);
+            leftNode.ShouldBeEnumNode(colorType, enumMember.Name);
+
+            Assert.True(leftNode.TypeReference.IsEnum());
+            Assert.Equal(enumMember.Name, leftNode.Value.ToString());
+            Assert.Equal(expectedLiteral, leftNode.LiteralText);
+
+            CollectionPropertyAccessNode rightNode = Assert.IsType<CollectionPropertyAccessNode>(inNode.Right);
+            rightNode.ShouldBeCollectionPropertyAccessQueryNode(this.GetColorsProperty(this.userModel));
+            Assert.Equal(colorType, rightNode.ItemType.Definition);
+        }
+
+        [Fact]
+        public void ParseFilterWithInOperatorWithEnumsMemberDoubleIntegralValue()
+        {
+            // Arrange
+            long enumValue = 3;
+            string filterQuery = $"{enumValue} in Colors"; // "3 in Colors"
+            string expectedLiteral = "'Blue'";
+
+            IEdmEnumType colorType = this.GetColorType(this.userModel);
+            bool success = colorType.TryParse(enumValue, out IEdmEnumMember enumMember);
+
+            // Act
+            FilterClause filterQueryNode = ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+            SingleValueNode expression = filterQueryNode.Expression;
+
+            // Assert
+            Assert.Equal("3 in Colors", filterQuery);
+            Assert.True(success);
+            InNode inNode = expression.ShouldBeInNode();
+            ConstantNode leftNode = Assert.IsType<ConstantNode>(inNode.Left);
+            leftNode.ShouldBeEnumNode(colorType, enumMember.Name);
+
+            Assert.True(leftNode.TypeReference.IsEnum());
+            Assert.Equal(enumMember.Name, leftNode.Value.ToString());
+            Assert.Equal(expectedLiteral, leftNode.LiteralText);
+
+            CollectionPropertyAccessNode rightNode = Assert.IsType<CollectionPropertyAccessNode>(inNode.Right);
+            rightNode.ShouldBeCollectionPropertyAccessQueryNode(this.GetColorsProperty(this.userModel));
+            Assert.Equal(colorType, rightNode.ItemType.Definition);
+        }
+
+        [Theory]
+        [InlineData("3.0")]
+        [InlineData("3.1")]
+        [InlineData("4.0")]
+        [InlineData("5.0")]
+        public void ParseFilterWithInOperatorWithEnumsMemberFloatIntegralValue(string floatString)
+        {
+            // Arrange
+            string filterQuery = $"{floatString} in Colors";
+
+            // Act
+            Action test = () => ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+
+            // Assert
+            test.Throws<ArgumentException>(Strings.Nodes_InNode_CollectionItemTypeMustBeSameAsSingleItemType("NS.Color", "Edm.Single")); // Float are of Type Edm.Single
+        }
+
+        [Theory]
+        [InlineData(-20)]
+        [InlineData("-20")]
+        [InlineData("'-20'")]
+        public void ParseFilterWithInOperatorWithEnumsMemberInvalidIntegralValue(object integralValue)
+        {
+            // Arrange
+            string filterQuery = $"{integralValue} in Colors";
+
+            // Act
+            Action action = () => ParseFilter(filterQuery, this.userModel, this.entityType, this.entitySet);
+
+            // Assert
+            action.Throws<ODataException>(Strings.Binder_IsNotValidEnumConstant("-20"));
+        }
+
         private IEdmStructuralProperty GetColorProp(IEdmModel model)
         {
             return (IEdmStructuralProperty)((IEdmStructuredType)model
                 .FindType("NS.MyEntityType"))
                 .FindProperty("Color");
         }
 
+        private IEdmStructuralProperty GetColorsProperty(IEdmModel model)
+        {
+            return (IEdmStructuralProperty)((IEdmStructuredType)model
+                .FindType("NS.MyEntityType"))
+                .FindProperty("Colors");
+        }
+
         private IEdmEnumType GetColorType(IEdmModel model)
         {
             return (IEdmEnumType)model.FindType("NS.Color");

test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/UriParser/FilterAndOrderByFunctionalTests.cs

@@ -2041,6 +2041,91 @@ public void FilterWithInOperationWithEnums()
             Assert.Equal("FavoriteColors", Assert.IsType<CollectionPropertyAccessNode>(inNode.Right).Property.Name);
         }
 
+        [Fact]
+        public void FilterWithInOperationWithEnumsMemberName_WithoutQualifiedNamespace()
+        {
+            // Arrange
+            string filterQuery = "'SolidYellow' in FavoriteColors";
+
+            string expectedLiteralText = "'SolidYellow'";
+            string expectedfullyQualifiedName = "Fully.Qualified.Namespace.ColorPattern'SolidYellow'";
+            string expectedCollectionPropertyName = "FavoriteColors";
+
+            // Act
+            FilterClause filter = ParseFilter(filterQuery, HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
+
+            // Assert
+            InNode inNode = Assert.IsType<InNode>(filter.Expression);
+            ConstantNode left = Assert.IsType<ConstantNode>(inNode.Left);
+            ODataEnumValue enumValue = Assert.IsType<ODataEnumValue>(left.Value);
+
+            Assert.Equal(expectedLiteralText, left.LiteralText);
+            Assert.Equal(expectedfullyQualifiedName, (enumValue.TypeName + left.LiteralText));
+            Assert.Equal(expectedCollectionPropertyName, Assert.IsType<CollectionPropertyAccessNode>(inNode.Right).Property.Name);
+        }
+
+        [Fact]
+        public void FilterWithInOperationWithEnumsMemberIntegralValue_WithSingleQuotes()
+        {
+            // Arrange
+            string filterQuery = "'12' in FavoriteColors";
+
+            string expectedLiteralText = "'SolidYellow'";
+            string expectedfullyQualifiedName = "Fully.Qualified.Namespace.ColorPattern'SolidYellow'";
+            string expectedCollectionPropertyName = "FavoriteColors";
+
+            // Act
+            FilterClause filter = ParseFilter(filterQuery, HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
+
+            // Assert
+            InNode inNode = Assert.IsType<InNode>(filter.Expression);
+            ConstantNode left = Assert.IsType<ConstantNode>(inNode.Left);
+            ODataEnumValue enumValue = Assert.IsType<ODataEnumValue>(left.Value);
+
+            Assert.Equal(expectedLiteralText, left.LiteralText);
+            Assert.Equal(expectedfullyQualifiedName, (enumValue.TypeName + left.LiteralText));
+            Assert.Equal(expectedCollectionPropertyName, Assert.IsType<CollectionPropertyAccessNode>(inNode.Right).Property.Name);
+        }
+
+        [Fact]
+        public void FilterWithInOperationWithEnumsMemberIntegralValue_WithoutSingleQuotes()
+        {
+            // Arrange
+            string filterQuery = "12 in FavoriteColors";
+
+            string expectedLiteralText = "'SolidYellow'";
+            string expectedfullyQualifiedName = "Fully.Qualified.Namespace.ColorPattern'SolidYellow'";
+            string expectedCollectionPropertyName = "FavoriteColors";
+
+            // Act
+            FilterClause filter = ParseFilter(filterQuery, HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
+
+            // Assert
+            InNode inNode = Assert.IsType<InNode>(filter.Expression);
+            ConstantNode left = Assert.IsType<ConstantNode>(inNode.Left);
+            ODataEnumValue enumValue = Assert.IsType<ODataEnumValue>(left.Value);
+
+            Assert.Equal(expectedLiteralText, left.LiteralText);
+            Assert.Equal(expectedfullyQualifiedName, (enumValue.TypeName + left.LiteralText));
+            Assert.Equal(expectedCollectionPropertyName, Assert.IsType<CollectionPropertyAccessNode>(inNode.Right).Property.Name);
+        }
+
+        [Theory]
+        [InlineData(53)]
+        [InlineData("53")]
+        [InlineData("'53'")]
+        public void FilterWithInOperationWithEnumsInValidMemberIntegralValue_ThrowsIsNotValidEnumConstantException(object integralValue)
+        {
+            // Arrange
+            string filterQuery = $"{integralValue} in FavoriteColors";
+
+            // Act
+            Action action = () => ParseFilter(filterQuery, HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
+
+            // Assert
+            action.Throws<ODataException>(ODataErrorStrings.Binder_IsNotValidEnumConstant("53"));
+        }
+
         [Fact]
         public void FilterWithInOperationWithAny()
         {