Fixed tests for Contains operator on different collection types

Author: Viktor Tochonov

src/FSharp.Data.GraphQL.Server.Middleware/ObjectListFilter.fs

@@ -129,17 +129,15 @@ module ObjectListFilter =
     let private StringEndsWithMethod = typeof<string>.GetMethod ("EndsWith", [| typeof<string> |])
     let private StringContainsMethod = typeof<string>.GetMethod ("Contains", [| typeof<string> |])
     let private getEnumerableContainsMethod (memberType : Type) =
-        match memberType.GetMethods(BindingFlags.Instance &&& BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 2) with
-        | null ->
-            match typeof<Enumerable>.GetMethods(BindingFlags.Static ||| BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 2) with
-            | null -> raise (MissingMemberException "Static 'Contains' method with 2 parameters not found on 'Enumerable' class")
-            | containsGenericStaticMethod ->
-                if memberType.IsGenericType && memberType.GenericTypeArguments.Length = 1 then
-                    containsGenericStaticMethod.MakeGenericMethod(memberType.GenericTypeArguments)
-                else
-                    let ienumerable = memberType.GetType().GetInterfaces().First(fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
-                    containsGenericStaticMethod.MakeGenericMethod([| ienumerable.GenericTypeArguments[0] |])
-        | instanceContainsMethod -> instanceContainsMethod
+        match typeof<Enumerable>.GetMethods(BindingFlags.Static ||| BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 2) with
+        | null -> raise (MissingMemberException "Static 'Contains' method with 2 parameters not found on 'Enumerable' class")
+        | containsGenericStaticMethod ->
+            if memberType.IsGenericType && memberType.GenericTypeArguments.Length = 1 then
+                containsGenericStaticMethod.MakeGenericMethod(memberType.GenericTypeArguments)
+            else
+                let ienumerable = memberType.GetInterfaces().First(fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
+                containsGenericStaticMethod.MakeGenericMethod([| ienumerable.GenericTypeArguments[0] |])
+        
 
     let getField (param : ParameterExpression) fieldName = Expression.PropertyOrField (param, fieldName)
 
@@ -174,7 +172,9 @@ module ObjectListFilter =
                 && memberType.GetInterfaces().Any(fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
             match ``member``.Member  with
             | :? PropertyInfo as prop when prop.PropertyType |> isEnumerable ->
-                Expression.Call (getEnumerableContainsMethod prop.PropertyType, Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
+                match prop.PropertyType.GetMethods(BindingFlags.Instance ||| BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 1) with
+                | null -> Expression.Call (getEnumerableContainsMethod prop.PropertyType, Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
+                | instanceContainsMethod -> Expression.Call (Expression.PropertyOrField (param, f.FieldName),instanceContainsMethod, Expression.Constant (f.Value))    
             | :? FieldInfo as field when field.FieldType |> isEnumerable ->
                 Expression.Call (getEnumerableContainsMethod field.FieldType, Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
             | _ ->

tests/FSharp.Data.GraphQL.Tests/ObjectListFilterLinqTests.fs

@@ -324,22 +324,20 @@ let ``ObjectListFilter works with getDiscriminatorValue startsWith for Horse and
         c.ID |> equals 5
         c.Name |> equals "Hamster E"
 
-type Product = {
+type ListTagsProduct = {
     Name : string
     Tags : string list
 }
 
-let productList =
-    [
-        { Name = "Product A"; Tags = ["Tag1"; "Tag2"] }
-        { Name = "Product B"; Tags = ["Tag2"; "Tag3"] }
-        { Name = "Product C"; Tags = ["Tag3"; "Tag4"] }
-        { Name = "Product D"; Tags = ["Tag4"; "Tag5"] }
-    ]
-let productArray = productList.ToArray()
-
 [<Fact>]
-let ``ObjectListFilter works with Contains operator collection type properties``() =
+let ``ObjectListFilter works with Contains operator on list collection properties``() =
+    let productList =
+        [
+            { Name = "Product A"; Tags = ["Tag1"; "Tag2"] }
+            { Name = "Product B"; Tags = ["Tag2"; "Tag3"] }
+            { Name = "Product C"; Tags = ["Tag3"; "Tag4"] }
+            { Name = "Product D"; Tags = ["Tag4"; "Tag5"] }
+        ]
     let queryable = productList.AsQueryable()
     let filter = Contains { FieldName = "Tags"; Value = "Tag3" }
     let filteredData = queryable.Apply(filter) |> Seq.toList
@@ -349,9 +347,45 @@ let ``ObjectListFilter works with Contains operator collection type properties``
     let result2 = List.last filteredData
     result2.Name |> equals "Product C"
 
+type ArrayTagsProduct = {
+        Name : string
+        Tags : string array
+}
+
+[<Fact>]
+let ``ObjectListFilter works with Contains operator on array collection properties``() =
+
+    let productArray =
+        [
+           { Name = "Product A"; Tags = [|"Tag1"; "Tag2"|] }
+           { Name = "Product B"; Tags = [|"Tag2"; "Tag3"|] }
+           { Name = "Product C"; Tags = [|"Tag3"; "Tag4"|] }
+           { Name = "Product D"; Tags = [|"Tag4"; "Tag5"|] }
+    ]
+    let queryable = productArray.AsQueryable()
+    let filter = Contains { FieldName = "Tags"; Value = "Tag3" }
+    let filteredData = queryable.Apply(filter) |> Seq.toList
+    List.length filteredData |> equals 2
+    let result1 = List.head filteredData
+    result1.Name |> equals "Product B"
+    let result2 = List.last filteredData
+    result2.Name |> equals "Product C"
+
+type SetTagsProduct = {
+        Name : string
+        Tags : string Set
+}
 
 [<Fact>]
-let ``ObjectListFilter works with Contains operator collection type properties with array``() =
+let ``ObjectListFilter works with Contains operator on set collection properties``() =
+
+    let productArray =
+        [
+           { Name = "Product A"; Tags = [|"Tag1"; "Tag2"|] |> Set.ofArray}
+           { Name = "Product B"; Tags = [|"Tag2"; "Tag3"|] |> Set.ofArray}
+           { Name = "Product C"; Tags = [|"Tag3"; "Tag4"|] |> Set.ofArray}
+           { Name = "Product D"; Tags = [|"Tag4"; "Tag5"|] |> Set.ofArray}
+    ]
     let queryable = productArray.AsQueryable()
     let filter = Contains { FieldName = "Tags"; Value = "Tag3" }
     let filteredData = queryable.Apply(filter) |> Seq.toList