Refactor of tests to use TestUtil more consistently where I could

Author: bbakerman

src/test/groovy/graphql/TestUtil.groovy

@@ -13,15 +13,12 @@ import graphql.schema.GraphQLInputType
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLScalarType
 import graphql.schema.GraphQLSchema
-import graphql.schema.PropertyDataFetcher
 import graphql.schema.TypeResolver
-import graphql.schema.idl.FieldWiringEnvironment
-import graphql.schema.idl.InterfaceWiringEnvironment
+import graphql.schema.idl.MockedWiringFactory
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaGenerator
 import graphql.schema.idl.SchemaParser
 import graphql.schema.idl.TypeRuntimeWiring
-import graphql.schema.idl.UnionWiringEnvironment
 import graphql.schema.idl.WiringFactory
 import graphql.schema.idl.errors.SchemaProblem
 
@@ -61,13 +58,24 @@ class TestUtil {
     }
 
     static GraphQLSchema schema(String spec) {
-        schema(spec, RuntimeWiring.newRuntimeWiring().wiringFactory(mockWiringFactory).build())
+        schema(spec, mockRuntimeWiring)
+    }
+
+    static GraphQLSchema schema(Reader specReader) {
+        schema(specReader, mockRuntimeWiring)
     }
 
     static GraphQLSchema schemaFile(String fileName) {
-        return schemaFile(fileName, RuntimeWiring.newRuntimeWiring().wiringFactory(mockWiringFactory).build())
+        return schemaFile(fileName, mockRuntimeWiring)
+    }
+
+
+    static GraphQLSchema schemaFromResource(String resourceFileName, RuntimeWiring wiring) {
+        def stream = TestUtil.class.getClassLoader().getResourceAsStream(resourceFileName)
+        return schema(stream, wiring)
     }
 
+
     static GraphQLSchema schemaFile(String fileName, RuntimeWiring wiring) {
         def stream = TestUtil.class.getClassLoader().getResourceAsStream(fileName)
 
@@ -78,14 +86,22 @@ class TestUtil {
     }
 
 
-    @SuppressWarnings("GroovyMissingReturnStatement")
     static GraphQLSchema schema(String spec, RuntimeWiring runtimeWiring) {
+        schema(new StringReader(spec), runtimeWiring)
+    }
+
+    static GraphQLSchema schema(InputStream specStream, RuntimeWiring runtimeWiring) {
+        schema(new InputStreamReader(specStream), runtimeWiring)
+    }
+
+    static GraphQLSchema schema(Reader specReader, RuntimeWiring runtimeWiring) {
         try {
-            def registry = new SchemaParser().parse(spec)
+            def registry = new SchemaParser().parse(specReader)
             def options = SchemaGenerator.Options.defaultOptions().enforceSchemaDirectives(false)
             return new SchemaGenerator().makeExecutableSchema(options, registry, runtimeWiring)
         } catch (SchemaProblem e) {
             assert false: "The schema could not be compiled : ${e}"
+            return null
         }
     }
 
@@ -95,56 +111,16 @@ class TestUtil {
             return new SchemaGenerator().makeExecutableSchema(options, registry, runtimeWiring)
         } catch (SchemaProblem e) {
             assert false: "The schema could not be compiled : ${e}"
+            return null
         }
     }
 
-    static WiringFactory mockWiringFactory = new WiringFactory() {
-
-        @Override
-        boolean providesTypeResolver(InterfaceWiringEnvironment environment) {
-            return true
-        }
-
-        @Override
-        TypeResolver getTypeResolver(InterfaceWiringEnvironment environment) {
-            new TypeResolver() {
-                @Override
-                GraphQLObjectType getType(TypeResolutionEnvironment env) {
-                    throw new UnsupportedOperationException("Not implemented")
-                }
-            }
-        }
-
-        @Override
-        boolean providesTypeResolver(UnionWiringEnvironment environment) {
-            return true
-        }
-
-        @Override
-        TypeResolver getTypeResolver(UnionWiringEnvironment environment) {
-            new TypeResolver() {
-                @Override
-                GraphQLObjectType getType(TypeResolutionEnvironment env) {
-                    throw new UnsupportedOperationException("Not implemented")
-                }
-            }
-        }
-
-        @Override
-        boolean providesDataFetcher(FieldWiringEnvironment environment) {
-            return true
-        }
-
-        @Override
-        DataFetcher getDataFetcher(FieldWiringEnvironment environment) {
-            return new PropertyDataFetcher(environment.getFieldDefinition().getName())
-        }
-    }
+    static WiringFactory mockWiringFactory = new MockedWiringFactory()
 
     static RuntimeWiring mockRuntimeWiring = RuntimeWiring.newRuntimeWiring().wiringFactory(mockWiringFactory).build()
 
     static GraphQLScalarType mockScalar(String name) {
-        new GraphQLScalarType(name, name, mockCoercing());
+        new GraphQLScalarType(name, name, mockCoercing())
     }
 
     private static Coercing mockCoercing() {
@@ -169,10 +145,10 @@ class TestUtil {
     static GraphQLScalarType mockScalar(ScalarTypeDefinition definition) {
         new GraphQLScalarType(
                 definition.getName(),
-                definition.getDescription(),
+                definition.getDescription() == null ? null : definition.getDescription().getContent(),
                 mockCoercing(),
                 definition.getDirectives().stream().map({ mockDirective(it.getName()) }).collect(Collectors.toList()),
-                definition);
+                definition)
     }
 
     static GraphQLDirective mockDirective(String name) {
@@ -189,7 +165,7 @@ class TestUtil {
                 }
             })
         }
-        return builder.build();
+        return builder.build()
     }
 
 

src/test/groovy/graphql/execution/FieldCollectorTest.groovy

@@ -1,32 +1,22 @@
 package graphql.execution
 
+import graphql.TestUtil
 import graphql.language.Document
 import graphql.language.Field
 import graphql.language.InlineFragment
 import graphql.language.OperationDefinition
 import graphql.parser.Parser
 import graphql.schema.GraphQLObjectType
-import graphql.schema.GraphQLSchema
-import graphql.schema.idl.MockedWiringFactory
-import graphql.schema.idl.RuntimeWiring
-import graphql.schema.idl.SchemaGenerator
-import graphql.schema.idl.SchemaParser
 import spock.lang.Specification
 
 import static graphql.execution.FieldCollectorParameters.newParameters
 
 class FieldCollectorTest extends Specification {
 
 
-    GraphQLSchema createSchema(String schema) {
-        def registry = new SchemaParser().parse(schema)
-        return new SchemaGenerator().makeExecutableSchema(registry,
-                RuntimeWiring.newRuntimeWiring().wiringFactory(new MockedWiringFactory()).build())
-    }
-
     def "collect fields"() {
         given:
-        def schema = createSchema("""
+        def schema = TestUtil.schema("""
             type Query {
                 bar1: String
                 bar2: String 
@@ -53,7 +43,7 @@ class FieldCollectorTest extends Specification {
     }
 
     def "collect fields on inline fragments"() {
-        def schema = createSchema("""
+        def schema = TestUtil.schema("""
             type Query{
                 bar1: String
                 bar2: Test 

src/test/groovy/graphql/introspection/IntrospectionResultToSchemaTest.groovy

@@ -13,9 +13,6 @@ import graphql.language.ObjectTypeDefinition
 import graphql.language.UnionTypeDefinition
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
-import graphql.schema.idl.RuntimeWiring
-import graphql.schema.idl.SchemaGenerator
-import graphql.schema.idl.SchemaParser
 import graphql.schema.idl.SchemaPrinter
 import groovy.json.JsonSlurper
 import spock.lang.Specification
@@ -556,9 +553,8 @@ input CharacterInput {
 
         when:
         def printedSchema = new SchemaPrinter().print(graphQLSchema)
-        def typeRegistry = new SchemaParser().parse(printedSchema)
-        RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring().build()
-        GraphQLSchema schema = new SchemaGenerator().makeExecutableSchema(typeRegistry, runtimeWiring)
+
+        GraphQLSchema schema = TestUtil.schema(printedSchema)
 
         def introspectionResult = GraphQL.newGraphQL(schema).build().execute(ExecutionInput.newExecutionInput().query(INTROSPECTION_QUERY).build())
         Document schemaDefinitionDocument = introspectionResultToSchema.createSchemaDefinition(introspectionResult.data as Map)

src/test/groovy/graphql/schema/idl/ExecutableStarWarsSchemaTest.groovy

@@ -2,7 +2,7 @@ package graphql.schema.idl
 
 import graphql.GraphQL
 import graphql.StarWarsData
-import graphql.schema.GraphQLSchema
+import graphql.TestUtil
 import graphql.schema.StaticDataFetcher
 import spock.lang.Specification
 
@@ -14,15 +14,6 @@ import static TypeRuntimeWiring.newTypeWiring
  */
 class ExecutableStarWarsSchemaTest extends Specification {
 
-    GraphQLSchema load(String fileName, RuntimeWiring wiring) {
-        def stream = getClass().getClassLoader().getResourceAsStream(fileName)
-
-        def typeRegistry = new SchemaParser().parse(new InputStreamReader(stream))
-        def schema = new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring)
-        schema
-    }
-
-
     RuntimeWiring wiring = RuntimeWiring.newRuntimeWiring()
             .type(newTypeWiring("QueryType")
             .dataFetchers(
@@ -44,7 +35,7 @@ class ExecutableStarWarsSchemaTest extends Specification {
     )
             .build()
 
-    def executableStarWarsSchema = load("starWarsSchema.graphqls", wiring)
+    def executableStarWarsSchema = TestUtil.schemaFromResource("starWarsSchema.graphqls", wiring)
 
 
     def 'Correctly identifies R2-D2 as the hero of the Star Wars Saga'() {

src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy

@@ -47,7 +47,7 @@ class SchemaPrinterTest extends Specification {
                 .type("Node", { type -> type.typeResolver(resolver) } as UnaryOperator<TypeRuntimeWiring.Builder>)
                 .scalar(ASTEROID)
                 .build()
-        GraphQLSchema schema = load("starWarsSchemaExtended.graphqls", wiring)
+        GraphQLSchema schema = TestUtil.schemaFromResource("starWarsSchemaExtended.graphqls", wiring)
         schema
     }
 
@@ -77,20 +77,6 @@ class SchemaPrinterTest extends Specification {
         }
     }
 
-    GraphQLSchema load(String fileName, RuntimeWiring wiring) {
-        def stream = getClass().getClassLoader().getResourceAsStream(fileName)
-
-        def typeRegistry = new SchemaParser().parse(new InputStreamReader(stream))
-        def schema = new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring)
-        schema
-    }
-
-    GraphQLSchema generate(String spec) {
-        def typeRegistry = new SchemaParser().parse(spec)
-        def schema = new SchemaGenerator().makeExecutableSchema(typeRegistry, newRuntimeWiring().build())
-        schema
-    }
-
     static class MyGraphQLObjectType extends GraphQLObjectType {
 
         MyGraphQLObjectType(String name, String description, List<GraphQLFieldDefinition> fieldDefinitions) {
@@ -178,7 +164,7 @@ class SchemaPrinterTest extends Specification {
     }
 
     def "default root names are handled"() {
-        def schema = generate("""
+        def schema = TestUtil.schema("""
             type Query {
                 field: String
             }
@@ -211,7 +197,7 @@ type Subscription {
     }
 
     def "schema prints if forced with default root names"() {
-        def schema = generate("""
+        def schema = TestUtil.schema("""
             type Query {
                 field: String
             }
@@ -253,7 +239,7 @@ type Subscription {
 
 
     def "schema is printed if default root names are not ALL present"() {
-        def schema = generate("""
+        def schema = TestUtil.schema("""
             type Query {
                 field: String
             }
@@ -623,7 +609,7 @@ type Query {
 
 
     def "schema will be sorted"() {
-        def schema = generate("""
+        def schema = TestUtil.schema("""
             type Query {
                 fieldB(argZ : String, argY : Int, argX : String) : String
                 fieldA(argZ : String, argY : Int, argX : String) : String
@@ -738,7 +724,7 @@ enum Episode {
 
 
     def "AST doc string entries are printed if present"() {
-        def schema = generate('''
+        def schema = TestUtil.schema('''
             # comments up here
             """docstring"""
             # and comments as well down here

src/test/groovy/graphql/schema/idl/WiringFactoryTest.groovy

@@ -1,5 +1,6 @@
 package graphql.schema.idl
 
+import graphql.TestUtil
 import graphql.TypeResolutionEnvironment
 import graphql.schema.Coercing
 import graphql.schema.DataFetcher
@@ -9,7 +10,6 @@ import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLInterfaceType
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLScalarType
-import graphql.schema.GraphQLSchema
 import graphql.schema.GraphQLUnionType
 import graphql.schema.PropertyDataFetcher
 import graphql.schema.TypeResolver
@@ -125,13 +125,6 @@ class WiringFactoryTest extends Specification {
     }
 
 
-    GraphQLSchema generateSchema(String schemaSpec, RuntimeWiring wiring) {
-        def typeRegistry = new SchemaParser().parse(schemaSpec)
-        def result = new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring)
-        result
-    }
-
-
     def "ensure that wiring factory is called to resolve and create data fetchers"() {
 
         def spec = """             
@@ -183,7 +176,7 @@ class WiringFactoryTest extends Specification {
                 .wiringFactory(combinedWiringFactory)
                 .build()
 
-        def schema = generateSchema(spec, wiring)
+        def schema = TestUtil.schema(spec, wiring)
 
         expect:
 
@@ -246,7 +239,7 @@ class WiringFactoryTest extends Specification {
                 .wiringFactory(wiringFactory)
                 .build()
 
-        generateSchema(spec, wiring)
+        TestUtil.schema(spec, wiring)
 
         expect:
 
@@ -292,7 +285,7 @@ class WiringFactoryTest extends Specification {
                 .wiringFactory(wiringFactory)
                 .build()
 
-        generateSchema(spec, wiring)
+        TestUtil.schema(spec, wiring)
 
         expect:
 
@@ -316,7 +309,7 @@ class WiringFactoryTest extends Specification {
                 .wiringFactory(wiringFactory)
                 .build()
 
-        def schema = generateSchema(spec, wiring)
+        def schema = TestUtil.schema(spec, wiring)
 
         GraphQLObjectType type = schema.getType("Query") as GraphQLObjectType