Load GraphQL schema via introspection (#616)

* load GraphQL schema via introspection

* minor refactor

* sneaking in a small timing data change

* add graphql-groovy dep to webtau-groovy so it shows up in maven plugin

* rename common sounding classes

* use lower level http constructs to avoid reporter problems

* licenses...

Author: tsiq-karold

pom.xml

@@ -500,6 +500,12 @@
                 <version>${jackson.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>com.fasterxml.jackson.datatype</groupId>
+                <artifactId>jackson-datatype-jdk8</artifactId>
+                <version>${jackson.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>com.google.guava</groupId>
                 <artifactId>guava</artifactId>

webtau-config/src/main/java/org/testingisdocumenting/webtau/cfg/WebTauConfigHandler.java

@@ -1,4 +1,5 @@
 /*
+ * Copyright 2020 webtau maintainers
  * Copyright 2019 TWO SIGMA OPEN SOURCE, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,6 +21,6 @@
 
 public interface WebTauConfigHandler {
     default void onBeforeCreate(WebTauConfig cfg) {}
-    default void onAfterCreate(WebTauConfig cfg) {};
+    default void onAfterCreate(WebTauConfig cfg) {}
     default Stream<ConfigValue> additionalConfigValues() { return Stream.empty(); }
 }

webtau-core-groovy/src/main/groovy/org/testingisdocumenting/webtau/data/json/GStringJsonSerializationModuleProvider.groovy

@@ -18,13 +18,14 @@ package org.testingisdocumenting.webtau.data.json
 
 import com.fasterxml.jackson.core.JsonGenerator
 import com.fasterxml.jackson.databind.JsonSerializer
+import com.fasterxml.jackson.databind.Module
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.module.SimpleModule
 import org.testingisdocumenting.webtau.utils.json.JsonSerializationModuleProvider
 
 class GStringJsonSerializationModuleProvider implements JsonSerializationModuleProvider {
     @Override
-    SimpleModule provide() {
+    Module provide() {
         SimpleModule module = new SimpleModule()
         module.addSerializer(GString.class, new JsonSerializer<GString>() {
             @Override

webtau-feature-testing/examples/scenarios/graphql/webtau.cfg

@@ -2,6 +2,6 @@ import scenarios.graphql.Report
 
 url = "http://localhost:8180"
 
-graphQLSchema = "scenarios/graphql/schema.graphql"
+graphQLEnabled = true
 
 reportGenerator = Report.&generateReport

webtau-graphql/pom.xml

@@ -39,6 +39,11 @@
             <artifactId>graphql-java</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.testingisdocumenting.webtau</groupId>
             <artifactId>webtau-core-groovy</artifactId>

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQL.java

@@ -16,17 +16,14 @@
 
 package org.testingisdocumenting.webtau.graphql;
 
+import org.testingisdocumenting.webtau.graphql.model.GraphQLRequest;
 import org.testingisdocumenting.webtau.http.HttpHeader;
-import org.testingisdocumenting.webtau.http.json.JsonRequestBody;
 import org.testingisdocumenting.webtau.http.validation.HttpResponseValidatorWithReturn;
 
-import java.util.HashMap;
 import java.util.Map;
 
 import static org.testingisdocumenting.webtau.Matchers.equal;
 import static org.testingisdocumenting.webtau.http.Http.http;
-import static org.testingisdocumenting.webtau.utils.CollectionUtils.notNullOrEmpty;
-import static org.testingisdocumenting.webtau.utils.StringUtils.notNullOrEmpty;
 
 public class GraphQL {
     public static final GraphQL graphql = new GraphQL();
@@ -40,8 +37,12 @@ static GraphQLCoverage getCoverage() {
         return coverage;
     }
 
+    public static GraphQLSchema getSchema() {
+        return schema;
+    }
+
     static void reset() {
-        schema = new GraphQLSchema(GraphQLConfig.schemaFullPath());
+        schema = new GraphQLSchema(GraphQLConfig.isEnabled());
         coverage = new GraphQLCoverage(schema);
     }
 
@@ -54,19 +55,7 @@ public <E> E execute(String query, Map<String, Object> variables, HttpResponseVa
     }
 
     public <E> E execute(String query, Map<String, Object> variables, String operationName, HttpHeader header, HttpResponseValidatorWithReturn validator) {
-        Map<String, Object> request = new HashMap<>();
-        request.put("query", query);
-
-        if (notNullOrEmpty(variables)) {
-            request.put("variables", variables);
-        }
-
-        if (notNullOrEmpty(operationName)) {
-            request.put("operationName", operationName);
-        }
-
-        // TODO make the url configurable
-        return http.post("/graphql", header, new JsonRequestBody(request), (headerDataNode, body) -> {
+        return http.post("/graphql", header, GraphQLRequest.body(query, variables, operationName), (headerDataNode, body) -> {
             headerDataNode.statusCode().should(equal(SUCCESS_CODE));
             return validator.validate(headerDataNode, body);
         });

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLConfig.java

@@ -25,24 +25,20 @@
 import static org.testingisdocumenting.webtau.cfg.ConfigValue.declare;
 
 public class GraphQLConfig implements WebTauConfigHandler {
-    static final ConfigValue schemaPath = declare("graphQLSchema",
-            "path to GraphQL schema against which to validate http calls", () -> "");
+    static final ConfigValue graphQLEnabled = declare("graphQLEnabled",
+            "enable graphQL coverage and timing capture", () -> false);
 
-    private static String fullPath;
-
-    static String schemaFullPath() {
-        return fullPath;
+    static boolean isEnabled() {
+        return graphQLEnabled.getAsBoolean();
     }
 
     @Override
     public void onAfterCreate(WebTauConfig cfg) {
-        fullPath = schemaPath.getAsString().isEmpty() ? "" :
-                cfg.getWorkingDir().resolve(schemaPath.getAsString()).toString();
         GraphQL.reset();
     }
 
     @Override
     public Stream<ConfigValue> additionalConfigValues() {
-        return Stream.of(schemaPath);
+        return Stream.of(graphQLEnabled);
     }
 }

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLQuery.java

@@ -24,7 +24,7 @@ public class GraphQLQuery {
     private final String name;
     private final GraphQLQueryType type;
 
-    GraphQLQuery(String name, GraphQLQueryType type) {
+    public GraphQLQuery(String name, GraphQLQueryType type) {
         this.name = name;
         this.type = type;
     }

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLReportDataProvider.java

@@ -80,6 +80,7 @@ public Stream<ReportCustomData> provide(WebTauTestList tests) {
         statistics.put("mean", summaryStatistics.getAverage());
         statistics.put("min", summaryStatistics.getMin());
         statistics.put("max", summaryStatistics.getMax());
+        statistics.put("count", summaryStatistics.getCount());
 
         double[] times = entry.getValue().stream().map(GraphQLCoveredQueries.Call::getElapsedTime).mapToDouble(Long::doubleValue).sorted().toArray();
         Percentile percentile = new Percentile();

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLSchema.java

@@ -16,69 +16,51 @@
 
 package org.testingisdocumenting.webtau.graphql;
 
+import com.google.common.base.Suppliers;
 import graphql.ExecutionInput;
 import graphql.ParseAndValidate;
 import graphql.ParseAndValidateResult;
 import graphql.language.Field;
 import graphql.language.OperationDefinition;
-import graphql.schema.GraphQLObjectType;
-import graphql.schema.idl.RuntimeWiring;
-import graphql.schema.idl.SchemaGenerator;
-import graphql.schema.idl.SchemaParser;
-import graphql.schema.idl.TypeDefinitionRegistry;
 import org.testingisdocumenting.webtau.http.request.HttpRequestBody;
-import org.testingisdocumenting.webtau.utils.FileUtils;
 import org.testingisdocumenting.webtau.utils.JsonUtils;
 
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.function.BiConsumer;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static java.util.Collections.emptySet;
 
 public class GraphQLSchema {
-    private final boolean isSchemaDefined;
-    private final Set<GraphQLQuery> schemaDeclaredQueries;
-
-    public GraphQLSchema(String schemaPathStr) {
-        isSchemaDefined = !schemaPathStr.isEmpty();
-        schemaDeclaredQueries = new HashSet<>();
-
-        if (isSchemaDefined) {
-            SchemaParser schemaParser = new SchemaParser();
-            Path schemaPath = Paths.get(schemaPathStr);
-            TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(FileUtils.fileTextContent(schemaPath));
-
-            RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring().build();
-
-            SchemaGenerator schemaGenerator = new SchemaGenerator();
-            graphql.schema.GraphQLSchema schema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
-
-            BiConsumer<Optional<GraphQLObjectType>, GraphQLQueryType> registerTypes = (objectType, queryType) ->
-                    objectType.ifPresent(type ->
-                            type.getFieldDefinitions().forEach(definition -> schemaDeclaredQueries.add(
-                                    new GraphQLQuery(definition.getName(), queryType)
-                            )));
-            registerTypes.accept(Optional.ofNullable(schema.getQueryType()), GraphQLQueryType.QUERY);
-            registerTypes.accept(Optional.ofNullable(schema.getMutationType()), GraphQLQueryType.MUTATION);
-            registerTypes.accept(Optional.ofNullable(schema.getSubscriptionType()), GraphQLQueryType.SUBSCRIPTION);
+    private static final Supplier<Optional<Set<GraphQLQuery>>> NO_QUERIES_SUPPLIER = Optional::empty;
+
+    private final Supplier<Optional<Set<GraphQLQuery>>> schemaDeclaredQueriesSupplier;
+
+    public GraphQLSchema(boolean isEnabled) {
+        if (!isEnabled) {
+            this.schemaDeclaredQueriesSupplier = NO_QUERIES_SUPPLIER;
+            return;
         }
+
+        this.schemaDeclaredQueriesSupplier = Suppliers.memoize(() ->
+                Optional.of(GraphQLSchemaLoader.fetchSchemaDeclaredQueries()));
+    }
+
+    public GraphQLSchema(Set<GraphQLQuery> schemaDeclaredQueries) {
+        this.schemaDeclaredQueriesSupplier = () -> Optional.of(schemaDeclaredQueries);
     }
 
     public boolean isSchemaDefined() {
-        return isSchemaDefined;
+        return schemaDeclaredQueriesSupplier.get().isPresent();
     }
 
     public Stream<GraphQLQuery> getSchemaDeclaredQueries() {
-        return schemaDeclaredQueries.stream();
+        return schemaDeclaredQueriesSupplier.get().map(Set::stream).orElseGet(Stream::empty);
     }
 
     public Set<GraphQLQuery> findQueries(HttpRequestBody requestBody) {
@@ -98,7 +80,9 @@ public Set<GraphQLQuery> findQueries(HttpRequestBody requestBody) {
 
         List<OperationDefinition> operations = parsingResult.getDocument().getDefinitionsOfType(OperationDefinition.class);
         if (operationName != null) {
-            List<OperationDefinition> matchingOperations = operations.stream().filter(operationDefinition -> operationName.equals(operationDefinition.getName())).collect(Collectors.toList());
+            List<OperationDefinition> matchingOperations = operations.stream()
+                    .filter(operationDefinition -> operationName.equals(operationDefinition.getName()))
+                    .collect(Collectors.toList());
             if (matchingOperations.size() != 1) {
                 // Either no matching operation or more than one, either way it's not valid GraphQL
                 return emptySet();