Fix unit tests

Author: oliemansm

src/main/java/graphql/servlet/AbstractGraphQLHttpServlet.java

@@ -1,75 +1,40 @@
 package graphql.servlet;
 
-import static graphql.servlet.HttpRequestHandler.APPLICATION_GRAPHQL;
-import static graphql.servlet.HttpRequestHandler.STATUS_BAD_REQUEST;
-
-import com.google.common.io.ByteStreams;
-import com.google.common.io.CharStreams;
-import graphql.ExecutionResult;
-import graphql.GraphQL;
-import graphql.execution.reactive.SingleSubscriberPublisher;
-import graphql.introspection.IntrospectionQuery;
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.servlet.config.GraphQLConfiguration;
-import graphql.servlet.context.ContextSetting;
 import graphql.servlet.core.GraphQLMBean;
 import graphql.servlet.core.GraphQLObjectMapper;
 import graphql.servlet.core.GraphQLQueryInvoker;
 import graphql.servlet.core.GraphQLServletListener;
 import graphql.servlet.core.internal.GraphQLRequest;
-import graphql.servlet.core.internal.VariableMapper;
-import graphql.servlet.input.BatchInputPreProcessResult;
-import graphql.servlet.input.BatchInputPreProcessor;
-import graphql.servlet.input.GraphQLBatchedInvocationInput;
 import graphql.servlet.input.GraphQLInvocationInputFactory;
-import graphql.servlet.input.GraphQLSingleInvocationInput;
-import java.io.BufferedInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.Writer;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.servlet.AsyncContext;
-import javax.servlet.AsyncEvent;
-import javax.servlet.AsyncListener;
 import javax.servlet.Servlet;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.Part;
 import lombok.extern.slf4j.Slf4j;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
 
 /**
  * @author Andrew Potter
  */
 @Slf4j
 public abstract class AbstractGraphQLHttpServlet extends HttpServlet implements Servlet, GraphQLMBean {
 
-  private static final String[] MULTIPART_KEYS = new String[]{"operations", "graphql", "query"};
   /**
    * @deprecated use {@link #getConfiguration()} instead
    */
   @Deprecated
   private final List<GraphQLServletListener> listeners;
   private GraphQLConfiguration configuration;
-  private HttpRequestHandler getHandler;
-  private HttpRequestHandler postHandler;
+  private HttpRequestHandler requestHandler;
 
   public AbstractGraphQLHttpServlet() {
     this(null);
@@ -114,138 +79,10 @@ protected GraphQLConfiguration getConfiguration() {
 
   @Override
   public void init() {
-    if (configuration != null) {
-      return;
+    if (configuration == null) {
+      this.configuration = getConfiguration();
+      this.requestHandler = new HttpRequestHandlerImpl(configuration);
     }
-    this.configuration = getConfiguration();
-    this.getHandler = new HttpGetRequestHandler(configuration);
-
-    this.postHandler = (request, response) -> {
-      GraphQLInvocationInputFactory invocationInputFactory = configuration.getInvocationInputFactory();
-      GraphQLObjectMapper graphQLObjectMapper = configuration.getObjectMapper();
-      GraphQLQueryInvoker queryInvoker = configuration.getQueryInvoker();
-
-      try {
-        if (APPLICATION_GRAPHQL.equals(request.getContentType())) {
-          String query = CharStreams.toString(request.getReader());
-          query(queryInvoker, graphQLObjectMapper,
-              invocationInputFactory.create(new GraphQLRequest(query, null, null), request, response),
-              request, response);
-        } else if (request.getContentType() != null && request.getContentType().startsWith("multipart/form-data")
-            && !request.getParts().isEmpty()) {
-          final Map<String, List<Part>> fileItems = request.getParts()
-              .stream()
-              .collect(Collectors.groupingBy(Part::getName));
-
-          for (String key : MULTIPART_KEYS) {
-            // Check to see if there is a part under the key we seek
-            if (!fileItems.containsKey(key)) {
-              continue;
-            }
-
-            final Optional<Part> queryItem = getFileItem(fileItems, key);
-            if (!queryItem.isPresent()) {
-              // If there is a part, but we don't see an item, then break and return BAD_REQUEST
-              break;
-            }
-
-            InputStream inputStream = asMarkableInputStream(queryItem.get().getInputStream());
-
-            final Optional<Map<String, List<String>>> variablesMap =
-                getFileItem(fileItems, "map").map(graphQLObjectMapper::deserializeMultipartMap);
-
-            if (isBatchedQuery(inputStream)) {
-              List<GraphQLRequest> graphQLRequests =
-                  graphQLObjectMapper.readBatchedGraphQLRequest(inputStream);
-              variablesMap.ifPresent(map -> graphQLRequests.forEach(r -> mapMultipartVariables(r, map, fileItems)));
-              GraphQLBatchedInvocationInput batchedInvocationInput = invocationInputFactory
-                  .create(configuration.getContextSetting(),
-                      graphQLRequests, request, response);
-              queryBatched(queryInvoker, batchedInvocationInput, request, response, configuration);
-              return;
-            } else {
-              GraphQLRequest graphQLRequest;
-              if ("query".equals(key)) {
-                graphQLRequest = buildRequestFromQuery(inputStream, graphQLObjectMapper, fileItems);
-              } else {
-                graphQLRequest = graphQLObjectMapper.readGraphQLRequest(inputStream);
-              }
-
-              variablesMap.ifPresent(m -> mapMultipartVariables(graphQLRequest, m, fileItems));
-              GraphQLSingleInvocationInput invocationInput =
-                  invocationInputFactory.create(graphQLRequest, request, response);
-              query(queryInvoker, graphQLObjectMapper, invocationInput, request, response);
-              return;
-            }
-          }
-
-          response.setStatus(STATUS_BAD_REQUEST);
-          log.info("Bad POST multipart request: no part named " + Arrays.toString(MULTIPART_KEYS));
-        } else {
-          // this is not a multipart request
-          InputStream inputStream = asMarkableInputStream(request.getInputStream());
-
-          if (isBatchedQuery(inputStream)) {
-            List<GraphQLRequest> requests = graphQLObjectMapper.readBatchedGraphQLRequest(inputStream);
-            GraphQLBatchedInvocationInput batchedInvocationInput =
-                invocationInputFactory.create(configuration.getContextSetting(), requests, request, response);
-            queryBatched(queryInvoker, batchedInvocationInput, request, response, configuration);
-          } else {
-            query(queryInvoker, graphQLObjectMapper,
-                invocationInputFactory.create(graphQLObjectMapper.readGraphQLRequest(inputStream), request, response),
-                request, response);
-          }
-        }
-      } catch (Exception e) {
-        log.info("Bad POST request: parsing failed", e);
-        response.setStatus(STATUS_BAD_REQUEST);
-      }
-    };
-  }
-
-  private InputStream asMarkableInputStream(InputStream inputStream) {
-    if (!inputStream.markSupported()) {
-      return new BufferedInputStream(inputStream);
-    }
-    return inputStream;
-  }
-
-  private GraphQLRequest buildRequestFromQuery(InputStream inputStream,
-      GraphQLObjectMapper graphQLObjectMapper,
-      Map<String, List<Part>> fileItems) throws IOException {
-    GraphQLRequest graphQLRequest;
-    String query = new String(ByteStreams.toByteArray(inputStream));
-
-    Map<String, Object> variables = null;
-    final Optional<Part> variablesItem = getFileItem(fileItems, "variables");
-    if (variablesItem.isPresent()) {
-      variables = graphQLObjectMapper
-          .deserializeVariables(new String(ByteStreams.toByteArray(variablesItem.get().getInputStream())));
-    }
-
-    String operationName = null;
-    final Optional<Part> operationNameItem = getFileItem(fileItems, "operationName");
-    if (operationNameItem.isPresent()) {
-      operationName = new String(ByteStreams.toByteArray(operationNameItem.get().getInputStream())).trim();
-    }
-
-    graphQLRequest = new GraphQLRequest(query, variables, operationName);
-    return graphQLRequest;
-  }
-
-  private void mapMultipartVariables(GraphQLRequest request,
-      Map<String, List<String>> variablesMap,
-      Map<String, List<Part>> fileItems) {
-    Map<String, Object> variables = request.getVariables();
-
-    variablesMap.forEach((partName, objectPaths) -> {
-      Part part = getFileItem(fileItems, partName)
-          .orElseThrow(() -> new RuntimeException("unable to find part name " +
-              partName +
-              " as referenced in the variables map"));
-
-      objectPaths.forEach(objectPath -> VariableMapper.mapVariable(objectPath, variables, part));
-    });
   }
 
   public void addListener(GraphQLServletListener servletListener) {
@@ -320,95 +157,13 @@ private void doRequest(HttpServletRequest request, HttpServletResponse response,
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
     init();
-    doRequestAsync(req, resp, getHandler);
+    doRequestAsync(req, resp, requestHandler);
   }
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
     init();
-    doRequestAsync(req, resp, postHandler);
-  }
-
-  private Optional<Part> getFileItem(Map<String, List<Part>> fileItems, String name) {
-    return Optional.ofNullable(fileItems.get(name)).filter(list -> !list.isEmpty()).map(list -> list.get(0));
-  }
-
-  private void query(GraphQLQueryInvoker queryInvoker, GraphQLObjectMapper graphQLObjectMapper,
-      GraphQLSingleInvocationInput invocationInput,
-      HttpServletRequest req, HttpServletResponse resp) throws IOException {
-    ExecutionResult result = queryInvoker.query(invocationInput);
-
-    boolean isDeferred =
-        Objects.nonNull(result.getExtensions()) && result.getExtensions().containsKey(GraphQL.DEFERRED_RESULTS);
-
-    if (!(result.getData() instanceof Publisher || isDeferred)) {
-      resp.setContentType(APPLICATION_JSON_UTF8);
-      resp.setStatus(STATUS_OK);
-      graphQLObjectMapper.serializeResultAsJson(resp.getWriter(), result);
-    } else {
-      if (req == null) {
-        throw new IllegalStateException("Http servlet request can not be null");
-      }
-      resp.setContentType(APPLICATION_EVENT_STREAM_UTF8);
-      resp.setStatus(STATUS_OK);
-
-      boolean isInAsyncThread = req.isAsyncStarted();
-      AsyncContext asyncContext = isInAsyncThread ? req.getAsyncContext() : req.startAsync(req, resp);
-      asyncContext.setTimeout(configuration.getSubscriptionTimeout());
-      AtomicReference<Subscription> subscriptionRef = new AtomicReference<>();
-      asyncContext.addListener(new SubscriptionAsyncListener(subscriptionRef));
-      ExecutionResultSubscriber subscriber = new ExecutionResultSubscriber(subscriptionRef, asyncContext,
-          graphQLObjectMapper);
-      List<Publisher<ExecutionResult>> publishers = new ArrayList<>();
-      if (result.getData() instanceof Publisher) {
-        publishers.add(result.getData());
-      } else {
-        publishers.add(new StaticDataPublisher<>(result));
-        final Publisher<ExecutionResult> deferredResultsPublisher = (Publisher<ExecutionResult>) result.getExtensions()
-            .get(GraphQL.DEFERRED_RESULTS);
-        publishers.add(deferredResultsPublisher);
-      }
-      publishers.forEach(it -> it.subscribe(subscriber));
-
-      if (isInAsyncThread) {
-        // We need to delay the completion of async context until after the subscription has terminated, otherwise the AsyncContext is prematurely closed.
-        try {
-          subscriber.await();
-        } catch (InterruptedException e) {
-          Thread.currentThread().interrupt();
-        }
-      }
-    }
-  }
-
-  private void queryBatched(GraphQLQueryInvoker queryInvoker, GraphQLBatchedInvocationInput batchedInvocationInput,
-      HttpServletRequest request,
-      HttpServletResponse response, GraphQLConfiguration configuration) throws IOException {
-    BatchInputPreProcessor batchInputPreProcessor = configuration.getBatchInputPreProcessor();
-    ContextSetting contextSetting = configuration.getContextSetting();
-    BatchInputPreProcessResult batchInputPreProcessResult = batchInputPreProcessor
-        .preProcessBatch(batchedInvocationInput, request, response);
-    if (batchInputPreProcessResult.isExecutable()) {
-      List<ExecutionResult> results = queryInvoker
-          .query(batchInputPreProcessResult.getBatchedInvocationInput().getExecutionInputs(),
-              contextSetting);
-      response.setContentType(AbstractGraphQLHttpServlet.APPLICATION_JSON_UTF8);
-      response.setStatus(AbstractGraphQLHttpServlet.STATUS_OK);
-      Writer writer = response.getWriter();
-      Iterator<ExecutionResult> executionInputIterator = results.iterator();
-      writer.write("[");
-      GraphQLObjectMapper graphQLObjectMapper = configuration.getObjectMapper();
-      while (executionInputIterator.hasNext()) {
-        String result = graphQLObjectMapper.serializeResultAsJson(executionInputIterator.next());
-        writer.write(result);
-        if (executionInputIterator.hasNext()) {
-          writer.write(",");
-        }
-      }
-      writer.write("]");
-    } else {
-      response.sendError(batchInputPreProcessResult.getStatusCode(), batchInputPreProcessResult.getStatusMessage());
-    }
+    doRequestAsync(req, resp, requestHandler);
   }
 
   private <R> List<R> runListeners(Function<? super GraphQLServletListener, R> action) {
@@ -435,35 +190,4 @@ private <T> void runCallbacks(List<T> callbacks, Consumer<T> action) {
     });
   }
 
-  private boolean isBatchedQuery(InputStream inputStream) throws IOException {
-    if (inputStream == null) {
-      return false;
-    }
-
-    final int BUFFER_SIZE = 128;
-    ByteArrayOutputStream result = new ByteArrayOutputStream();
-    byte[] buffer = new byte[BUFFER_SIZE];
-    int length;
-
-    inputStream.mark(BUFFER_SIZE);
-    while ((length = inputStream.read(buffer)) != -1) {
-      result.write(buffer, 0, length);
-      if (isArrayStart(result.toString())) {
-        inputStream.reset();
-        return true;
-      }
-    }
-
-    inputStream.reset();
-    return false;
-  }
-
-  private boolean isBatchedQuery(String query) {
-    return isArrayStart(query);
-  }
-
-  private boolean isArrayStart(String s) {
-    return s != null && s.trim().startsWith("[");
-  }
-
 }

src/main/java/graphql/servlet/AbstractGraphQLInvocationInputParser.java

@@ -0,0 +1,23 @@
+package graphql.servlet;
+
+import graphql.servlet.context.ContextSetting;
+import graphql.servlet.core.GraphQLObjectMapper;
+import graphql.servlet.input.GraphQLInvocationInputFactory;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+abstract class AbstractGraphQLInvocationInputParser implements GraphQLInvocationInputParser {
+
+  final GraphQLInvocationInputFactory invocationInputFactory;
+  final GraphQLObjectMapper graphQLObjectMapper;
+  final ContextSetting contextSetting;
+
+  boolean isSingleQuery(String query) {
+    return !isArrayStart(query);
+  }
+
+  private boolean isArrayStart(String s) {
+    return s != null && s.trim().startsWith("[");
+  }
+
+}