Clarify test about relay connections, by moving to another class the code that checks if the @uppercase directive is applied correctly.

Author: BURJA Lucian

src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt

@@ -2,13 +2,75 @@ package graphql.kickstart.tools
 
 import graphql.GraphQL
 import graphql.execution.AsyncExecutionStrategy
+import graphql.relay.Connection
+import graphql.relay.SimpleListConnection
+import graphql.schema.DataFetcherFactories
+import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.idl.SchemaDirectiveWiring
 import graphql.schema.idl.SchemaDirectiveWiringEnvironment
+import org.junit.Assert
 import org.junit.Ignore
 import org.junit.Test
+import java.util.function.BiFunction
 
 class DirectiveTest {
+    @Test
+    fun `should apply correctly the @uppercase directive`() {
+        val schema = SchemaParser.newParser().schemaString("""
+              directive @uppercase on FIELD_DEFINITION
+  
+              type Query {
+                users: UserConnection
+              }
+      
+              type UserConnection {
+                edges: [UserEdge!]!
+              }
+      
+              type UserEdge {
+                node: User!
+              } 
+              
+              type User {
+                id: ID!
+                name: String @uppercase
+              }
+            """)
+                .resolvers(UsersQueryResolver())
+                .directive("uppercase", UppercaseDirective())
+                .build()
+                .makeExecutableSchema()
+
+        val gql = GraphQL.newGraphQL(schema)
+                .queryExecutionStrategy(AsyncExecutionStrategy())
+                .build()
+
+        val result = gql.execute("""
+          query {
+            users {
+              edges {
+                node {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        """)
+
+        val expected = mapOf(
+                "users" to mapOf(
+                        "edges" to listOf(
+                                mapOf("node" to
+                                        mapOf("id" to "1", "name" to "LUKE")
+                                )
+                        )
+                )
+        )
+
+        Assert.assertEquals(expected, result.getData<Map<String, List<*>>>())
+    }
 
     @Test
     @Ignore("Ignore until enums work in directives")
@@ -65,4 +127,32 @@ class DirectiveTest {
             return field
         }
     }
+
+    private class UppercaseDirective : SchemaDirectiveWiring {
+
+        override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
+            val field = environment.element
+            val parentType = environment.fieldsContainer
+
+            val originalDataFetcher = environment.codeRegistry.getDataFetcher(parentType, field)
+            val wrappedDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher, BiFunction { env, value ->
+                (value as? String)?.toUpperCase()
+            })
+
+            environment.codeRegistry.dataFetcher(parentType, field, wrappedDataFetcher)
+
+            return field
+        }
+    }
+
+    private class UsersQueryResolver : GraphQLQueryResolver {
+        fun users(env: DataFetchingEnvironment): Connection<User> {
+            return SimpleListConnection(listOf(User(1L, "Luke"))).get(env)
+        }
+
+        private data class User(
+                val id: Long,
+                val name: String
+        )
+    }
 }

src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt

@@ -4,25 +4,16 @@ import graphql.GraphQL
 import graphql.execution.AsyncExecutionStrategy
 import graphql.relay.Connection
 import graphql.relay.SimpleListConnection
-import graphql.schema.DataFetcherFactories
 import graphql.schema.DataFetchingEnvironment
-import graphql.schema.GraphQLFieldDefinition
-import graphql.schema.idl.SchemaDirectiveWiring
-import graphql.schema.idl.SchemaDirectiveWiringEnvironment
 import groovy.lang.Closure
 import org.junit.Assert
 import org.junit.Test
-import java.util.function.BiFunction
 
 class RelayConnectionTest {
 
     @Test
     fun `should compile relay schema when not using @connection directive`() {
-        // Note: in addition to testing that a relay schema compiles without the @connection directive,
-        //       this test also verifies that a custom @uppercase directive works as expected
         val schema = SchemaParser.newParser().schemaString("""
-              directive @uppercase on FIELD_DEFINITION
-  
               type Query {
                 users(first: Int, after: String): UserConnection
                 otherTypes: AnotherTypeConnection
@@ -39,7 +30,7 @@ class RelayConnectionTest {
               
               type User {
                 id: ID!
-                name: String @uppercase
+                name: String
               }
       
               type PageInfo {
@@ -59,7 +50,6 @@ class RelayConnectionTest {
               }
             """)
             .resolvers(QueryResolver())
-            .directive("uppercase", UppercaseDirective())
             .build()
             .makeExecutableSchema()
 
@@ -91,7 +81,7 @@ class RelayConnectionTest {
             "users" to mapOf(
                 "edges" to listOf(
                     mapOf("node" to
-                        mapOf("id" to "1", "name" to "LUKE")
+                        mapOf("id" to "1", "name" to "Luke")
                     )
                 )
             ),
@@ -163,21 +153,4 @@ class RelayConnectionTest {
     private data class AnotherType(
         val echo: String
     )
-
-    private class UppercaseDirective : SchemaDirectiveWiring {
-
-        override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
-            val field = environment.element
-            val parentType = environment.fieldsContainer
-
-            val originalDataFetcher = environment.codeRegistry.getDataFetcher(parentType, field)
-            val wrappedDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher, BiFunction { env, value ->
-                (value as? String)?.toUpperCase()
-            })
-
-            environment.codeRegistry.dataFetcher(parentType, field, wrappedDataFetcher)
-
-            return field
-        }
-    }
 }