Updated tests to find a solution for generics

oliemansm · oliemansm · commit 0d857e31ccff · 2018-09-28T19:33:24.000+02:00
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/FieldResolverScanner.kt b/src/main/kotlin/com/coxautodev/graphql/tools/FieldResolverScanner.kt
@@ -9,7 +9,6 @@ import org.apache.commons.lang3.reflect.FieldUtils
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Modifier
 import java.lang.reflect.ParameterizedType
-import java.lang.reflect.TypeVariable
 
 /**
  * @author Andrew Potter
@@ -22,7 +21,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
         private val log = LoggerFactory.getLogger(FieldResolverScanner::class.java)
 
         fun getAllMethods(type: Class<*>) =
-                (type.methods.toList() + ClassUtils.getAllSuperclasses(type).flatMap { it.methods.toList() })
+                (type.declaredMethods.toList() + ClassUtils.getAllSuperclasses(type).flatMap { it.methods.toList() })
                         .asSequence()
                         .filter { !it.isSynthetic }
                         .filter { !Modifier.isPrivate(it.modifiers) }
@@ -74,7 +73,6 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
     private fun isBoolean(type: GraphQLLangType) = type.unwrap().let { it is TypeName && it.name == Scalars.GraphQLBoolean.name }
 
     private fun findResolverMethod(field: FieldDefinition, search: Search): java.lang.reflect.Method? {
-
         val methods = getAllMethods(search.type)
         val argumentCount = field.inputValueDefinitions.size + if (search.requiredFirstParameterType != null) 1 else 0
         val name = field.name
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/GenericType.kt b/src/main/kotlin/com/coxautodev/graphql/tools/GenericType.kt
@@ -9,10 +9,10 @@ import java.lang.reflect.TypeVariable
 /**
  * @author Andrew Potter
  */
-open internal class GenericType(protected val mostSpecificType: JavaType, protected val options: SchemaParserOptions) {
+internal open class GenericType(protected val mostSpecificType: JavaType, protected val options: SchemaParserOptions) {
 
     fun isTypeAssignableFromRawClass(type: ParameterizedType, clazz: Class<*>) =
-        clazz.isAssignableFrom(getRawClass(type.rawType))
+            clazz.isAssignableFrom(getRawClass(type.rawType))
 
     fun getRawClass() = getRawClass(mostSpecificType)
 
@@ -21,29 +21,30 @@ open internal class GenericType(protected val mostSpecificType: JavaType, protec
     fun isAssignableFrom(type: JavaType) = TypeUtils.isAssignable(type, mostSpecificType)
 
     fun relativeToPotentialParent(declaringType: JavaType): RelativeTo {
-        if(declaringType !is Class<*>) {
+        if (declaringType !is Class<*> || declaringType.isInterface) {
             return relativeToType(declaringType)
         }
 
         val type = getGenericSuperType(mostSpecificType, declaringType)
-        if(type == null) {
+        if (type == null) {
             error("Unable to find generic type of class ${TypeUtils.toString(declaringType)} relative to ${TypeUtils.toString(mostSpecificType)}")
         } else {
             return relativeToType(type)
         }
     }
+
     fun relativeToType(declaringType: JavaType) = RelativeTo(declaringType, mostSpecificType, options)
 
     fun getGenericInterface(targetInterface: Class<*>) = getGenericInterface(mostSpecificType, targetInterface)
 
     private fun getGenericInterface(type: JavaType?, targetInterface: Class<*>): JavaType? {
-        if(type == null) {
+        if (type == null) {
             return null
         }
 
         val raw = type as? Class<*> ?: getRawClass(type)
 
-        if(raw == targetInterface) {
+        if (raw == targetInterface) {
             return type
         }
 
@@ -59,32 +60,32 @@ open internal class GenericType(protected val mostSpecificType: JavaType, protec
     fun getGenericSuperType(targetSuperClass: Class<*>) = getGenericSuperType(mostSpecificType, targetSuperClass)
 
     private fun getGenericSuperType(type: JavaType?, targetSuperClass: Class<*>): JavaType? {
-        if(type == null) {
+        if (type == null) {
             return null
         }
 
         val raw = type as? Class<*> ?: TypeUtils.getRawType(type, type)
 
-        if(raw == targetSuperClass) {
+        if (raw == targetSuperClass) {
             return type
         }
 
         return getGenericSuperType(raw.genericSuperclass, targetSuperClass)
     }
 
-    class RelativeTo(private val declaringType: JavaType, mostSpecificType: JavaType, options: SchemaParserOptions): GenericType(mostSpecificType, options) {
+    class RelativeTo(private val declaringType: JavaType, mostSpecificType: JavaType, options: SchemaParserOptions) : GenericType(mostSpecificType, options) {
 
         /**
          * Unwrap certain Java types to find the "real" class.
          */
         fun unwrapGenericType(type: JavaType): JavaType {
-            return when(type) {
+            return when (type) {
                 is ParameterizedType -> {
                     val rawType = type.rawType
                     val genericType = options.genericWrappers.find { it.type == rawType } ?: return type
 
                     val typeArguments = type.actualTypeArguments
-                    if(typeArguments.size <= genericType.index) {
+                    if (typeArguments.size <= genericType.index) {
                         throw IndexOutOfBoundsException("Generic type '${TypeUtils.toString(type)}' does not have a type argument at index ${genericType.index}!")
                     }
 
@@ -96,15 +97,17 @@ open internal class GenericType(protected val mostSpecificType: JavaType, protec
 
                     return unwrapGenericType(unwrapsTo)
                 }
-                is Class<*> -> if(type.isPrimitive) Primitives.wrap(type) else type
+                is Class<*> -> if (type.isPrimitive) Primitives.wrap(type) else type
                 is TypeVariable<*> -> {
-                    if(declaringType !is ParameterizedType) {
+                    if (declaringType !is ParameterizedType) {
                         error("Could not resolve type variable '${TypeUtils.toLongString(type)}' because declaring type is not parameterized: ${TypeUtils.toString(declaringType)}")
                     }
 
-                    unwrapGenericType(TypeUtils.determineTypeArguments(getRawClass(mostSpecificType), declaringType)[type] ?: error("No type variable found for: ${TypeUtils.toLongString(type)}"))
+                    unwrapGenericType(TypeUtils.determineTypeArguments(getRawClass(mostSpecificType), declaringType)[type]
+                            ?: error("No type variable found for: ${TypeUtils.toLongString(type)}"))
                 }
-                is WildcardTypeImpl -> type.upperBounds.firstOrNull() ?: throw error("Unable to unwrap type, wildcard has no upper bound: $type")
+                is WildcardTypeImpl -> type.upperBounds.firstOrNull()
+                        ?: throw error("Unable to unwrap type, wildcard has no upper bound: $type")
                 else -> error("Unable to unwrap type: $type")
             }
         }
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/ResolverInfo.kt b/src/main/kotlin/com/coxautodev/graphql/tools/ResolverInfo.kt
@@ -64,8 +64,10 @@ internal class MultiResolverInfo(val resolverInfoList: List<NormalResolverInfo>)
 
     override fun getFieldSearches(): List<FieldResolverScanner.Search> {
         return resolverInfoList
+                .asSequence()
                 .map { FieldResolverScanner.Search(it.resolverType, this, it.resolver, dataClassType, true) }
                 .plus(FieldResolverScanner.Search(dataClassType, this, null))
+                .toList()
     }
 }
 
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/SchemaClassScanner.kt b/src/main/kotlin/com/coxautodev/graphql/tools/SchemaClassScanner.kt
@@ -412,7 +412,7 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
     }
 
     class ReturnValueReference(private val method: Method) : Reference() {
-        fun getMethod() = method;
+        fun getMethod() = method
         override fun getDescription() = "return type of method $method"
     }
 
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/TypeClassMatcher.kt b/src/main/kotlin/com/coxautodev/graphql/tools/TypeClassMatcher.kt
@@ -6,9 +6,7 @@ import graphql.language.NonNullType
 import graphql.language.ScalarTypeDefinition
 import graphql.language.TypeDefinition
 import graphql.language.TypeName
-import graphql.relay.Connection
 import graphql.schema.idl.ScalarInfo
-import org.apache.commons.lang3.reflect.TypeUtils
 import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
 import java.lang.reflect.ParameterizedType
 import java.util.*
diff --git a/src/test/groovy/com/coxautodev/graphql/tools/FieldResolverScannerSpec.groovy b/src/test/groovy/com/coxautodev/graphql/tools/FieldResolverScannerSpec.groovy
@@ -2,6 +2,10 @@ package com.coxautodev.graphql.tools
 
 import graphql.language.FieldDefinition
 import graphql.language.TypeName
+import graphql.relay.Connection
+import graphql.relay.DefaultConnection
+import graphql.relay.SimpleListConnection
+import graphql.schema.DataFetchingEnvironment
 import spock.lang.Specification
 
 /**
@@ -59,6 +63,17 @@ class FieldResolverScannerSpec extends Specification {
             version instanceof PropertyFieldResolver
     }
 
+    def "scanner finds generic return type"() {
+        setup:
+            def resolver = new RootResolverInfo([new GenericQuery()], options)
+
+        when:
+            def users = scanner.findFieldResolver(new FieldDefinition("users", new TypeName("UserConnection")), resolver)
+
+        then:
+            users instanceof MethodFieldResolver
+    }
+
     class RootQuery1 implements GraphQLQueryResolver {
         def field1() {}
     }
@@ -78,4 +93,12 @@ class FieldResolverScannerSpec extends Specification {
     class PropertyQuery extends ParentPropertyQuery implements GraphQLQueryResolver {
         private String name = "name"
     }
+
+    class User {
+
+    }
+
+    class GenericQuery implements GraphQLQueryResolver {
+        Connection<User> getUsers() { }
+    }
 }
diff --git a/src/test/groovy/com/coxautodev/graphql/tools/RelayConnectionSpec.groovy b/src/test/groovy/com/coxautodev/graphql/tools/RelayConnectionSpec.groovy
@@ -2,15 +2,27 @@ package com.coxautodev.graphql.tools
 
 import graphql.relay.Connection
 import graphql.relay.DefaultConnection
+import graphql.relay.Edge
 import graphql.relay.SimpleListConnection
 import graphql.schema.DataFetchingEnvironment
 import spock.lang.Specification
 
 class RelayConnectionSpec extends Specification {
 
+    private static final SchemaParserOptions options = SchemaParserOptions.newOptions().genericWrappers(
+            new SchemaParserOptions.GenericWrapper(
+                    Connection.class,
+                    0
+            ),
+            new SchemaParserOptions.GenericWrapper(
+                    Edge.class,
+                    0
+            )
+    ).build()
+
     def "relay connection types are compatible"() {
         when:
-            SchemaParser.newParser().schemaString('''\
+            SchemaParser.newParser().options(options).schemaString('''\
                         type Query {
                             users(first: Int, after: String): UserConnection
                         }

Original file line number	Diff line number	Diff line change
`@@ -64,8 +64,10 @@ internal class MultiResolverInfo(val resolverInfoList: List<NormalResolverInfo>)`
`64`	`64`
`65`	`65`	`override fun getFieldSearches(): List<FieldResolverScanner.Search> {`
`66`	`66`	`return resolverInfoList`
	`67`	`+ .asSequence()`
`67`	`68`	`.map { FieldResolverScanner.Search(it.resolverType, this, it.resolver, dataClassType, true) }`
`68`	`69`	`.plus(FieldResolverScanner.Search(dataClassType, this, null))`
	`70`	`+ .toList()`
`69`	`71`	`}`
`70`	`72`	`}`
`71`	`73`
Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`class ReturnValueReference(private val method: Method) : Reference() {`
`415`		`- fun getMethod() = method;`
	`415`	`+ fun getMethod() = method`
`416`	`416`	`override fun getDescription() = "return type of method $method"`
`417`	`417`	`}`
`418`	`418`